From d2a5d27c94aa1089ba52847393f12c3ef6a22562 Mon Sep 17 00:00:00 2001
From: Richard McDaniel <1130888+rmcdaniel@users.noreply.github.com>
Date: Sun, 25 Oct 2026 01:19:40 +0000
Subject: [PATCH 1/9] Server parity: Waterline v1 projection import fixture,
 recorded from published 2.11.1

POST /api/workflows/import/waterline-v1 (LegacyV1ProjectionController and
LegacyV1Projection) from v1 flow-detail templates, in the probe's own
namespaces:

- The request gates, Laravel validation, and each normalization refusal,
  alone and together.
- operator_id precedence over id, and a dry run that writes nothing.
- The projection with idempotent, trimmed, changed and cross-namespace
  repeats.
- Every v1 status, timestamp offsets and unparseable times, unusable rows,
  signal-name fallbacks, and the fewest accepted fields.
- A native identity collision from another namespace.
- The projected runs through describe, run, runs, history, history export
  and list.
- The read-only refusal of signal, query, update, cancel, terminate,
  repair, archive, redrive and cooperative cancellation, on running and
  completed projections.

Projected identities are hashes of the source id, which carries the
recording prefix, so the probe computes them as mappedIdentity does and
records them, their event ids, dedupe keys, export checksums and
import-time sort keys as labels. Import and export times are placeholders.
Status projections get distinct source times, so the list order does not
depend on hashed ids.

Two export details are made target- and prefix-independent:

- The summary's history size is recorded without the bytes the prefix
  contributes.
- The probe recomputes each export's checksum over PHP's canonical JSON of
  the bundle and records whether it matches. Timeline, wait and
  projection-source reporting belong to the general history export and are
  left out.

Recorded three times under prefixes of 2, 7 and 9 characters, identical.

Stream items and close are left out until native serves those routes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/server-parity.yml           |     4 +-
 .../conformance/server-parity/contract.mjs    |     3 +
 scripts/conformance/server-parity/probe.php   |     6 +
 .../waterline-import-contract.mjs             |    25 +
 .../server-parity/waterline-import-probe.php  |   324 +
 .../ServerParity/waterline-import.json        | 10752 ++++++++++++++++
 .../waterline-import-observation.json         | 10634 +++++++++++++++
 ...erverParityWaterlineImportContractTest.mjs |   100 +
 8 files changed, 21847 insertions(+), 1 deletion(-)
 create mode 100644 scripts/conformance/server-parity/waterline-import-contract.mjs
 create mode 100644 scripts/conformance/server-parity/waterline-import-probe.php
 create mode 100644 tests/Fixtures/ServerParity/waterline-import.json
 create mode 100644 tests/Fixtures/ServerParityExpected/waterline-import-observation.json
 create mode 100644 tests/Unit/ServerParityWaterlineImportContractTest.mjs

diff --git a/.github/workflows/server-parity.yml b/.github/workflows/server-parity.yml
index ac9285b2b..0be764cc3 100644
--- a/.github/workflows/server-parity.yml
+++ b/.github/workflows/server-parity.yml
@@ -37,6 +37,7 @@ on:
       - tests/Unit/ServerParityActivityLeaseRenewalContractTest.mjs
       - tests/Unit/ServerParityServiceCatalogContractTest.mjs
       - tests/Unit/ServerParityWorkflowImportContractTest.mjs
+      - tests/Unit/ServerParityWaterlineImportContractTest.mjs
       - tests/Unit/ServerParitySystemMetricsContractTest.mjs
       - tests/Unit/ServerParityOperatorDashboardTypesContractTest.mjs
       - tests/Unit/ServerParityPrometheusMetricsContractTest.mjs
@@ -94,6 +95,7 @@ on:
       - tests/Unit/ServerParityActivityLeaseRenewalContractTest.mjs
       - tests/Unit/ServerParityServiceCatalogContractTest.mjs
       - tests/Unit/ServerParityWorkflowImportContractTest.mjs
+      - tests/Unit/ServerParityWaterlineImportContractTest.mjs
       - tests/Unit/ServerParitySystemMetricsContractTest.mjs
       - tests/Unit/ServerParityOperatorDashboardTypesContractTest.mjs
       - tests/Unit/ServerParityPrometheusMetricsContractTest.mjs
@@ -1531,7 +1533,7 @@ jobs:
             -e COMPOSER_HOME=/tmp/composer -v "$PWD:/source" -w /source "$image" \
             install --working-dir=scripts/conformance/server-parity --no-interaction --no-progress
           docker run --rm --user=1000:1000 --entrypoint node -v "$PWD:/source:ro" -w /source \
-            "$image" --test tests/Unit/ServerParityRunnerTest.mjs tests/Unit/ServerParityCooperativeContractTest.mjs tests/Unit/ServerParityChildCancellationContractTest.mjs tests/Unit/ServerParityScheduleContractTest.mjs tests/Unit/ServerParityVisibilityContractTest.mjs tests/Unit/ServerParityAdmissionContractTest.mjs tests/Unit/ServerParityRoleTokenContractTest.mjs tests/Unit/ServerParityWorkerDeregistrationContractTest.mjs tests/Unit/ServerParitySearchAttributeContractTest.mjs tests/Unit/ServerParityWorkerListingContractTest.mjs tests/Unit/ServerParityWorkerReplacementContractTest.mjs tests/Unit/ServerParityPatchDeploymentContractTest.mjs tests/Unit/ServerParityWaitingHistoryContractTest.mjs tests/Unit/ServerParityTaskRetryContractTest.mjs tests/Unit/ServerParityPublishedPatchContractTest.mjs tests/Unit/ServerParityPublishedPatchTransportTest.mjs tests/Unit/ServerParityRecordFileTest.mjs tests/Unit/ServerParityLateWorkflowCompletionContractTest.mjs tests/Unit/ServerParityStorageTestContractTest.mjs tests/Unit/ServerParitySchedulePoliciesContractTest.mjs tests/Unit/ServerParitySignalsBeforeWorkerContractTest.mjs tests/Unit/ServerParityScheduleCatalogContractTest.mjs tests/Unit/ServerParityOperatorMetricsContractTest.mjs tests/Unit/ServerParityActivityLeaseRenewalContractTest.mjs tests/Unit/ServerParityServiceCatalogContractTest.mjs tests/Unit/ServerParityWorkflowImportContractTest.mjs tests/Unit/ServerParitySystemMetricsContractTest.mjs tests/Unit/ServerParityOperatorDashboardTypesContractTest.mjs tests/Unit/ServerParityPrometheusMetricsContractTest.mjs tests/Unit/ServerParityPayloadCleanupContractTest.mjs tests/Unit/ServerParityRepairPassContractTest.mjs tests/Unit/ServerParityClusterInfoContractTest.mjs tests/Unit/ServerParityNamespaceDeleteContractTest.mjs > parity-evidence/comparator-tests.txt
+            "$image" --test tests/Unit/ServerParityRunnerTest.mjs tests/Unit/ServerParityCooperativeContractTest.mjs tests/Unit/ServerParityChildCancellationContractTest.mjs tests/Unit/ServerParityScheduleContractTest.mjs tests/Unit/ServerParityVisibilityContractTest.mjs tests/Unit/ServerParityAdmissionContractTest.mjs tests/Unit/ServerParityRoleTokenContractTest.mjs tests/Unit/ServerParityWorkerDeregistrationContractTest.mjs tests/Unit/ServerParitySearchAttributeContractTest.mjs tests/Unit/ServerParityWorkerListingContractTest.mjs tests/Unit/ServerParityWorkerReplacementContractTest.mjs tests/Unit/ServerParityPatchDeploymentContractTest.mjs tests/Unit/ServerParityWaitingHistoryContractTest.mjs tests/Unit/ServerParityTaskRetryContractTest.mjs tests/Unit/ServerParityPublishedPatchContractTest.mjs tests/Unit/ServerParityPublishedPatchTransportTest.mjs tests/Unit/ServerParityRecordFileTest.mjs tests/Unit/ServerParityLateWorkflowCompletionContractTest.mjs tests/Unit/ServerParityStorageTestContractTest.mjs tests/Unit/ServerParitySchedulePoliciesContractTest.mjs tests/Unit/ServerParitySignalsBeforeWorkerContractTest.mjs tests/Unit/ServerParityScheduleCatalogContractTest.mjs tests/Unit/ServerParityOperatorMetricsContractTest.mjs tests/Unit/ServerParityActivityLeaseRenewalContractTest.mjs tests/Unit/ServerParityServiceCatalogContractTest.mjs tests/Unit/ServerParityWorkflowImportContractTest.mjs tests/Unit/ServerParityWaterlineImportContractTest.mjs tests/Unit/ServerParitySystemMetricsContractTest.mjs tests/Unit/ServerParityOperatorDashboardTypesContractTest.mjs tests/Unit/ServerParityPrometheusMetricsContractTest.mjs tests/Unit/ServerParityPayloadCleanupContractTest.mjs tests/Unit/ServerParityRepairPassContractTest.mjs tests/Unit/ServerParityClusterInfoContractTest.mjs tests/Unit/ServerParityNamespaceDeleteContractTest.mjs > parity-evidence/comparator-tests.txt
           docker run --rm --user=1000:1000 --cpus=1 --memory=256m --memory-swap=256m \
             --network=none --entrypoint node -v "$PWD:/source:ro" -w /source \
             "$image" --test tests/Unit/ServerParityCodecDeadlineLoadTest.mjs > parity-evidence/codec-load-tests.txt
diff --git a/scripts/conformance/server-parity/contract.mjs b/scripts/conformance/server-parity/contract.mjs
index 0d3bc1be4..bb4d51a63 100644
--- a/scripts/conformance/server-parity/contract.mjs
+++ b/scripts/conformance/server-parity/contract.mjs
@@ -15,6 +15,7 @@ import {checkStorageTest} from './storage-test-contract.mjs';
 import {checkActivityLeaseRenewal} from './activity-lease-renewal-contract.mjs';
 import {checkServiceCatalog} from './service-catalog-contract.mjs';
 import {checkWorkflowImport} from './workflow-import-contract.mjs';
+import {checkWaterlineImport} from './waterline-import-contract.mjs';
 import {checkSystemMetrics} from './system-metrics-contract.mjs';
 import {checkOperatorDashboardTypes} from './operator-dashboard-types-contract.mjs';
 import {checkPrometheusMetrics} from './prometheus-metrics-contract.mjs';
@@ -154,6 +155,7 @@ export function checkObservation(fixture, observation, workflowId, artifacts) {
   const activityLeaseRenewal = fixture.activity_lease_renewal ? checkActivityLeaseRenewal(fixture, observation, workflowId) : null;
   const serviceCatalog = fixture.service_catalog ? checkServiceCatalog(fixture, observation, workflowId) : null;
   const workflowImport = fixture.workflow_import ? checkWorkflowImport(fixture, observation, workflowId) : null;
+  const waterlineImport = fixture.waterline_import ? checkWaterlineImport(fixture, observation, workflowId) : null;
   const systemMetrics = fixture.system_metrics ? checkSystemMetrics(fixture, observation, workflowId) : null;
   const operatorDashboardTypes = fixture.operator_dashboard_types ? checkOperatorDashboardTypes(fixture, observation, workflowId) : null;
   const prometheusMetrics = fixture.prometheus_metrics ? checkPrometheusMetrics(fixture, observation, workflowId) : null;
@@ -710,6 +712,7 @@ export function checkObservation(fixture, observation, workflowId, artifacts) {
     ...(activityLeaseRenewal ? {activity_lease_renewal: activityLeaseRenewal} : {}),
     ...(serviceCatalog ? {service_catalog: serviceCatalog} : {}),
     ...(workflowImport ? {workflow_import: workflowImport} : {}),
+    ...(waterlineImport ? {waterline_import: waterlineImport} : {}),
     ...(systemMetrics ? {system_metrics: systemMetrics} : {}),
     ...(operatorDashboardTypes ? {operator_dashboard_types: operatorDashboardTypes} : {}),
     ...(prometheusMetrics ? {prometheus_metrics: prometheusMetrics} : {}),
diff --git a/scripts/conformance/server-parity/probe.php b/scripts/conformance/server-parity/probe.php
index e8da666f4..409f3b6d5 100644
--- a/scripts/conformance/server-parity/probe.php
+++ b/scripts/conformance/server-parity/probe.php
@@ -433,6 +433,7 @@ function httpObservation(array $fixture, string $workflowId, string $namespace,
     $activityLeaseRenewal = isset($fixture['activity_lease_renewal']) ? finishHttpActivityLeaseRenewal($client, $fixture, $workflowId, $url) : null;
     $serviceCatalog = isset($fixture['service_catalog']) ? finishHttpServiceCatalog($client, $fixture, $workflowId, $url) : null;
     $workflowImport = isset($fixture['workflow_import']) ? finishHttpWorkflowImport($client, $fixture, $workflowId, $url) : null;
+    $waterlineImport = isset($fixture['waterline_import']) ? finishHttpWaterlineImport($client, $fixture, $workflowId, $url) : null;
     $systemMetrics = isset($fixture['system_metrics']) ? finishHttpSystemMetrics($client, $fixture, $workflowId, $url) : null;
     $operatorDashboardTypes = isset($fixture['operator_dashboard_types']) ? finishHttpOperatorDashboardTypes($client, $fixture, $workflowId, $url) : null;
     $prometheusMetrics = isset($fixture['prometheus_metrics']) ? finishHttpPrometheusMetrics($client, $fixture, $workflowId, $url) : null;
@@ -542,6 +543,7 @@ function httpObservation(array $fixture, string $workflowId, string $namespace,
         'activity_lease_renewal' => $activityLeaseRenewal,
         'service_catalog' => $serviceCatalog,
         'workflow_import' => $workflowImport,
+        'waterline_import' => $waterlineImport,
         'system_metrics' => $systemMetrics,
         'operator_dashboard_types' => $operatorDashboardTypes,
         'prometheus_metrics' => $prometheusMetrics,
@@ -855,6 +857,7 @@ function embeddedObservation(array $fixture, string $workflowId, string $namespa
     require __DIR__.'/activity-lease-renewal-probe.php';
     require __DIR__.'/service-catalog-probe.php';
     require __DIR__.'/workflow-import-probe.php';
+    require __DIR__.'/waterline-import-probe.php';
     require __DIR__.'/system-metrics-probe.php';
     require __DIR__.'/operator-dashboard-types-probe.php';
     require __DIR__.'/prometheus-metrics-probe.php';
@@ -1029,6 +1032,9 @@ function embeddedObservation(array $fixture, string $workflowId, string $namespa
     if ($mode === 'embedded' && isset($fixture['workflow_import'])) {
         $observation['workflow_import'] = ['applicable' => false, 'reason' => 'embedded_has_no_http_workflow_import'];
     }
+    if ($mode === 'embedded' && isset($fixture['waterline_import'])) {
+        $observation['waterline_import'] = ['applicable' => false, 'reason' => 'embedded_has_no_http_waterline_import'];
+    }
     if ($mode === 'embedded' && isset($fixture['system_metrics'])) {
         $observation['system_metrics'] = ['applicable' => false, 'reason' => 'embedded_has_no_http_metrics'];
     }
diff --git a/scripts/conformance/server-parity/waterline-import-contract.mjs b/scripts/conformance/server-parity/waterline-import-contract.mjs
new file mode 100644
index 000000000..4f9bf6255
--- /dev/null
+++ b/scripts/conformance/server-parity/waterline-import-contract.mjs
@@ -0,0 +1,25 @@
+import assert from 'node:assert/strict';
+
+// Waterline v1 projection import (LegacyV1ProjectionController), recorded
+// against published Server 2.11.1. The fixture's `expected` holds the whole
+// normalized observation, with the probe's workflow prefix as `{id}`,
+// projected identities, event ids, dedupe keys and export checksums as
+// `{<label>.<token>}` labels, and import and export times as placeholders.
+// Every step compares exactly.
+export function checkWaterlineImport(fixture, observation, workflowId) {
+  const state = observation.waterline_import;
+  const projection = {scope: 'waterline_import'};
+  assert.ok(state && typeof state === 'object', 'actual waterline import observation');
+  if (observation.mode === 'embedded') {
+    assert.deepStrictEqual(state, {applicable: false, reason: 'embedded_has_no_http_waterline_import'},
+      'embedded waterline import explicitly inapplicable');
+    return projection;
+  }
+  const definition = fixture.waterline_import;
+  const actual = JSON.parse(JSON.stringify(state).replaceAll(workflowId, '{id}'));
+  for (const [step, expected] of Object.entries(definition.expected)) {
+    assert.deepStrictEqual(actual[step], expected, `waterline import ${step}`);
+  }
+  assert.deepStrictEqual(Object.keys(actual).sort(), Object.keys(definition.expected).sort(), 'waterline import steps');
+  return projection;
+}
diff --git a/scripts/conformance/server-parity/waterline-import-probe.php b/scripts/conformance/server-parity/waterline-import-probe.php
new file mode 100644
index 000000000..3dc6d5991
--- /dev/null
+++ b/scripts/conformance/server-parity/waterline-import-probe.php
@@ -0,0 +1,324 @@
+<?php
+
+declare(strict_types=1);
+
+use DurableWorkflow\Client;
+use GuzzleHttp\Client as WaterlineImportHttp;
+use GuzzleHttp\HandlerStack;
+
+// Waterline v1 projection import (POST /api/workflows/import/waterline-v1)
+// over raw HTTP in fresh namespaces: the request gates, validation, each
+// normalization refusal, a dry run, projections of every v1 status,
+// idempotent, changed and cross-namespace repeats, a native identity
+// collision, the projected runs through describe, runs, history, history
+// export and list, and the read-only refusals of every control operation.
+//
+// Sources come from the fixture's templates, Waterline v1 flow details.
+// Projected identities are deterministic hashes of the source id, which
+// carries this recording's prefix, so the probe computes them as
+// LegacyV1Projection::mappedIdentity does and records each as a label, with
+// its event ids. Dedupe keys and export checksums are labelled where first
+// seen; import and export times are placeholders.
+function finishHttpWaterlineImport(Client $admin, array $fixture, string $workflowId, string $url): array
+{
+    $definition = $fixture['waterline_import'];
+    $namespace = strtolower($workflowId.'-wl1');
+    $alt = strtolower($workflowId.'-wl1alt');
+    $other = strtolower($workflowId.'-wl1native');
+    $admin->createNamespace($namespace, 'waterline import λ', 30);
+    $admin->createNamespace($alt, 'waterline import alt', 30);
+    $admin->createNamespace($other, 'waterline import native', 30);
+    $token = getenv('DW_PARITY_TOKEN') ?: null;
+    $stack = HandlerStack::create();
+    $stack->push(LockPressurePollRetries::middleware(), 'lock_pressure_poll_retry');
+    $http = new WaterlineImportHttp(['base_uri' => rtrim($url, '/'), 'http_errors' => false,
+        'connect_timeout' => 1, 'timeout' => 30, 'handler' => $stack]);
+
+    // One raw request. Options: namespace, auth (false drops the token),
+    // version (a header value, or false to drop it), and raw (a literal
+    // body) with content_type.
+    $raw = static function (string $method, string $path, mixed $body = null, array $options = []) use ($http, $token, $namespace): array {
+        $version = array_key_exists('version', $options) ? $options['version'] : '2';
+        $headers = array_filter(['Authorization' => ($options['auth'] ?? true) && $token !== null ? 'Bearer '.$token : null,
+            'Accept' => 'application/json', 'X-Namespace' => $options['namespace'] ?? $namespace,
+            'X-Durable-Workflow-Control-Plane-Version' => $version === false ? null : $version], static fn ($value) => $value !== null);
+        $request = ['headers' => $headers];
+        if (array_key_exists('raw', $options)) {
+            $request['headers']['Content-Type'] = $options['content_type'] ?? 'application/json';
+            $request['body'] = $options['raw'];
+        } elseif ($body !== null) {
+            $request['json'] = $body;
+        }
+        $response = $http->request($method, $path, $request);
+
+        return ['status' => $response->getStatusCode(), 'response' => json_decode((string) $response->getBody(), true)];
+    };
+
+    // LegacyV1Projection::mappedIdentity, with Laravel's Str::lower,
+    // replaceMatches, trim and limit(32, '').
+    $sourceId = $workflowId;
+    $mapped = static function (string $source, string $qualified): array {
+        $key = trim($source)."\0".trim($qualified);
+        $slug = trim((string) preg_replace('/[^a-z0-9._-]+/', '-', mb_strtolower($source, 'UTF-8')), '-');
+        if (mb_strwidth($slug, 'UTF-8') > 32) {
+            $slug = rtrim(mb_strimwidth($slug, 0, 32, '', 'UTF-8'));
+        }
+        $slug = $slug === '' ? 'source' : $slug;
+
+        return [
+            'workflow_id' => 'v1:'.$slug.':'.substr(hash('sha256', 'workflow'."\0".$key), 0, 24),
+            'run_id' => substr(hash('sha256', 'run'."\0".$key), 0, 26),
+            'import_id' => hash('sha256', 'import'."\0".$key),
+        ];
+    };
+
+    // BundleIntegrityVerifier::canonicalJson: lists keep their order, maps
+    // are key-sorted as strings, with unescaped slashes and preserved zero
+    // fractions.
+    $canonicalize = static function (mixed $value) use (&$canonicalize): mixed {
+        if (! is_array($value)) {
+            return $value;
+        }
+        if (array_is_list($value)) {
+            return array_map($canonicalize, $value);
+        }
+        $sorted = [];
+        foreach ($value as $key => $item) {
+            $sorted[$key] = $canonicalize($item);
+        }
+        ksort($sorted, SORT_STRING);
+
+        return $sorted;
+    };
+    $canonical = static fn (array $bundle): string => json_encode($canonicalize($bundle),
+        JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION | JSON_THROW_ON_ERROR);
+
+    // Labels for every projected identity, its event ids and its dedupe key.
+    $labels = [];
+    $identities = [];
+    $identity = static function (string $label, string $qualified, ?string $source = null) use (&$labels, &$identities, $mapped, $sourceId): array {
+        $ids = $mapped($source ?? $sourceId, $qualified);
+        if (! isset($identities[$label])) {
+            $identities[$label] = $ids;
+            $labels[$ids['workflow_id']] = '{'.$label.'.workflow}';
+            $labels[$ids['run_id']] = '{'.$label.'.run}';
+            $labels[$ids['import_id']] = '{'.$label.'.import}';
+            foreach (['WorkflowStarted', 'ActivityCompleted', 'SignalReceived', 'ActivityFailed', 'WorkflowCompleted',
+                'WorkflowFailed', 'WorkflowCancelled', 'WorkflowTerminated'] as $type) {
+                for ($sequence = 1; $sequence <= 12; $sequence++) {
+                    $labels[substr(hash('sha256', $ids['run_id']."\0".$sequence."\0".$type), 0, 26)] = '{'.$label.'.e'.$sequence.'}';
+                }
+            }
+        }
+
+        return $ids;
+    };
+    // A v1 flow detail from template $template for label $label, with
+    // qualified id v1:$legacy. Options: mutate (after the identity is set).
+    $source = static function (string $template, string $label, string $legacy, array $options = []) use ($definition, $identity): array {
+        $document = $definition['sources'][$template];
+        $document['id'] = 'v1:'.$legacy;
+        $document['operator_id'] = 'v1:'.$legacy;
+        $document['legacy_id'] = $legacy;
+        $identity($label, 'v1:'.$legacy, $options['source_id'] ?? null);
+        if (isset($options['mutate'])) {
+            $options['mutate']($document);
+        }
+
+        return $document;
+    };
+    // A projection report or other recorded answer: import and export times
+    // become placeholders, and each new dedupe key or export checksum becomes
+    // a label for $label.
+    $placeholders = static function (mixed $value) use (&$placeholders): mixed {
+        if (! is_array($value)) {
+            return $value;
+        }
+        foreach ($value as $key => $item) {
+            if (in_array($key, ['imported_at', 'exported_at'], true) && is_string($item)
+                && preg_match('/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(\.\d{1,6})?(Z|[+-]\d\d:\d\d)$/', $item)) {
+                $value[$key] = '{'.$key.'}';
+            } else {
+                $value[$key] = $placeholders($item);
+            }
+        }
+
+        return $value;
+    };
+    $record = static function (array $recorded, ?string $label = null) use (&$labels, $placeholders): array {
+        $body = $recorded['response'];
+        if ($label !== null && is_string($body['dedupe_key'] ?? null) && ! isset($labels[$body['dedupe_key']])) {
+            $labels[$body['dedupe_key']] = '{'.$label.'.dedupe}';
+        }
+        // A projection without source times sorts and exports by its import
+        // time, so that time is a label wherever else it appears.
+        if ($label !== null && $recorded['status'] === 201 && is_string($body['imported_at'] ?? null)) {
+            $labels[$body['imported_at']] ??= '{'.$label.'.imported_at}';
+        }
+
+        return ['status' => $recorded['status'], 'response' => $placeholders($body)];
+    };
+    // The published SQLite reference shares its file with its maintenance
+    // loop and may refuse a lock upgrade, which the projection reports as
+    // target_write_failed. Nothing was committed, so only that answer is
+    // retried, and each retry is reported on stderr.
+    $project = static function (mixed $body, ?string $label = null, array $options = []) use ($raw, $record): array {
+        for ($attempt = 1; ; $attempt++) {
+            $recorded = $raw('POST', '/api/workflows/import/waterline-v1', $body, $options);
+            if ($attempt >= 10 || ($recorded['response']['reason'] ?? null) !== 'target_write_failed') {
+                return $record($recorded, $label);
+            }
+            fwrite(STDERR, json_encode(['waterline_import_lock_retry' => $attempt], JSON_THROW_ON_ERROR).PHP_EOL);
+            usleep(250_000);
+        }
+    };
+    $state = ['applicable' => true, 'namespace' => $namespace, 'alternate_namespace' => $alt, 'native_namespace' => $other,
+        'source_id' => $sourceId];
+
+    // Gates, before the controller.
+    $state['gate_unauthenticated'] = $project([], null, ['auth' => false]);
+    $state['gate_missing_version'] = $project([], null, ['version' => false]);
+    $state['gate_unsupported_version'] = $project([], null, ['version' => '3']);
+    $state['gate_unknown_namespace'] = $project([], null, ['namespace' => $workflowId.'-missing']);
+    $state['gate_text_plain'] = $project(null, null, ['raw' => 'workflow', 'content_type' => 'text/plain']);
+    $state['gate_malformed_json'] = $project(null, null, ['raw' => '{bad']);
+
+    // Validation: source_id required|string|max:64, workflow required|array,
+    // dry_run nullable|boolean, after Laravel trims and nulls every string.
+    $completed = $source('completed', 'completed', '4101');
+    $state['validate_empty'] = $project([]);
+    $state['validate_source_id_blank'] = $project(['source_id' => '   ', 'workflow' => $completed]);
+    $state['validate_source_id_number'] = $project(['source_id' => 4101, 'workflow' => $completed]);
+    $state['validate_source_id_long'] = $project(['source_id' => str_repeat('s', 65), 'workflow' => $completed]);
+    $state['validate_workflow_empty'] = $project(['source_id' => $sourceId, 'workflow' => []]);
+    $state['validate_workflow_string'] = $project(['source_id' => $sourceId, 'workflow' => 'v1:4101']);
+    $state['validate_dry_run'] = $project(['source_id' => $sourceId, 'workflow' => $completed, 'dry_run' => 'yes']);
+
+    // Normalization refusals, each alone and then all at once.
+    $state['reject_source_id'] = $project(['source_id' => 'legacy prod/us', 'workflow' => $completed]);
+    $state['reject_unqualified'] = $project(['source_id' => $sourceId, 'workflow' => array_merge($completed, ['operator_id' => '4101', 'id' => '4101', 'legacy_id' => null])]);
+    $state['reject_mismatch'] = $project(['source_id' => $sourceId, 'workflow' => array_merge($completed, ['legacy_id' => 4102])]);
+    $state['reject_engine'] = $project(['source_id' => $sourceId, 'workflow' => array_merge($completed, ['engine_source' => 'v2'])]);
+    $state['reject_class'] = $project(['source_id' => $sourceId, 'workflow' => array_merge($completed, ['class' => '  '])]);
+    $state['reject_status'] = $project(['source_id' => $sourceId, 'workflow' => array_merge($completed, ['status' => 'paused'])]);
+    $state['reject_all'] = $project(['source_id' => 'bad id!', 'workflow' => ['operator_id' => 'x', 'legacy_id' => 9, 'status' => 'odd', 'engine_source' => 'v1.5']]);
+    // operator_id wins over id.
+    $state['operator_id_first'] = $project(['source_id' => $sourceId, 'workflow' => array_merge($completed, ['id' => 'v1:9999']), 'dry_run' => true], 'completed');
+
+    // A dry run writes nothing.
+    $state['dry_run'] = $project(['source_id' => $sourceId, 'workflow' => $completed, 'dry_run' => true], 'completed');
+    $state['dry_run_describe'] = $record($raw('GET', '/api/workflows/'.rawurlencode($identities['completed']['workflow_id'])));
+
+    // The projection and its repeats.
+    $state['project'] = $project(['source_id' => $sourceId, 'workflow' => $completed, 'dry_run' => false], 'completed');
+    $state['repeat'] = $project(['source_id' => $sourceId, 'workflow' => $completed], 'completed');
+    $state['repeat_dry_run'] = $project(['source_id' => $sourceId, 'workflow' => $completed, 'dry_run' => 1], 'completed');
+    // Trimmed strings and ignored fields leave the dedupe key unchanged.
+    $state['repeat_trimmed'] = $project(['source_id' => ' '.$sourceId.' ', 'workflow' => array_merge($completed,
+        ['class' => ' '.$completed['class'].' ', 'chart_data' => [], 'extra' => 'ignored'])], 'completed');
+    $state['changed'] = $project(['source_id' => $sourceId, 'workflow' => array_merge($completed, ['output' => 's:7:"changed";'])], 'changed');
+    $state['other_namespace'] = $project(['source_id' => $sourceId, 'workflow' => $completed], 'completed', ['namespace' => $alt]);
+
+    // Every v1 status, and the timestamp rules.
+    $states = ['created' => 'pending', 'pending' => 'pending', 'waiting' => 'waiting', 'failed' => 'failed',
+        'cancelled' => 'cancelled', 'terminated' => 'terminated', 'continued' => 'continued'];
+    foreach ($states as $v1 => $label) {
+        $state['status_'.$v1] = $project(['source_id' => $sourceId, 'workflow' => $source('completed', 'status-'.$v1,
+            '43'.str_pad((string) array_search($v1, array_keys($states), true), 2, '0', STR_PAD_LEFT),
+            ['mutate' => static function (array &$document) use ($v1, $states): void {
+                // Distinct times keep the list order independent of the hashed ids.
+                $minute = array_search($v1, array_keys($states), true);
+                $document['status'] = strtoupper($v1);
+                $document['created_at'] = sprintf('2026-09-30T07:%02d:00.000000Z', $minute);
+                $document['updated_at'] = sprintf('2026-09-30T07:%02d:30.000000Z', $minute);
+            }])], 'status-'.$v1);
+    }
+    $running = $source('running', 'running', '4201');
+    $state['running'] = $project(['source_id' => $sourceId, 'workflow' => $running], 'running');
+    $state['offsets'] = $project(['source_id' => $sourceId, 'workflow' => $source('completed', 'offsets', '4401', ['mutate' => static function (array &$document): void {
+        $document['created_at'] = '2026-09-30T10:00:00+02:00';
+        $document['updated_at'] = 'not a time';
+        $document['logs'][] = 'not a row';
+        $document['logs'][] = ['id' => 9003, 'class' => 'App\\Activities\\Untimed', 'result' => ['array' => 'value']];
+        $document['signals'][0]['created_at'] = null;
+        $document['signals'][0]['received_at'] = '2026-09-30T08:00:00.500000Z';
+        $document['signals'][] = ['id' => 7002, 'name' => 'named', 'method' => 'ignored'];
+        unset($document['arguments'], $document['connection']);
+    }])], 'offsets');
+    // The fewest fields a projection accepts.
+    $identity('bare', 'v1:4501');
+    $state['bare'] = $project(['source_id' => $sourceId, 'workflow' => ['operator_id' => 'v1:4501', 'engine_source' => 'v1',
+        'class' => 'App\\Workflows\\Legacy\\Bare', 'status' => 'completed']], 'bare');
+
+    // A native execution already owns the mapped identity. Workflow and run
+    // ids are global, so it collides from its own namespace too.
+    $collision = $identity('collision', 'v1:4601');
+    $native = $raw('POST', '/api/workflows', ['workflow_id' => $collision['workflow_id'], 'workflow_type' => 'parity.v1.echo',
+        'task_queue' => strtolower($workflowId.'-wl1-native')], ['namespace' => $other]);
+    $state['native_start_status'] = $native['status'];
+    $state['native_collision'] = $project(['source_id' => $sourceId, 'workflow' => $source('completed', 'collision', '4601')], 'collision');
+
+    // The projected runs read as published 2.11.1 shows them.
+    foreach (['completed' => 'project', 'running' => 'running', 'status-failed' => 'failed', 'offsets' => 'offsets', 'bare' => 'bare'] as $label => $name) {
+        $ids = $identities[$label];
+        $instance = '/api/workflows/'.rawurlencode($ids['workflow_id']);
+        $run = $instance.'/runs/'.$ids['run_id'];
+        $state['read_'.$name.'_describe'] = $record($raw('GET', $instance));
+        $state['read_'.$name.'_run'] = $record($raw('GET', $run));
+        $state['read_'.$name.'_runs'] = $record($raw('GET', $instance.'/runs'));
+        $state['read_'.$name.'_history'] = $record($raw('GET', $run.'/history'));
+        // The export as served: its checksum is recomputed here over PHP's
+        // canonical JSON of the bundle without its integrity block, which
+        // LegacyV1Projection::decorateHistoryExport refreshes after adding
+        // migration_projection.
+        $served = $raw('GET', $run.'/history/export');
+        $bundle = is_array($served['response']) ? $served['response'] : [];
+        $integrity = $bundle['integrity'] ?? null;
+        unset($bundle['integrity']);
+        $export = $record($served);
+        if (is_array($export['response'])) {
+            $export['response']['integrity_verified'] = is_array($integrity)
+                && hash('sha256', $canonical($bundle)) === ($integrity['checksum'] ?? null);
+            // Timeline, wait and projection-source reporting belong to the
+            // general history export, which this fixture does not qualify.
+            unset($export['response']['timeline'], $export['response']['waits'], $export['response']['selected_run'],
+                $export['response']['links']['projection_source']);
+        }
+        // The summary's history size counts the source id, namespace and
+        // slug the prefix carries; record it without them, so recordings
+        // under prefixes of any length compare.
+        if (is_int($export['response']['summary']['history_size_bytes'] ?? null)) {
+            $slug = explode(':', $ids['workflow_id'])[1];
+            $export['response']['summary']['history_size_bytes'] -= strlen($sourceId) + strlen($namespace) + strlen($slug);
+        }
+        if (is_string($export['response']['integrity']['checksum'] ?? null)) {
+            $labels[$export['response']['integrity']['checksum']] ??= '{'.$label.'.export_checksum}';
+        }
+        $state['read_'.$name.'_export'] = $export;
+    }
+    $state['read_list'] = $record($raw('GET', '/api/workflows'));
+    $state['read_list_alt'] = $record($raw('GET', '/api/workflows', null, ['namespace' => $alt]));
+
+    // Every control operation refuses a projection, terminal or not.
+    foreach (['running' => $identities['running'], 'completed' => $identities['completed']] as $label => $ids) {
+        $instance = '/api/workflows/'.rawurlencode($ids['workflow_id']);
+        $run = $instance.'/runs/'.$ids['run_id'];
+        $state['refuse_'.$label] = [
+            'signal' => $record($raw('POST', $instance.'/signal/approve', ['input' => ['yes']])),
+            'run_signal' => $record($raw('POST', $run.'/signal/approve', ['input' => ['yes']])),
+            'query' => $record($raw('POST', $instance.'/query/status', ['input' => []])),
+            'update' => $record($raw('POST', $instance.'/update/rename', ['input' => ['x']])),
+            'cancel' => $record($raw('POST', $instance.'/cancel', ['reason' => 'operator'])),
+            'run_cancel' => $record($raw('POST', $run.'/cancel', ['reason' => 'operator'])),
+            'terminate' => $record($raw('POST', $instance.'/terminate', ['reason' => 'operator'])),
+            'repair' => $record($raw('POST', $instance.'/repair')),
+            'archive' => $record($raw('POST', $instance.'/archive', ['reason' => 'operator'])),
+            'redrive' => $record($raw('POST', $run.'/redrive')),
+            'request_cancellation' => $record($raw('POST', $instance.'/request-cancellation', ['reason' => 'operator'])),
+        ];
+    }
+    $state['refused_running_describe'] = $record($raw('GET', '/api/workflows/'.rawurlencode($identities['running']['workflow_id'])));
+
+    return json_decode(strtr(json_encode($state, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR), $labels),
+        true, 512, JSON_THROW_ON_ERROR);
+}
diff --git a/tests/Fixtures/ServerParity/waterline-import.json b/tests/Fixtures/ServerParity/waterline-import.json
new file mode 100644
index 000000000..a2d26d162
--- /dev/null
+++ b/tests/Fixtures/ServerParity/waterline-import.json
@@ -0,0 +1,10752 @@
+{
+  "schema": "durable-workflow.server-parity-fixture/v1",
+  "id": "waterline-import",
+  "review_state": "reviewed",
+  "workflow_type": "parity.v1.echo",
+  "input": {
+    "message": "waterline import λ",
+    "count": 9007199254740993,
+    "optional": null
+  },
+  "typed_value": {
+    "type": "map",
+    "value": {
+      "message": {
+        "type": "string",
+        "value": "waterline import λ"
+      },
+      "count": {
+        "type": "int64",
+        "value": "9007199254740993"
+      },
+      "optional": {
+        "type": "null",
+        "value": null
+      }
+    }
+  },
+  "activity": false,
+  "expected_events": [
+    "StartAccepted",
+    "WorkflowStarted",
+    "WorkflowCompleted"
+  ],
+  "contract": "Waterline v1 projection import (POST /api/workflows/import/waterline-v1, LegacyV1ProjectionController and LegacyV1Projection) as published Server 2.11.1 serves it, in its own namespaces, from the fixture's v1 flow-detail templates: the request gates, validation, each normalization refusal alone and together, operator_id precedence, a dry run that writes nothing, the projection with idempotent, trimmed, changed and cross-namespace repeats, every v1 status, timestamp offsets and unparseable times, unusable rows, signal-name fallbacks, the fewest accepted fields, a native identity collision from another namespace, the projected runs through describe, run, runs, history, history export (its projection decoration and a checksum recomputed over PHP's canonical JSON; timeline, waits and projection sources belong to the general export) and list, and the read-only refusal of signal, query, update, cancel, terminate, repair, archive, redrive and cooperative cancellation on running and completed projections. Projected identities, event ids, dedupe keys, export checksums and import-time sort keys are labels, history sizes are recorded without the prefix's bytes; import and export times are placeholders. Recorded three times, identical.",
+  "waterline_import": {
+    "sources": {
+      "completed": {
+        "id": "v1:4101",
+        "operator_id": "v1:4101",
+        "legacy_id": 4101,
+        "engine_source": "v1",
+        "engine_version": "1.0.68",
+        "execution_engine": "finish-on-v1",
+        "class": "App\\Workflows\\Legacy\\OrderFulfillment",
+        "status": "completed",
+        "connection": "redis",
+        "queue": "legacy-orders",
+        "arguments": "a:1:{i:0;s:7:\"order-7\";}",
+        "output": "s:9:\"fulfilled\";",
+        "logs": [
+          {
+            "id": 9001,
+            "index": 0,
+            "now": "2026-09-30T08:00:01.000000Z",
+            "class": "App\\Activities\\ReserveStock",
+            "result": "b:1;",
+            "created_at": "2026-09-30T08:00:02.000000Z"
+          },
+          {
+            "id": 9002,
+            "index": 1,
+            "now": "2026-09-30T08:00:04.500000Z",
+            "class": "App\\Activities\\ChargeCard",
+            "result": null,
+            "created_at": "2026-09-30T08:00:05.000000Z"
+          }
+        ],
+        "signals": [
+          {
+            "id": 7001,
+            "method": "approve-λ",
+            "arguments": "a:1:{i:0;s:3:\"yes\";}",
+            "created_at": "2026-09-30T08:00:03.000000Z"
+          }
+        ],
+        "exceptions": [
+          {
+            "id": 5001,
+            "class": "App\\Activities\\ChargeCard",
+            "exception": "O:9:\"Exception\":0:{}",
+            "created_at": "2026-09-30T08:00:04.000000Z"
+          }
+        ],
+        "created_at": "2026-09-30T08:00:00.000000Z",
+        "updated_at": "2026-09-30T08:00:06.000000Z",
+        "chart_data": [
+          {
+            "x": 1,
+            "y": 2
+          }
+        ]
+      },
+      "running": {
+        "id": "v1:4201",
+        "legacy_id": "4201",
+        "engine_source": "v1",
+        "class": "App\\Workflows\\Legacy\\Subscription",
+        "status": "running",
+        "connection": "database",
+        "queue": "legacy-billing",
+        "arguments": "a:0:{}",
+        "logs": [
+          {
+            "id": 9101,
+            "index": 0,
+            "now": "2026-09-30T09:00:01.000000Z",
+            "class": "App\\Activities\\Bill",
+            "result": "i:42;",
+            "created_at": "2026-09-30T09:00:02.000000Z"
+          }
+        ],
+        "signals": [],
+        "exceptions": [],
+        "created_at": "2026-09-30T09:00:00.000000Z"
+      }
+    },
+    "expected": {
+      "applicable": true,
+      "namespace": "{id}-wl1",
+      "alternate_namespace": "{id}-wl1alt",
+      "native_namespace": "{id}-wl1native",
+      "source_id": "{id}",
+      "gate_unauthenticated": {
+        "status": 401,
+        "response": {
+          "reason": "unauthorized",
+          "message": "Invalid or missing authentication token.",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "reason": "unauthorized",
+            "message": "Invalid or missing authentication token."
+          }
+        }
+      },
+      "gate_missing_version": {
+        "status": 400,
+        "response": {
+          "message": "Missing control-plane version header.",
+          "reason": "missing_control_plane_version",
+          "supported_version": "2",
+          "requested_version": null,
+          "remediation": "Send the X-Durable-Workflow-Control-Plane-Version: 2 header on control-plane requests.",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "reason": "missing_control_plane_version",
+            "message": "Missing control-plane version header.",
+            "remediation": "Send the X-Durable-Workflow-Control-Plane-Version: 2 header on control-plane requests."
+          }
+        }
+      },
+      "gate_unsupported_version": {
+        "status": 400,
+        "response": {
+          "message": "Unsupported control-plane version.",
+          "reason": "unsupported_control_plane_version",
+          "supported_version": "2",
+          "requested_version": "3",
+          "remediation": "Client requested control-plane version 3; this server only supports 2. Upgrade the client to a release that targets control-plane 2, or connect to a server that supports 3.",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "reason": "unsupported_control_plane_version",
+            "message": "Unsupported control-plane version.",
+            "remediation": "Client requested control-plane version 3; this server only supports 2. Upgrade the client to a release that targets control-plane 2, or connect to a server that supports 3."
+          }
+        }
+      },
+      "gate_unknown_namespace": {
+        "status": 404,
+        "response": {
+          "message": "Namespace '{id}-missing' does not exist.",
+          "reason": "namespace_not_found",
+          "namespace": "{id}-missing",
+          "remediation": "Register the namespace via POST /api/namespaces, or send an X-Namespace header naming an existing namespace.",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "namespace": "{id}-missing",
+            "reason": "namespace_not_found",
+            "message": "Namespace '{id}-missing' does not exist.",
+            "remediation": "Register the namespace via POST /api/namespaces, or send an X-Namespace header naming an existing namespace."
+          }
+        }
+      },
+      "gate_text_plain": {
+        "status": 415,
+        "response": {
+          "message": "Request bodies must use a JSON media type.",
+          "reason": "unsupported_media_type",
+          "accepted_content_types": [
+            "application/json",
+            "application/*+json"
+          ],
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "reason": "unsupported_media_type",
+            "message": "Request bodies must use a JSON media type."
+          }
+        }
+      },
+      "gate_malformed_json": {
+        "status": 400,
+        "response": {
+          "message": "Request bodies must contain valid JSON.",
+          "reason": "malformed_json",
+          "json_error": "Syntax error",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "reason": "malformed_json",
+            "message": "Request bodies must contain valid JSON."
+          }
+        }
+      },
+      "validate_empty": {
+        "status": 422,
+        "response": {
+          "message": "The source id field is required. (and 1 more error)",
+          "reason": "validation_failed",
+          "errors": {
+            "source_id": [
+              "The source id field is required."
+            ],
+            "workflow": [
+              "The workflow field is required."
+            ]
+          },
+          "validation_errors": {
+            "source_id": [
+              "The source id field is required."
+            ],
+            "workflow": [
+              "The workflow field is required."
+            ]
+          },
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "reason": "validation_failed",
+            "validation_errors": {
+              "source_id": [
+                "The source id field is required."
+              ],
+              "workflow": [
+                "The workflow field is required."
+              ]
+            },
+            "message": "The source id field is required. (and 1 more error)"
+          }
+        }
+      },
+      "validate_source_id_blank": {
+        "status": 422,
+        "response": {
+          "message": "The source id field is required.",
+          "reason": "validation_failed",
+          "errors": {
+            "source_id": [
+              "The source id field is required."
+            ]
+          },
+          "validation_errors": {
+            "source_id": [
+              "The source id field is required."
+            ]
+          },
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "reason": "validation_failed",
+            "validation_errors": {
+              "source_id": [
+                "The source id field is required."
+              ]
+            },
+            "message": "The source id field is required."
+          }
+        }
+      },
+      "validate_source_id_number": {
+        "status": 422,
+        "response": {
+          "message": "The source id field must be a string.",
+          "reason": "validation_failed",
+          "errors": {
+            "source_id": [
+              "The source id field must be a string."
+            ]
+          },
+          "validation_errors": {
+            "source_id": [
+              "The source id field must be a string."
+            ]
+          },
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "reason": "validation_failed",
+            "validation_errors": {
+              "source_id": [
+                "The source id field must be a string."
+              ]
+            },
+            "message": "The source id field must be a string."
+          }
+        }
+      },
+      "validate_source_id_long": {
+        "status": 422,
+        "response": {
+          "message": "The source id field must not be greater than 64 characters.",
+          "reason": "validation_failed",
+          "errors": {
+            "source_id": [
+              "The source id field must not be greater than 64 characters."
+            ]
+          },
+          "validation_errors": {
+            "source_id": [
+              "The source id field must not be greater than 64 characters."
+            ]
+          },
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "reason": "validation_failed",
+            "validation_errors": {
+              "source_id": [
+                "The source id field must not be greater than 64 characters."
+              ]
+            },
+            "message": "The source id field must not be greater than 64 characters."
+          }
+        }
+      },
+      "validate_workflow_empty": {
+        "status": 422,
+        "response": {
+          "message": "The workflow field is required.",
+          "reason": "validation_failed",
+          "errors": {
+            "workflow": [
+              "The workflow field is required."
+            ]
+          },
+          "validation_errors": {
+            "workflow": [
+              "The workflow field is required."
+            ]
+          },
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "reason": "validation_failed",
+            "validation_errors": {
+              "workflow": [
+                "The workflow field is required."
+              ]
+            },
+            "message": "The workflow field is required."
+          }
+        }
+      },
+      "validate_workflow_string": {
+        "status": 422,
+        "response": {
+          "message": "The workflow field must be an array.",
+          "reason": "validation_failed",
+          "errors": {
+            "workflow": [
+              "The workflow field must be an array."
+            ]
+          },
+          "validation_errors": {
+            "workflow": [
+              "The workflow field must be an array."
+            ]
+          },
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "reason": "validation_failed",
+            "validation_errors": {
+              "workflow": [
+                "The workflow field must be an array."
+              ]
+            },
+            "message": "The workflow field must be an array."
+          }
+        }
+      },
+      "validate_dry_run": {
+        "status": 422,
+        "response": {
+          "message": "The dry run field must be true or false.",
+          "reason": "validation_failed",
+          "errors": {
+            "dry_run": [
+              "The dry run field must be true or false."
+            ]
+          },
+          "validation_errors": {
+            "dry_run": [
+              "The dry run field must be true or false."
+            ]
+          },
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "reason": "validation_failed",
+            "validation_errors": {
+              "dry_run": [
+                "The dry run field must be true or false."
+              ]
+            },
+            "message": "The dry run field must be true or false."
+          }
+        }
+      },
+      "reject_source_id": {
+        "status": 409,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "rejected",
+          "projection_only": true,
+          "identity": null,
+          "dedupe_key": null,
+          "unsupported_fields": [],
+          "errors": [
+            {
+              "reason": "invalid_source_id",
+              "message": "source_id must be 1-64 stable URL-safe characters.",
+              "remediation": "Use a deployment-stable identifier such as legacy-prod-us-east."
+            }
+          ],
+          "reason": "invalid_source_id",
+          "message": "source_id must be 1-64 stable URL-safe characters.",
+          "remediation": "Use a deployment-stable identifier such as legacy-prod-us-east.",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "rejected",
+            "reason": "invalid_source_id",
+            "message": "source_id must be 1-64 stable URL-safe characters.",
+            "remediation": "Use a deployment-stable identifier such as legacy-prod-us-east.",
+            "identity": null
+          }
+        }
+      },
+      "reject_unqualified": {
+        "status": 409,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "rejected",
+          "projection_only": true,
+          "identity": null,
+          "dedupe_key": null,
+          "unsupported_fields": [],
+          "errors": [
+            {
+              "reason": "unqualified_v1_identity",
+              "message": "The Waterline workflow must carry operator_id or id in v1:<workflow-id> form.",
+              "remediation": "Export the detail from the Waterline hybrid migration API."
+            }
+          ],
+          "reason": "unqualified_v1_identity",
+          "message": "The Waterline workflow must carry operator_id or id in v1:<workflow-id> form.",
+          "remediation": "Export the detail from the Waterline hybrid migration API.",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "rejected",
+            "reason": "unqualified_v1_identity",
+            "message": "The Waterline workflow must carry operator_id or id in v1:<workflow-id> form.",
+            "remediation": "Export the detail from the Waterline hybrid migration API.",
+            "identity": null
+          }
+        }
+      },
+      "reject_mismatch": {
+        "status": 409,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "rejected",
+          "projection_only": true,
+          "identity": null,
+          "dedupe_key": null,
+          "unsupported_fields": [],
+          "errors": [
+            {
+              "reason": "v1_identity_mismatch",
+              "message": "legacy_id does not match the qualified Waterline identity.",
+              "remediation": "Re-export the workflow detail without editing its identity fields."
+            }
+          ],
+          "reason": "v1_identity_mismatch",
+          "message": "legacy_id does not match the qualified Waterline identity.",
+          "remediation": "Re-export the workflow detail without editing its identity fields.",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "rejected",
+            "reason": "v1_identity_mismatch",
+            "message": "legacy_id does not match the qualified Waterline identity.",
+            "remediation": "Re-export the workflow detail without editing its identity fields.",
+            "identity": null
+          }
+        }
+      },
+      "reject_engine": {
+        "status": 409,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "rejected",
+          "projection_only": true,
+          "identity": null,
+          "dedupe_key": null,
+          "unsupported_fields": [],
+          "errors": [
+            {
+              "reason": "unsupported_source_engine",
+              "message": "Only Waterline engine_source=v1 projections are accepted.",
+              "remediation": "Use embedded-v2 import for v2-origin history bundles."
+            }
+          ],
+          "reason": "unsupported_source_engine",
+          "message": "Only Waterline engine_source=v1 projections are accepted.",
+          "remediation": "Use embedded-v2 import for v2-origin history bundles.",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "rejected",
+            "reason": "unsupported_source_engine",
+            "message": "Only Waterline engine_source=v1 projections are accepted.",
+            "remediation": "Use embedded-v2 import for v2-origin history bundles.",
+            "identity": null
+          }
+        }
+      },
+      "reject_class": {
+        "status": 409,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "rejected",
+          "projection_only": true,
+          "identity": null,
+          "dedupe_key": null,
+          "unsupported_fields": [],
+          "errors": [
+            {
+              "reason": "missing_v1_workflow_class",
+              "message": "The Waterline projection does not identify the workflow class.",
+              "remediation": "Export the complete v1 workflow detail response."
+            }
+          ],
+          "reason": "missing_v1_workflow_class",
+          "message": "The Waterline projection does not identify the workflow class.",
+          "remediation": "Export the complete v1 workflow detail response.",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "rejected",
+            "reason": "missing_v1_workflow_class",
+            "message": "The Waterline projection does not identify the workflow class.",
+            "remediation": "Export the complete v1 workflow detail response.",
+            "identity": null
+          }
+        }
+      },
+      "reject_status": {
+        "status": 409,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "rejected",
+          "projection_only": true,
+          "identity": null,
+          "dedupe_key": null,
+          "unsupported_fields": [],
+          "errors": [
+            {
+              "reason": "unsupported_v1_status",
+              "message": "The v1 workflow status cannot be represented by the standalone v2 visibility model.",
+              "remediation": "Complete or normalize the workflow on v1, then export it again."
+            }
+          ],
+          "reason": "unsupported_v1_status",
+          "message": "The v1 workflow status cannot be represented by the standalone v2 visibility model.",
+          "remediation": "Complete or normalize the workflow on v1, then export it again.",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "rejected",
+            "reason": "unsupported_v1_status",
+            "message": "The v1 workflow status cannot be represented by the standalone v2 visibility model.",
+            "remediation": "Complete or normalize the workflow on v1, then export it again.",
+            "identity": null
+          }
+        }
+      },
+      "reject_all": {
+        "status": 409,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "rejected",
+          "projection_only": true,
+          "identity": null,
+          "dedupe_key": null,
+          "unsupported_fields": [],
+          "errors": [
+            {
+              "reason": "invalid_source_id",
+              "message": "source_id must be 1-64 stable URL-safe characters.",
+              "remediation": "Use a deployment-stable identifier such as legacy-prod-us-east."
+            },
+            {
+              "reason": "unqualified_v1_identity",
+              "message": "The Waterline workflow must carry operator_id or id in v1:<workflow-id> form.",
+              "remediation": "Export the detail from the Waterline hybrid migration API."
+            },
+            {
+              "reason": "v1_identity_mismatch",
+              "message": "legacy_id does not match the qualified Waterline identity.",
+              "remediation": "Re-export the workflow detail without editing its identity fields."
+            },
+            {
+              "reason": "unsupported_source_engine",
+              "message": "Only Waterline engine_source=v1 projections are accepted.",
+              "remediation": "Use embedded-v2 import for v2-origin history bundles."
+            },
+            {
+              "reason": "missing_v1_workflow_class",
+              "message": "The Waterline projection does not identify the workflow class.",
+              "remediation": "Export the complete v1 workflow detail response."
+            },
+            {
+              "reason": "unsupported_v1_status",
+              "message": "The v1 workflow status cannot be represented by the standalone v2 visibility model.",
+              "remediation": "Complete or normalize the workflow on v1, then export it again."
+            }
+          ],
+          "reason": "invalid_source_id",
+          "message": "source_id must be 1-64 stable URL-safe characters.",
+          "remediation": "Use a deployment-stable identifier such as legacy-prod-us-east.",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "rejected",
+            "reason": "invalid_source_id",
+            "message": "source_id must be 1-64 stable URL-safe characters.",
+            "remediation": "Use a deployment-stable identifier such as legacy-prod-us-east.",
+            "identity": null
+          }
+        }
+      },
+      "operator_id_first": {
+        "status": 200,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "dry_run",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4101",
+              "legacy_workflow_id": "4101"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{completed.workflow}",
+              "run_id": "{completed.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{completed.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          ],
+          "errors": [],
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "dry_run",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4101",
+                "legacy_workflow_id": "4101"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{completed.workflow}",
+                "run_id": "{completed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "dry_run": {
+        "status": 200,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "dry_run",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4101",
+              "legacy_workflow_id": "4101"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{completed.workflow}",
+              "run_id": "{completed.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{completed.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          ],
+          "errors": [],
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "dry_run",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4101",
+                "legacy_workflow_id": "4101"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{completed.workflow}",
+                "run_id": "{completed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "dry_run_describe": {
+        "status": 404,
+        "response": {
+          "message": "Workflow not found.",
+          "reason": "instance_not_found",
+          "workflow_id": "{completed.workflow}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "describe",
+            "workflow_id": "{completed.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": []
+            },
+            "reason": "instance_not_found",
+            "message": "Workflow not found."
+          }
+        }
+      },
+      "project": {
+        "status": 201,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "projected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4101",
+              "legacy_workflow_id": "4101"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{completed.workflow}",
+              "run_id": "{completed.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{completed.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          ],
+          "errors": [],
+          "imported_at": "{imported_at}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "projected",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4101",
+                "legacy_workflow_id": "4101"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{completed.workflow}",
+                "run_id": "{completed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "repeat": {
+        "status": 200,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "already_projected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4101",
+              "legacy_workflow_id": "4101"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{completed.workflow}",
+              "run_id": "{completed.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{completed.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          ],
+          "errors": [],
+          "imported_at": "{imported_at}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "already_projected",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4101",
+                "legacy_workflow_id": "4101"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{completed.workflow}",
+                "run_id": "{completed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "repeat_dry_run": {
+        "status": 200,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "already_projected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4101",
+              "legacy_workflow_id": "4101"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{completed.workflow}",
+              "run_id": "{completed.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{completed.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          ],
+          "errors": [],
+          "imported_at": "{imported_at}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "already_projected",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4101",
+                "legacy_workflow_id": "4101"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{completed.workflow}",
+                "run_id": "{completed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "repeat_trimmed": {
+        "status": 200,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "already_projected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4101",
+              "legacy_workflow_id": "4101"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{completed.workflow}",
+              "run_id": "{completed.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{completed.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          ],
+          "errors": [],
+          "imported_at": "{imported_at}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "already_projected",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4101",
+                "legacy_workflow_id": "4101"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{completed.workflow}",
+                "run_id": "{completed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "changed": {
+        "status": 409,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "rejected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4101",
+              "legacy_workflow_id": "4101"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{completed.workflow}",
+              "run_id": "{completed.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{changed.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          ],
+          "errors": [],
+          "reason": "v1_projection_changed",
+          "message": "This v1 identity was already projected from different source state.",
+          "remediation": "Inspect the existing projection and resolve it before importing a different snapshot of the same v1 identity.",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "rejected",
+            "reason": "v1_projection_changed",
+            "message": "This v1 identity was already projected from different source state.",
+            "remediation": "Inspect the existing projection and resolve it before importing a different snapshot of the same v1 identity.",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4101",
+                "legacy_workflow_id": "4101"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{completed.workflow}",
+                "run_id": "{completed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "other_namespace": {
+        "status": 409,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "rejected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4101",
+              "legacy_workflow_id": "4101"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{completed.workflow}",
+              "run_id": "{completed.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{completed.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          ],
+          "errors": [],
+          "requested_namespace": "{id}-wl1alt",
+          "reason": "v1_projection_namespace_collision",
+          "message": "This v1 identity is already projected in a different standalone namespace.",
+          "remediation": "Repeat the operation in the existing {id}-wl1 namespace, or choose a different stable source_id for an independent projection.",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "rejected",
+            "reason": "v1_projection_namespace_collision",
+            "message": "This v1 identity is already projected in a different standalone namespace.",
+            "remediation": "Repeat the operation in the existing {id}-wl1 namespace, or choose a different stable source_id for an independent projection.",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4101",
+                "legacy_workflow_id": "4101"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{completed.workflow}",
+                "run_id": "{completed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "status_created": {
+        "status": 201,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "projected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4300",
+              "legacy_workflow_id": "4300"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{status-created.workflow}",
+              "run_id": "{status-created.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{status-created.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "runtime.execution",
+              "reason": "finish_on_v1_execution_not_transferable",
+              "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+            }
+          ],
+          "errors": [],
+          "imported_at": "{imported_at}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "projected",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4300",
+                "legacy_workflow_id": "4300"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{status-created.workflow}",
+                "run_id": "{status-created.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "status_pending": {
+        "status": 201,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "projected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4301",
+              "legacy_workflow_id": "4301"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{status-pending.workflow}",
+              "run_id": "{status-pending.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{status-pending.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "runtime.execution",
+              "reason": "finish_on_v1_execution_not_transferable",
+              "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+            }
+          ],
+          "errors": [],
+          "imported_at": "{imported_at}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "projected",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4301",
+                "legacy_workflow_id": "4301"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{status-pending.workflow}",
+                "run_id": "{status-pending.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "status_waiting": {
+        "status": 201,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "projected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4302",
+              "legacy_workflow_id": "4302"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{status-waiting.workflow}",
+              "run_id": "{status-waiting.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{status-waiting.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "runtime.execution",
+              "reason": "finish_on_v1_execution_not_transferable",
+              "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+            }
+          ],
+          "errors": [],
+          "imported_at": "{imported_at}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "projected",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4302",
+                "legacy_workflow_id": "4302"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{status-waiting.workflow}",
+                "run_id": "{status-waiting.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "status_failed": {
+        "status": 201,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "projected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4303",
+              "legacy_workflow_id": "4303"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{status-failed.workflow}",
+              "run_id": "{status-failed.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{status-failed.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          ],
+          "errors": [],
+          "imported_at": "{imported_at}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "projected",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4303",
+                "legacy_workflow_id": "4303"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{status-failed.workflow}",
+                "run_id": "{status-failed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "status_cancelled": {
+        "status": 201,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "projected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4304",
+              "legacy_workflow_id": "4304"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{status-cancelled.workflow}",
+              "run_id": "{status-cancelled.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{status-cancelled.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          ],
+          "errors": [],
+          "imported_at": "{imported_at}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "projected",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4304",
+                "legacy_workflow_id": "4304"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{status-cancelled.workflow}",
+                "run_id": "{status-cancelled.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "status_terminated": {
+        "status": 201,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "projected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4305",
+              "legacy_workflow_id": "4305"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{status-terminated.workflow}",
+              "run_id": "{status-terminated.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{status-terminated.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          ],
+          "errors": [],
+          "imported_at": "{imported_at}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "projected",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4305",
+                "legacy_workflow_id": "4305"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{status-terminated.workflow}",
+                "run_id": "{status-terminated.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "status_continued": {
+        "status": 201,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "projected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4306",
+              "legacy_workflow_id": "4306"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{status-continued.workflow}",
+              "run_id": "{status-continued.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{status-continued.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          ],
+          "errors": [],
+          "imported_at": "{imported_at}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "projected",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4306",
+                "legacy_workflow_id": "4306"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{status-continued.workflow}",
+                "run_id": "{status-continued.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "running": {
+        "status": 201,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "projected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4201",
+              "legacy_workflow_id": "4201"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{running.workflow}",
+              "run_id": "{running.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{running.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "runtime.execution",
+              "reason": "finish_on_v1_execution_not_transferable",
+              "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+            }
+          ],
+          "errors": [],
+          "imported_at": "{imported_at}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "projected",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4201",
+                "legacy_workflow_id": "4201"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{running.workflow}",
+                "run_id": "{running.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "offsets": {
+        "status": 201,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "projected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4401",
+              "legacy_workflow_id": "4401"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{offsets.workflow}",
+              "run_id": "{offsets.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{offsets.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          ],
+          "errors": [],
+          "imported_at": "{imported_at}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "projected",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4401",
+                "legacy_workflow_id": "4401"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{offsets.workflow}",
+                "run_id": "{offsets.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "bare": {
+        "status": 201,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "projected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4501",
+              "legacy_workflow_id": "4501"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{bare.workflow}",
+              "run_id": "{bare.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{bare.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            }
+          ],
+          "errors": [],
+          "imported_at": "{imported_at}",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "projected",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4501",
+                "legacy_workflow_id": "4501"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{bare.workflow}",
+                "run_id": "{bare.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "native_start_status": 201,
+      "native_collision": {
+        "status": 409,
+        "response": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.report",
+          "schema_version": 1,
+          "status": "rejected",
+          "projection_only": true,
+          "identity": {
+            "waterline": {
+              "source_id": "{id}",
+              "qualified_workflow_id": "v1:4601",
+              "legacy_workflow_id": "4601"
+            },
+            "standalone": {
+              "namespace": "{id}-wl1",
+              "workflow_id": "{collision.workflow}",
+              "run_id": "{collision.run}"
+            },
+            "relationship": "deterministic_source_qualified_projection",
+            "collision_policy": "reject_without_overwrite"
+          },
+          "dedupe_key": "{collision.dedupe}",
+          "unsupported_fields": [
+            {
+              "field": "runtime.replay",
+              "reason": "v1_history_not_replayable_as_v2",
+              "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+            },
+            {
+              "field": "timers",
+              "reason": "legacy_timer_state_not_exposed_by_waterline",
+              "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+            },
+            {
+              "field": "payloads.arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.output",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.activity_results",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.signal_arguments",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            },
+            {
+              "field": "payloads.exception_values",
+              "reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          ],
+          "errors": [],
+          "reason": "native_v2_identity_collision",
+          "message": "The mapped standalone identity is already owned by a native or unrelated v2 execution.",
+          "remediation": "Choose a different stable source_id; the server will not overwrite the colliding v2 execution.",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "import_waterline_v1",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": [
+                "status",
+                "identity"
+              ],
+              "rejection_fields": [
+                "status",
+                "reason",
+                "message",
+                "remediation",
+                "identity"
+              ],
+              "rejection_reasons": [
+                "invalid_source_id",
+                "unqualified_v1_identity",
+                "v1_identity_mismatch",
+                "unsupported_source_engine",
+                "missing_v1_workflow_class",
+                "unsupported_v1_status",
+                "v1_projection_changed",
+                "v1_projection_namespace_collision",
+                "v1_projection_storage_inconsistent",
+                "native_v2_identity_collision",
+                "target_write_failed"
+              ]
+            },
+            "status": "rejected",
+            "reason": "native_v2_identity_collision",
+            "message": "The mapped standalone identity is already owned by a native or unrelated v2 execution.",
+            "remediation": "Choose a different stable source_id; the server will not overwrite the colliding v2 execution.",
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4601",
+                "legacy_workflow_id": "4601"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{collision.workflow}",
+                "run_id": "{collision.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            }
+          }
+        }
+      },
+      "read_project_describe": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{completed.workflow}",
+          "run_id": "{completed.run}",
+          "namespace": "{id}-wl1",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "completed",
+          "status_bucket": "completed",
+          "is_terminal": true,
+          "closed_reason": "completed",
+          "task_queue": "legacy-orders",
+          "run_number": 1,
+          "run_count": 1,
+          "is_current_run": true,
+          "continued_from_run_id": null,
+          "resume_step_sequence": null,
+          "recovery_kind": null,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "payload_codec": null,
+          "definition_routing": null,
+          "execution_timeout_seconds": null,
+          "run_timeout_seconds": null,
+          "execution_deadline_at": null,
+          "run_deadline_at": null,
+          "input": null,
+          "output": null,
+          "input_envelope": null,
+          "output_envelope": null,
+          "payload_previews": {
+            "input_omitted": false,
+            "output_omitted": false,
+            "max_encoded_bytes": 2097152
+          },
+          "started_at": "2026-09-30T08:00:00.000000Z",
+          "closed_at": "2026-09-30T08:00:06.000000Z",
+          "last_progress_at": "2026-09-30T08:00:06.000000Z",
+          "wait_kind": null,
+          "wait_reason": null,
+          "memo": [],
+          "search_attributes": [],
+          "actions": {
+            "can_signal": false,
+            "can_query": false,
+            "can_update": false,
+            "can_cancel": false,
+            "can_terminate": false,
+            "can_repair": false,
+            "can_archive": false
+          },
+          "commands_scope": "selected_run",
+          "commands": [],
+          "updates_scope": "selected_run",
+          "updates": [],
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.0.68",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4101",
+                "legacy_workflow_id": "4101"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{completed.workflow}",
+                "run_id": "{completed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": "redis",
+              "name": "legacy-orders",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.output",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.signal_arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.exception_values",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{completed.dedupe}"
+            }
+          },
+          "action_blocked_reason": "v1_projection_read_only",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "describe",
+            "workflow_id": "{completed.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": []
+            },
+            "run_id": "{completed.run}",
+            "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+            "namespace": "{id}-wl1",
+            "business_key": null,
+            "status": "completed",
+            "status_bucket": "completed",
+            "is_terminal": true,
+            "task_queue": "legacy-orders",
+            "run_number": 1,
+            "run_count": 1,
+            "is_current_run": true,
+            "compatibility": null,
+            "started_at": "2026-09-30T08:00:00.000000Z",
+            "closed_at": "2026-09-30T08:00:06.000000Z",
+            "last_progress_at": "2026-09-30T08:00:06.000000Z",
+            "wait_kind": null,
+            "wait_reason": null
+          }
+        }
+      },
+      "read_project_run": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{completed.workflow}",
+          "run_id": "{completed.run}",
+          "namespace": "{id}-wl1",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "completed",
+          "status_bucket": "completed",
+          "is_terminal": true,
+          "closed_reason": "completed",
+          "task_queue": "legacy-orders",
+          "run_number": 1,
+          "run_count": 1,
+          "is_current_run": true,
+          "continued_from_run_id": null,
+          "resume_step_sequence": null,
+          "recovery_kind": null,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "payload_codec": null,
+          "definition_routing": null,
+          "execution_timeout_seconds": null,
+          "run_timeout_seconds": null,
+          "execution_deadline_at": null,
+          "run_deadline_at": null,
+          "input": null,
+          "output": null,
+          "input_envelope": null,
+          "output_envelope": null,
+          "payload_previews": {
+            "input_omitted": false,
+            "output_omitted": false,
+            "max_encoded_bytes": 2097152
+          },
+          "started_at": "2026-09-30T08:00:00.000000Z",
+          "closed_at": "2026-09-30T08:00:06.000000Z",
+          "last_progress_at": "2026-09-30T08:00:06.000000Z",
+          "wait_kind": null,
+          "wait_reason": null,
+          "memo": [],
+          "search_attributes": [],
+          "actions": {
+            "can_signal": false,
+            "can_query": false,
+            "can_update": false,
+            "can_cancel": false,
+            "can_terminate": false,
+            "can_repair": false,
+            "can_archive": false
+          },
+          "commands_scope": "selected_run",
+          "commands": [],
+          "updates_scope": "selected_run",
+          "updates": [],
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.0.68",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4101",
+                "legacy_workflow_id": "4101"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{completed.workflow}",
+                "run_id": "{completed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": "redis",
+              "name": "legacy-orders",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.output",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.signal_arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.exception_values",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{completed.dedupe}"
+            }
+          },
+          "action_blocked_reason": "v1_projection_read_only",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "describe_run",
+            "workflow_id": "{completed.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": [
+                "run_id"
+              ],
+              "rejection_fields": [
+                "workflow_id",
+                "run_id",
+                "reason",
+                "message",
+                "retryable",
+                "error_id",
+                "exception"
+              ],
+              "rejection_reasons": [
+                "control_plane_internal_error"
+              ]
+            },
+            "run_id": "{completed.run}",
+            "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+            "namespace": "{id}-wl1",
+            "business_key": null,
+            "status": "completed",
+            "status_bucket": "completed",
+            "is_terminal": true,
+            "task_queue": "legacy-orders",
+            "run_number": 1,
+            "run_count": 1,
+            "is_current_run": true,
+            "compatibility": null,
+            "started_at": "2026-09-30T08:00:00.000000Z",
+            "closed_at": "2026-09-30T08:00:06.000000Z",
+            "last_progress_at": "2026-09-30T08:00:06.000000Z",
+            "wait_kind": null,
+            "wait_reason": null
+          }
+        }
+      },
+      "read_project_runs": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{completed.workflow}",
+          "run_count": 1,
+          "runs": [
+            {
+              "run_id": "{completed.run}",
+              "run_number": 1,
+              "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+              "business_key": null,
+              "status": "completed",
+              "status_bucket": "completed",
+              "is_terminal": true,
+              "is_current_run": true,
+              "task_queue": "legacy-orders",
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": "2026-09-30T08:00:00.000000Z",
+              "closed_at": "2026-09-30T08:00:06.000000Z"
+            }
+          ],
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "list_runs",
+            "workflow_id": "{completed.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": []
+            },
+            "run_count": 1
+          }
+        }
+      },
+      "read_project_history": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{completed.workflow}",
+          "run_id": "{completed.run}",
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "events": [
+            {
+              "sequence": 1,
+              "event_type": "WorkflowStarted",
+              "timestamp": "2026-09-30T08:00:00.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "origin": {
+                    "engine_source": "v1",
+                    "engine_version": "1.0.68",
+                    "execution_engine": "finish-on-v1"
+                  },
+                  "identity": {
+                    "waterline": {
+                      "source_id": "{id}",
+                      "qualified_workflow_id": "v1:4101",
+                      "legacy_workflow_id": "4101"
+                    },
+                    "standalone": {
+                      "namespace": "{id}-wl1",
+                      "workflow_id": "{completed.workflow}",
+                      "run_id": "{completed.run}"
+                    },
+                    "relationship": "deterministic_source_qualified_projection",
+                    "collision_policy": "reject_without_overwrite"
+                  },
+                  "task_queue_context": {
+                    "connection": "redis",
+                    "name": "legacy-orders",
+                    "execution_owner": "v1",
+                    "standalone_dispatch": "disabled"
+                  },
+                  "unsupported_fields": [
+                    {
+                      "field": "runtime.replay",
+                      "reason": "v1_history_not_replayable_as_v2",
+                      "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                    },
+                    {
+                      "field": "timers",
+                      "reason": "legacy_timer_state_not_exposed_by_waterline",
+                      "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                    },
+                    {
+                      "field": "payloads.arguments",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.output",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.activity_results",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.signal_arguments",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.exception_values",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    }
+                  ]
+                },
+                "legacy_payloads": {
+                  "arguments": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "a:1:{i:0;s:7:\"order-7\";}",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 2,
+              "event_type": "ActivityCompleted",
+              "timestamp": "2026-09-30T08:00:02.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9001,
+                  "legacy_index": 0
+                },
+                "activity": {
+                  "class": "App\\Activities\\ReserveStock",
+                  "logical_time": "2026-09-30T08:00:01.000000Z",
+                  "result": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "b:1;",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 3,
+              "event_type": "SignalReceived",
+              "timestamp": "2026-09-30T08:00:03.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_signal",
+                  "legacy_id": 7001
+                },
+                "signal_name": "approve-λ",
+                "arguments": {
+                  "available": true,
+                  "encoding": "php-serialize",
+                  "value": "a:1:{i:0;s:3:\"yes\";}",
+                  "portable": false,
+                  "unsupported_reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                }
+              }
+            },
+            {
+              "sequence": 4,
+              "event_type": "ActivityFailed",
+              "timestamp": "2026-09-30T08:00:04.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_exception",
+                  "legacy_id": 5001
+                },
+                "exception": {
+                  "value": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "O:9:\"Exception\":0:{}",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 5,
+              "event_type": "ActivityCompleted",
+              "timestamp": "2026-09-30T08:00:05.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9002,
+                  "legacy_index": 1
+                },
+                "activity": {
+                  "class": "App\\Activities\\ChargeCard",
+                  "logical_time": "2026-09-30T08:00:04.500000Z",
+                  "result": {
+                    "available": false,
+                    "encoding": "php-serialize",
+                    "value": null,
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 6,
+              "event_type": "WorkflowCompleted",
+              "timestamp": "2026-09-30T08:00:06.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_status": "completed",
+                  "execution_owner": "v1"
+                },
+                "legacy_payloads": {
+                  "output": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "s:9:\"fulfilled\";",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            }
+          ],
+          "next_page_token": null,
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.0.68",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4101",
+                "legacy_workflow_id": "4101"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{completed.workflow}",
+                "run_id": "{completed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": "redis",
+              "name": "legacy-orders",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.output",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.signal_arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.exception_values",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{completed.dedupe}"
+            }
+          },
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "history",
+            "workflow_id": "{completed.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id",
+                "run_id"
+              ],
+              "success_fields": [
+                "next_page_token"
+              ],
+              "rejection_fields": [
+                "workflow_id",
+                "run_id",
+                "reason",
+                "message",
+                "retryable",
+                "error_id",
+                "exception"
+              ],
+              "rejection_reasons": [
+                "control_plane_internal_error"
+              ]
+            },
+            "run_id": "{completed.run}",
+            "compatibility": null,
+            "next_page_token": null
+          }
+        }
+      },
+      "read_project_export": {
+        "status": 200,
+        "response": {
+          "schema": "durable-workflow.v2.history-export",
+          "schema_version": 2,
+          "exported_at": "{exported_at}",
+          "dedupe_key": "{completed.run}:6:2026-09-30T08:00:06.000000Z",
+          "history_complete": true,
+          "workflow": {
+            "instance_id": "{completed.workflow}",
+            "run_id": "{completed.run}",
+            "run_number": 1,
+            "is_current_run": true,
+            "current_run_id": "{completed.run}",
+            "current_run_source": "run_order_fallback",
+            "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+            "workflow_class": "App\\Workflows\\Legacy\\OrderFulfillment",
+            "source_runtime": "standalone_server",
+            "source_process_class": "server_http_node",
+            "business_key": null,
+            "visibility_labels": [],
+            "memo": [],
+            "memo_payload": {
+              "codec": "avro",
+              "blob": "wwHioz3/VYAiNw4A"
+            },
+            "search_attributes": [],
+            "status": "completed",
+            "status_bucket": "completed",
+            "closed_reason": "completed",
+            "archived_at": null,
+            "archive_command_id": null,
+            "archive_reason": null,
+            "compatibility": null,
+            "connection": "redis",
+            "queue": "legacy-orders",
+            "last_history_sequence": 6,
+            "started_at": "2026-09-30T08:00:00.000000Z",
+            "closed_at": "2026-09-30T08:00:06.000000Z",
+            "last_progress_at": "2026-09-30T08:00:06.000000Z"
+          },
+          "payloads": {
+            "codec": "avro",
+            "arguments": {
+              "available": false,
+              "data": null
+            },
+            "output": {
+              "available": false,
+              "codec": null,
+              "data": null
+            }
+          },
+          "summary": {
+            "status": "completed",
+            "status_bucket": "completed",
+            "closed_reason": "completed",
+            "archived_at": null,
+            "archive_command_id": null,
+            "archive_reason": null,
+            "business_key": null,
+            "visibility_labels": [],
+            "search_attributes": [],
+            "is_current_run": true,
+            "started_at": "2026-09-30T08:00:00.000000Z",
+            "closed_at": "2026-09-30T08:00:06.000000Z",
+            "duration_ms": null,
+            "wait_kind": null,
+            "wait_reason": null,
+            "wait_started_at": null,
+            "wait_deadline_at": null,
+            "open_wait_id": null,
+            "resume_source_kind": null,
+            "resume_source_id": null,
+            "next_task_at": null,
+            "next_task_id": null,
+            "next_task_type": null,
+            "next_task_status": null,
+            "next_task_lease_expires_at": null,
+            "liveness_state": null,
+            "liveness_reason": null,
+            "repair_attention": false,
+            "task_problem": false,
+            "task_problem_badge": null,
+            "exception_count": 1,
+            "history_event_count": 6,
+            "history_size_bytes": 5431,
+            "history_fan_out": 0,
+            "continue_as_new_recommended": false,
+            "history_budget_pressure": "ok",
+            "sort_timestamp": "2026-09-30T08:00:06.000000Z",
+            "sort_key": null
+          },
+          "history_events": [
+            {
+              "id": "{completed.e1}",
+              "sequence": 1,
+              "type": "WorkflowStarted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:00.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "origin": {
+                    "engine_source": "v1",
+                    "engine_version": "1.0.68",
+                    "execution_engine": "finish-on-v1"
+                  },
+                  "identity": {
+                    "waterline": {
+                      "source_id": "{id}",
+                      "qualified_workflow_id": "v1:4101",
+                      "legacy_workflow_id": "4101"
+                    },
+                    "standalone": {
+                      "namespace": "{id}-wl1",
+                      "workflow_id": "{completed.workflow}",
+                      "run_id": "{completed.run}"
+                    },
+                    "relationship": "deterministic_source_qualified_projection",
+                    "collision_policy": "reject_without_overwrite"
+                  },
+                  "task_queue_context": {
+                    "connection": "redis",
+                    "name": "legacy-orders",
+                    "execution_owner": "v1",
+                    "standalone_dispatch": "disabled"
+                  },
+                  "unsupported_fields": [
+                    {
+                      "field": "runtime.replay",
+                      "reason": "v1_history_not_replayable_as_v2",
+                      "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                    },
+                    {
+                      "field": "timers",
+                      "reason": "legacy_timer_state_not_exposed_by_waterline",
+                      "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                    },
+                    {
+                      "field": "payloads.arguments",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.output",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.activity_results",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.signal_arguments",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.exception_values",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    }
+                  ]
+                },
+                "legacy_payloads": {
+                  "arguments": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "a:1:{i:0;s:7:\"order-7\";}",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{completed.e2}",
+              "sequence": 2,
+              "type": "ActivityCompleted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:02.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9001,
+                  "legacy_index": 0
+                },
+                "activity": {
+                  "class": "App\\Activities\\ReserveStock",
+                  "logical_time": "2026-09-30T08:00:01.000000Z",
+                  "result": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "b:1;",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{completed.e3}",
+              "sequence": 3,
+              "type": "SignalReceived",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:03.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_signal",
+                  "legacy_id": 7001
+                },
+                "signal_name": "approve-λ",
+                "arguments": {
+                  "available": true,
+                  "encoding": "php-serialize",
+                  "value": "a:1:{i:0;s:3:\"yes\";}",
+                  "portable": false,
+                  "unsupported_reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                }
+              }
+            },
+            {
+              "id": "{completed.e4}",
+              "sequence": 4,
+              "type": "ActivityFailed",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:04.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_exception",
+                  "legacy_id": 5001
+                },
+                "exception": {
+                  "class": "App\\Activities\\ChargeCard",
+                  "value": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "O:9:\"Exception\":0:{}",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{completed.e5}",
+              "sequence": 5,
+              "type": "ActivityCompleted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:05.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9002,
+                  "legacy_index": 1
+                },
+                "activity": {
+                  "class": "App\\Activities\\ChargeCard",
+                  "logical_time": "2026-09-30T08:00:04.500000Z",
+                  "result": {
+                    "available": false,
+                    "encoding": "php-serialize",
+                    "value": null,
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{completed.e6}",
+              "sequence": 6,
+              "type": "WorkflowCompleted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:06.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_status": "completed",
+                  "execution_owner": "v1"
+                },
+                "legacy_payloads": {
+                  "output": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "s:9:\"fulfilled\";",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            }
+          ],
+          "linked_intakes_scope": "selected_run",
+          "linked_intakes": [],
+          "commands": [],
+          "signals": [],
+          "updates": [],
+          "tasks": [],
+          "activities": [],
+          "timers": [],
+          "failures": [],
+          "links": {
+            "parents": [],
+            "children": []
+          },
+          "redaction": {
+            "applied": false,
+            "policy": null,
+            "paths": []
+          },
+          "codec_schemas": {
+            "avro": {
+              "encoding": "base64-avro-single-object",
+              "framing": "single_object",
+              "magic_hex": "c301",
+              "current_fingerprint": "e2a33dff55802237",
+              "writer_schemas": {
+                "e2a33dff55802237": {
+                  "schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+                  "fingerprint": "crc64-avro:e2a33dff55802237"
+                }
+              }
+            }
+          },
+          "payload_manifest": {
+            "version": 1,
+            "entries": [
+              {
+                "path": "workflow.memo_payload",
+                "codec": "avro",
+                "available": true,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": "single_object",
+                "avro_prefix_hex": "c301",
+                "writer_schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+                "writer_schema_fingerprint": "crc64-avro:e2a33dff55802237",
+                "diagnostic": null
+              },
+              {
+                "path": "payloads.arguments.data",
+                "codec": "avro",
+                "available": false,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": null,
+                "avro_prefix_hex": null,
+                "writer_schema": null,
+                "writer_schema_fingerprint": null,
+                "diagnostic": "payload_unavailable"
+              },
+              {
+                "path": "payloads.output.data",
+                "codec": "avro",
+                "available": false,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": null,
+                "avro_prefix_hex": null,
+                "writer_schema": null,
+                "writer_schema_fingerprint": null,
+                "diagnostic": "payload_unavailable"
+              },
+              {
+                "path": "history_events.5.payload.output",
+                "codec": "avro",
+                "available": false,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": null,
+                "avro_prefix_hex": null,
+                "writer_schema": null,
+                "writer_schema_fingerprint": null,
+                "diagnostic": "payload_unavailable"
+              }
+            ]
+          },
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.0.68",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4101",
+                "legacy_workflow_id": "4101"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{completed.workflow}",
+                "run_id": "{completed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": "redis",
+              "name": "legacy-orders",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.output",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.signal_arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.exception_values",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{completed.dedupe}"
+            }
+          },
+          "integrity": {
+            "canonicalization": "json-recursive-ksort-v1",
+            "checksum_algorithm": "sha256",
+            "checksum": "{completed.export_checksum}",
+            "signature_algorithm": null,
+            "signature": null,
+            "key_id": null
+          },
+          "integrity_verified": true
+        }
+      },
+      "read_running_describe": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{running.workflow}",
+          "run_id": "{running.run}",
+          "namespace": "{id}-wl1",
+          "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+          "business_key": null,
+          "status": "running",
+          "status_bucket": "running",
+          "is_terminal": false,
+          "closed_reason": null,
+          "task_queue": "legacy-billing",
+          "run_number": 1,
+          "run_count": 1,
+          "is_current_run": true,
+          "continued_from_run_id": null,
+          "resume_step_sequence": null,
+          "recovery_kind": null,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "payload_codec": null,
+          "definition_routing": null,
+          "execution_timeout_seconds": null,
+          "run_timeout_seconds": null,
+          "execution_deadline_at": null,
+          "run_deadline_at": null,
+          "input": null,
+          "output": null,
+          "input_envelope": null,
+          "output_envelope": null,
+          "payload_previews": {
+            "input_omitted": false,
+            "output_omitted": false,
+            "max_encoded_bytes": 2097152
+          },
+          "started_at": "2026-09-30T09:00:00.000000Z",
+          "closed_at": null,
+          "last_progress_at": "2026-09-30T09:00:00.000000Z",
+          "wait_kind": null,
+          "wait_reason": null,
+          "memo": [],
+          "search_attributes": [],
+          "actions": {
+            "can_signal": false,
+            "can_query": false,
+            "can_update": false,
+            "can_cancel": false,
+            "can_terminate": false,
+            "can_repair": false,
+            "can_archive": false
+          },
+          "commands_scope": "selected_run",
+          "commands": [],
+          "updates_scope": "selected_run",
+          "updates": [],
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.x",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4201",
+                "legacy_workflow_id": "4201"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{running.workflow}",
+                "run_id": "{running.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": "database",
+              "name": "legacy-billing",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "runtime.execution",
+                "reason": "finish_on_v1_execution_not_transferable",
+                "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{running.dedupe}"
+            }
+          },
+          "action_blocked_reason": "v1_projection_read_only",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "describe",
+            "workflow_id": "{running.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": []
+            },
+            "run_id": "{running.run}",
+            "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+            "namespace": "{id}-wl1",
+            "business_key": null,
+            "status": "running",
+            "status_bucket": "running",
+            "is_terminal": false,
+            "task_queue": "legacy-billing",
+            "run_number": 1,
+            "run_count": 1,
+            "is_current_run": true,
+            "compatibility": null,
+            "started_at": "2026-09-30T09:00:00.000000Z",
+            "closed_at": null,
+            "last_progress_at": "2026-09-30T09:00:00.000000Z",
+            "wait_kind": null,
+            "wait_reason": null
+          }
+        }
+      },
+      "read_running_run": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{running.workflow}",
+          "run_id": "{running.run}",
+          "namespace": "{id}-wl1",
+          "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+          "business_key": null,
+          "status": "running",
+          "status_bucket": "running",
+          "is_terminal": false,
+          "closed_reason": null,
+          "task_queue": "legacy-billing",
+          "run_number": 1,
+          "run_count": 1,
+          "is_current_run": true,
+          "continued_from_run_id": null,
+          "resume_step_sequence": null,
+          "recovery_kind": null,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "payload_codec": null,
+          "definition_routing": null,
+          "execution_timeout_seconds": null,
+          "run_timeout_seconds": null,
+          "execution_deadline_at": null,
+          "run_deadline_at": null,
+          "input": null,
+          "output": null,
+          "input_envelope": null,
+          "output_envelope": null,
+          "payload_previews": {
+            "input_omitted": false,
+            "output_omitted": false,
+            "max_encoded_bytes": 2097152
+          },
+          "started_at": "2026-09-30T09:00:00.000000Z",
+          "closed_at": null,
+          "last_progress_at": "2026-09-30T09:00:00.000000Z",
+          "wait_kind": null,
+          "wait_reason": null,
+          "memo": [],
+          "search_attributes": [],
+          "actions": {
+            "can_signal": false,
+            "can_query": false,
+            "can_update": false,
+            "can_cancel": false,
+            "can_terminate": false,
+            "can_repair": false,
+            "can_archive": false
+          },
+          "commands_scope": "selected_run",
+          "commands": [],
+          "updates_scope": "selected_run",
+          "updates": [],
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.x",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4201",
+                "legacy_workflow_id": "4201"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{running.workflow}",
+                "run_id": "{running.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": "database",
+              "name": "legacy-billing",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "runtime.execution",
+                "reason": "finish_on_v1_execution_not_transferable",
+                "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{running.dedupe}"
+            }
+          },
+          "action_blocked_reason": "v1_projection_read_only",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "describe_run",
+            "workflow_id": "{running.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": [
+                "run_id"
+              ],
+              "rejection_fields": [
+                "workflow_id",
+                "run_id",
+                "reason",
+                "message",
+                "retryable",
+                "error_id",
+                "exception"
+              ],
+              "rejection_reasons": [
+                "control_plane_internal_error"
+              ]
+            },
+            "run_id": "{running.run}",
+            "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+            "namespace": "{id}-wl1",
+            "business_key": null,
+            "status": "running",
+            "status_bucket": "running",
+            "is_terminal": false,
+            "task_queue": "legacy-billing",
+            "run_number": 1,
+            "run_count": 1,
+            "is_current_run": true,
+            "compatibility": null,
+            "started_at": "2026-09-30T09:00:00.000000Z",
+            "closed_at": null,
+            "last_progress_at": "2026-09-30T09:00:00.000000Z",
+            "wait_kind": null,
+            "wait_reason": null
+          }
+        }
+      },
+      "read_running_runs": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{running.workflow}",
+          "run_count": 1,
+          "runs": [
+            {
+              "run_id": "{running.run}",
+              "run_number": 1,
+              "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+              "business_key": null,
+              "status": "running",
+              "status_bucket": "running",
+              "is_terminal": false,
+              "is_current_run": true,
+              "task_queue": "legacy-billing",
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": "2026-09-30T09:00:00.000000Z",
+              "closed_at": null
+            }
+          ],
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "list_runs",
+            "workflow_id": "{running.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": []
+            },
+            "run_count": 1
+          }
+        }
+      },
+      "read_running_history": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{running.workflow}",
+          "run_id": "{running.run}",
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "events": [
+            {
+              "sequence": 1,
+              "event_type": "WorkflowStarted",
+              "timestamp": "2026-09-30T09:00:00.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "origin": {
+                    "engine_source": "v1",
+                    "engine_version": "1.x",
+                    "execution_engine": "finish-on-v1"
+                  },
+                  "identity": {
+                    "waterline": {
+                      "source_id": "{id}",
+                      "qualified_workflow_id": "v1:4201",
+                      "legacy_workflow_id": "4201"
+                    },
+                    "standalone": {
+                      "namespace": "{id}-wl1",
+                      "workflow_id": "{running.workflow}",
+                      "run_id": "{running.run}"
+                    },
+                    "relationship": "deterministic_source_qualified_projection",
+                    "collision_policy": "reject_without_overwrite"
+                  },
+                  "task_queue_context": {
+                    "connection": "database",
+                    "name": "legacy-billing",
+                    "execution_owner": "v1",
+                    "standalone_dispatch": "disabled"
+                  },
+                  "unsupported_fields": [
+                    {
+                      "field": "runtime.replay",
+                      "reason": "v1_history_not_replayable_as_v2",
+                      "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                    },
+                    {
+                      "field": "timers",
+                      "reason": "legacy_timer_state_not_exposed_by_waterline",
+                      "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                    },
+                    {
+                      "field": "payloads.arguments",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.activity_results",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "runtime.execution",
+                      "reason": "finish_on_v1_execution_not_transferable",
+                      "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+                    }
+                  ]
+                },
+                "legacy_payloads": {
+                  "arguments": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "a:0:{}",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 2,
+              "event_type": "ActivityCompleted",
+              "timestamp": "2026-09-30T09:00:02.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9101,
+                  "legacy_index": 0
+                },
+                "activity": {
+                  "class": "App\\Activities\\Bill",
+                  "logical_time": "2026-09-30T09:00:01.000000Z",
+                  "result": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "i:42;",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            }
+          ],
+          "next_page_token": null,
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.x",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4201",
+                "legacy_workflow_id": "4201"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{running.workflow}",
+                "run_id": "{running.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": "database",
+              "name": "legacy-billing",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "runtime.execution",
+                "reason": "finish_on_v1_execution_not_transferable",
+                "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{running.dedupe}"
+            }
+          },
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "history",
+            "workflow_id": "{running.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id",
+                "run_id"
+              ],
+              "success_fields": [
+                "next_page_token"
+              ],
+              "rejection_fields": [
+                "workflow_id",
+                "run_id",
+                "reason",
+                "message",
+                "retryable",
+                "error_id",
+                "exception"
+              ],
+              "rejection_reasons": [
+                "control_plane_internal_error"
+              ]
+            },
+            "run_id": "{running.run}",
+            "compatibility": null,
+            "next_page_token": null
+          }
+        }
+      },
+      "read_running_export": {
+        "status": 200,
+        "response": {
+          "schema": "durable-workflow.v2.history-export",
+          "schema_version": 2,
+          "exported_at": "{exported_at}",
+          "dedupe_key": "{running.run}:2:2026-09-30T09:00:00.000000Z",
+          "history_complete": false,
+          "workflow": {
+            "instance_id": "{running.workflow}",
+            "run_id": "{running.run}",
+            "run_number": 1,
+            "is_current_run": true,
+            "current_run_id": "{running.run}",
+            "current_run_source": "run_order_fallback",
+            "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+            "workflow_class": "App\\Workflows\\Legacy\\Subscription",
+            "source_runtime": "standalone_server",
+            "source_process_class": "server_http_node",
+            "business_key": null,
+            "visibility_labels": [],
+            "memo": [],
+            "memo_payload": {
+              "codec": "avro",
+              "blob": "wwHioz3/VYAiNw4A"
+            },
+            "search_attributes": [],
+            "status": "running",
+            "status_bucket": "running",
+            "closed_reason": null,
+            "archived_at": null,
+            "archive_command_id": null,
+            "archive_reason": null,
+            "compatibility": null,
+            "connection": "database",
+            "queue": "legacy-billing",
+            "last_history_sequence": 2,
+            "started_at": "2026-09-30T09:00:00.000000Z",
+            "closed_at": null,
+            "last_progress_at": "2026-09-30T09:00:00.000000Z"
+          },
+          "payloads": {
+            "codec": "avro",
+            "arguments": {
+              "available": false,
+              "data": null
+            },
+            "output": {
+              "available": false,
+              "codec": null,
+              "data": null
+            }
+          },
+          "summary": {
+            "status": "running",
+            "status_bucket": "running",
+            "closed_reason": null,
+            "archived_at": null,
+            "archive_command_id": null,
+            "archive_reason": null,
+            "business_key": null,
+            "visibility_labels": [],
+            "search_attributes": [],
+            "is_current_run": true,
+            "started_at": "2026-09-30T09:00:00.000000Z",
+            "closed_at": null,
+            "duration_ms": null,
+            "wait_kind": null,
+            "wait_reason": null,
+            "wait_started_at": null,
+            "wait_deadline_at": null,
+            "open_wait_id": null,
+            "resume_source_kind": null,
+            "resume_source_id": null,
+            "next_task_at": null,
+            "next_task_id": null,
+            "next_task_type": null,
+            "next_task_status": null,
+            "next_task_lease_expires_at": null,
+            "liveness_state": "external_v1",
+            "liveness_reason": "Execution remains owned by the source v1 runtime; this standalone row is read-only.",
+            "repair_attention": false,
+            "task_problem": false,
+            "task_problem_badge": null,
+            "exception_count": 0,
+            "history_event_count": 2,
+            "history_size_bytes": 2683,
+            "history_fan_out": 0,
+            "continue_as_new_recommended": false,
+            "history_budget_pressure": "ok",
+            "sort_timestamp": "2026-09-30T09:00:00.000000Z",
+            "sort_key": null
+          },
+          "history_events": [
+            {
+              "id": "{running.e1}",
+              "sequence": 1,
+              "type": "WorkflowStarted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T09:00:00.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "origin": {
+                    "engine_source": "v1",
+                    "engine_version": "1.x",
+                    "execution_engine": "finish-on-v1"
+                  },
+                  "identity": {
+                    "waterline": {
+                      "source_id": "{id}",
+                      "qualified_workflow_id": "v1:4201",
+                      "legacy_workflow_id": "4201"
+                    },
+                    "standalone": {
+                      "namespace": "{id}-wl1",
+                      "workflow_id": "{running.workflow}",
+                      "run_id": "{running.run}"
+                    },
+                    "relationship": "deterministic_source_qualified_projection",
+                    "collision_policy": "reject_without_overwrite"
+                  },
+                  "task_queue_context": {
+                    "connection": "database",
+                    "name": "legacy-billing",
+                    "execution_owner": "v1",
+                    "standalone_dispatch": "disabled"
+                  },
+                  "unsupported_fields": [
+                    {
+                      "field": "runtime.replay",
+                      "reason": "v1_history_not_replayable_as_v2",
+                      "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                    },
+                    {
+                      "field": "timers",
+                      "reason": "legacy_timer_state_not_exposed_by_waterline",
+                      "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                    },
+                    {
+                      "field": "payloads.arguments",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.activity_results",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "runtime.execution",
+                      "reason": "finish_on_v1_execution_not_transferable",
+                      "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+                    }
+                  ]
+                },
+                "legacy_payloads": {
+                  "arguments": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "a:0:{}",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{running.e2}",
+              "sequence": 2,
+              "type": "ActivityCompleted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T09:00:02.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9101,
+                  "legacy_index": 0
+                },
+                "activity": {
+                  "class": "App\\Activities\\Bill",
+                  "logical_time": "2026-09-30T09:00:01.000000Z",
+                  "result": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "i:42;",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            }
+          ],
+          "linked_intakes_scope": "selected_run",
+          "linked_intakes": [],
+          "commands": [],
+          "signals": [],
+          "updates": [],
+          "tasks": [],
+          "activities": [],
+          "timers": [],
+          "failures": [],
+          "links": {
+            "parents": [],
+            "children": []
+          },
+          "redaction": {
+            "applied": false,
+            "policy": null,
+            "paths": []
+          },
+          "codec_schemas": {
+            "avro": {
+              "encoding": "base64-avro-single-object",
+              "framing": "single_object",
+              "magic_hex": "c301",
+              "current_fingerprint": "e2a33dff55802237",
+              "writer_schemas": {
+                "e2a33dff55802237": {
+                  "schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+                  "fingerprint": "crc64-avro:e2a33dff55802237"
+                }
+              }
+            }
+          },
+          "payload_manifest": {
+            "version": 1,
+            "entries": [
+              {
+                "path": "workflow.memo_payload",
+                "codec": "avro",
+                "available": true,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": "single_object",
+                "avro_prefix_hex": "c301",
+                "writer_schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+                "writer_schema_fingerprint": "crc64-avro:e2a33dff55802237",
+                "diagnostic": null
+              },
+              {
+                "path": "payloads.arguments.data",
+                "codec": "avro",
+                "available": false,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": null,
+                "avro_prefix_hex": null,
+                "writer_schema": null,
+                "writer_schema_fingerprint": null,
+                "diagnostic": "payload_unavailable"
+              },
+              {
+                "path": "payloads.output.data",
+                "codec": "avro",
+                "available": false,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": null,
+                "avro_prefix_hex": null,
+                "writer_schema": null,
+                "writer_schema_fingerprint": null,
+                "diagnostic": "payload_unavailable"
+              }
+            ]
+          },
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.x",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4201",
+                "legacy_workflow_id": "4201"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{running.workflow}",
+                "run_id": "{running.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": "database",
+              "name": "legacy-billing",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "runtime.execution",
+                "reason": "finish_on_v1_execution_not_transferable",
+                "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{running.dedupe}"
+            }
+          },
+          "integrity": {
+            "canonicalization": "json-recursive-ksort-v1",
+            "checksum_algorithm": "sha256",
+            "checksum": "{running.export_checksum}",
+            "signature_algorithm": null,
+            "signature": null,
+            "key_id": null
+          },
+          "integrity_verified": true
+        }
+      },
+      "read_failed_describe": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{status-failed.workflow}",
+          "run_id": "{status-failed.run}",
+          "namespace": "{id}-wl1",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "failed",
+          "status_bucket": "failed",
+          "is_terminal": true,
+          "closed_reason": "failed",
+          "task_queue": "legacy-orders",
+          "run_number": 1,
+          "run_count": 1,
+          "is_current_run": true,
+          "continued_from_run_id": null,
+          "resume_step_sequence": null,
+          "recovery_kind": null,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "payload_codec": null,
+          "definition_routing": null,
+          "execution_timeout_seconds": null,
+          "run_timeout_seconds": null,
+          "execution_deadline_at": null,
+          "run_deadline_at": null,
+          "input": null,
+          "output": null,
+          "input_envelope": null,
+          "output_envelope": null,
+          "payload_previews": {
+            "input_omitted": false,
+            "output_omitted": false,
+            "max_encoded_bytes": 2097152
+          },
+          "started_at": "2026-09-30T07:03:00.000000Z",
+          "closed_at": "2026-09-30T07:03:30.000000Z",
+          "last_progress_at": "2026-09-30T07:03:30.000000Z",
+          "wait_kind": null,
+          "wait_reason": null,
+          "memo": [],
+          "search_attributes": [],
+          "actions": {
+            "can_signal": false,
+            "can_query": false,
+            "can_update": false,
+            "can_cancel": false,
+            "can_terminate": false,
+            "can_repair": false,
+            "can_archive": false
+          },
+          "commands_scope": "selected_run",
+          "commands": [],
+          "updates_scope": "selected_run",
+          "updates": [],
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.0.68",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4303",
+                "legacy_workflow_id": "4303"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{status-failed.workflow}",
+                "run_id": "{status-failed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": "redis",
+              "name": "legacy-orders",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.output",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.signal_arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.exception_values",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{status-failed.dedupe}"
+            }
+          },
+          "action_blocked_reason": "v1_projection_read_only",
+          "error": null,
+          "failure": {
+            "activity_failures": [
+              {
+                "event_sequence": 4,
+                "event_type": "ActivityFailed"
+              }
+            ]
+          },
+          "exception": null,
+          "failures": [],
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "describe",
+            "workflow_id": "{status-failed.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": []
+            },
+            "run_id": "{status-failed.run}",
+            "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+            "namespace": "{id}-wl1",
+            "business_key": null,
+            "status": "failed",
+            "status_bucket": "failed",
+            "is_terminal": true,
+            "task_queue": "legacy-orders",
+            "run_number": 1,
+            "run_count": 1,
+            "is_current_run": true,
+            "compatibility": null,
+            "started_at": "2026-09-30T07:03:00.000000Z",
+            "closed_at": "2026-09-30T07:03:30.000000Z",
+            "last_progress_at": "2026-09-30T07:03:30.000000Z",
+            "wait_kind": null,
+            "wait_reason": null,
+            "exception": null
+          }
+        }
+      },
+      "read_failed_run": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{status-failed.workflow}",
+          "run_id": "{status-failed.run}",
+          "namespace": "{id}-wl1",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "failed",
+          "status_bucket": "failed",
+          "is_terminal": true,
+          "closed_reason": "failed",
+          "task_queue": "legacy-orders",
+          "run_number": 1,
+          "run_count": 1,
+          "is_current_run": true,
+          "continued_from_run_id": null,
+          "resume_step_sequence": null,
+          "recovery_kind": null,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "payload_codec": null,
+          "definition_routing": null,
+          "execution_timeout_seconds": null,
+          "run_timeout_seconds": null,
+          "execution_deadline_at": null,
+          "run_deadline_at": null,
+          "input": null,
+          "output": null,
+          "input_envelope": null,
+          "output_envelope": null,
+          "payload_previews": {
+            "input_omitted": false,
+            "output_omitted": false,
+            "max_encoded_bytes": 2097152
+          },
+          "started_at": "2026-09-30T07:03:00.000000Z",
+          "closed_at": "2026-09-30T07:03:30.000000Z",
+          "last_progress_at": "2026-09-30T07:03:30.000000Z",
+          "wait_kind": null,
+          "wait_reason": null,
+          "memo": [],
+          "search_attributes": [],
+          "actions": {
+            "can_signal": false,
+            "can_query": false,
+            "can_update": false,
+            "can_cancel": false,
+            "can_terminate": false,
+            "can_repair": false,
+            "can_archive": false
+          },
+          "commands_scope": "selected_run",
+          "commands": [],
+          "updates_scope": "selected_run",
+          "updates": [],
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.0.68",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4303",
+                "legacy_workflow_id": "4303"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{status-failed.workflow}",
+                "run_id": "{status-failed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": "redis",
+              "name": "legacy-orders",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.output",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.signal_arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.exception_values",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{status-failed.dedupe}"
+            }
+          },
+          "action_blocked_reason": "v1_projection_read_only",
+          "error": null,
+          "failure": {
+            "activity_failures": [
+              {
+                "event_sequence": 4,
+                "event_type": "ActivityFailed"
+              }
+            ]
+          },
+          "exception": null,
+          "failures": [],
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "describe_run",
+            "workflow_id": "{status-failed.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": [
+                "run_id"
+              ],
+              "rejection_fields": [
+                "workflow_id",
+                "run_id",
+                "reason",
+                "message",
+                "retryable",
+                "error_id",
+                "exception"
+              ],
+              "rejection_reasons": [
+                "control_plane_internal_error"
+              ]
+            },
+            "run_id": "{status-failed.run}",
+            "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+            "namespace": "{id}-wl1",
+            "business_key": null,
+            "status": "failed",
+            "status_bucket": "failed",
+            "is_terminal": true,
+            "task_queue": "legacy-orders",
+            "run_number": 1,
+            "run_count": 1,
+            "is_current_run": true,
+            "compatibility": null,
+            "started_at": "2026-09-30T07:03:00.000000Z",
+            "closed_at": "2026-09-30T07:03:30.000000Z",
+            "last_progress_at": "2026-09-30T07:03:30.000000Z",
+            "wait_kind": null,
+            "wait_reason": null,
+            "exception": null
+          }
+        }
+      },
+      "read_failed_runs": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{status-failed.workflow}",
+          "run_count": 1,
+          "runs": [
+            {
+              "run_id": "{status-failed.run}",
+              "run_number": 1,
+              "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+              "business_key": null,
+              "status": "failed",
+              "status_bucket": "failed",
+              "is_terminal": true,
+              "is_current_run": true,
+              "task_queue": "legacy-orders",
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": "2026-09-30T07:03:00.000000Z",
+              "closed_at": "2026-09-30T07:03:30.000000Z"
+            }
+          ],
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "list_runs",
+            "workflow_id": "{status-failed.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": []
+            },
+            "run_count": 1
+          }
+        }
+      },
+      "read_failed_history": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{status-failed.workflow}",
+          "run_id": "{status-failed.run}",
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "events": [
+            {
+              "sequence": 1,
+              "event_type": "WorkflowStarted",
+              "timestamp": "2026-09-30T07:03:00.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "origin": {
+                    "engine_source": "v1",
+                    "engine_version": "1.0.68",
+                    "execution_engine": "finish-on-v1"
+                  },
+                  "identity": {
+                    "waterline": {
+                      "source_id": "{id}",
+                      "qualified_workflow_id": "v1:4303",
+                      "legacy_workflow_id": "4303"
+                    },
+                    "standalone": {
+                      "namespace": "{id}-wl1",
+                      "workflow_id": "{status-failed.workflow}",
+                      "run_id": "{status-failed.run}"
+                    },
+                    "relationship": "deterministic_source_qualified_projection",
+                    "collision_policy": "reject_without_overwrite"
+                  },
+                  "task_queue_context": {
+                    "connection": "redis",
+                    "name": "legacy-orders",
+                    "execution_owner": "v1",
+                    "standalone_dispatch": "disabled"
+                  },
+                  "unsupported_fields": [
+                    {
+                      "field": "runtime.replay",
+                      "reason": "v1_history_not_replayable_as_v2",
+                      "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                    },
+                    {
+                      "field": "timers",
+                      "reason": "legacy_timer_state_not_exposed_by_waterline",
+                      "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                    },
+                    {
+                      "field": "payloads.arguments",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.output",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.activity_results",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.signal_arguments",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.exception_values",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    }
+                  ]
+                },
+                "legacy_payloads": {
+                  "arguments": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "a:1:{i:0;s:7:\"order-7\";}",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 2,
+              "event_type": "ActivityCompleted",
+              "timestamp": "2026-09-30T08:00:02.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9001,
+                  "legacy_index": 0
+                },
+                "activity": {
+                  "class": "App\\Activities\\ReserveStock",
+                  "logical_time": "2026-09-30T08:00:01.000000Z",
+                  "result": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "b:1;",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 3,
+              "event_type": "SignalReceived",
+              "timestamp": "2026-09-30T08:00:03.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_signal",
+                  "legacy_id": 7001
+                },
+                "signal_name": "approve-λ",
+                "arguments": {
+                  "available": true,
+                  "encoding": "php-serialize",
+                  "value": "a:1:{i:0;s:3:\"yes\";}",
+                  "portable": false,
+                  "unsupported_reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                }
+              }
+            },
+            {
+              "sequence": 4,
+              "event_type": "ActivityFailed",
+              "timestamp": "2026-09-30T08:00:04.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_exception",
+                  "legacy_id": 5001
+                },
+                "exception": {
+                  "value": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "O:9:\"Exception\":0:{}",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 5,
+              "event_type": "ActivityCompleted",
+              "timestamp": "2026-09-30T08:00:05.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9002,
+                  "legacy_index": 1
+                },
+                "activity": {
+                  "class": "App\\Activities\\ChargeCard",
+                  "logical_time": "2026-09-30T08:00:04.500000Z",
+                  "result": {
+                    "available": false,
+                    "encoding": "php-serialize",
+                    "value": null,
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 6,
+              "event_type": "WorkflowFailed",
+              "timestamp": "2026-09-30T07:03:30.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_status": "FAILED",
+                  "execution_owner": "v1"
+                },
+                "legacy_payloads": {
+                  "output": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "s:9:\"fulfilled\";",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            }
+          ],
+          "next_page_token": null,
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.0.68",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4303",
+                "legacy_workflow_id": "4303"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{status-failed.workflow}",
+                "run_id": "{status-failed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": "redis",
+              "name": "legacy-orders",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.output",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.signal_arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.exception_values",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{status-failed.dedupe}"
+            }
+          },
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "history",
+            "workflow_id": "{status-failed.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id",
+                "run_id"
+              ],
+              "success_fields": [
+                "next_page_token"
+              ],
+              "rejection_fields": [
+                "workflow_id",
+                "run_id",
+                "reason",
+                "message",
+                "retryable",
+                "error_id",
+                "exception"
+              ],
+              "rejection_reasons": [
+                "control_plane_internal_error"
+              ]
+            },
+            "run_id": "{status-failed.run}",
+            "compatibility": null,
+            "next_page_token": null
+          }
+        }
+      },
+      "read_failed_export": {
+        "status": 200,
+        "response": {
+          "schema": "durable-workflow.v2.history-export",
+          "schema_version": 2,
+          "exported_at": "{exported_at}",
+          "dedupe_key": "{status-failed.run}:6:2026-09-30T07:03:30.000000Z",
+          "history_complete": true,
+          "workflow": {
+            "instance_id": "{status-failed.workflow}",
+            "run_id": "{status-failed.run}",
+            "run_number": 1,
+            "is_current_run": true,
+            "current_run_id": "{status-failed.run}",
+            "current_run_source": "run_order_fallback",
+            "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+            "workflow_class": "App\\Workflows\\Legacy\\OrderFulfillment",
+            "source_runtime": "standalone_server",
+            "source_process_class": "server_http_node",
+            "business_key": null,
+            "visibility_labels": [],
+            "memo": [],
+            "memo_payload": {
+              "codec": "avro",
+              "blob": "wwHioz3/VYAiNw4A"
+            },
+            "search_attributes": [],
+            "status": "failed",
+            "status_bucket": "failed",
+            "closed_reason": "failed",
+            "archived_at": null,
+            "archive_command_id": null,
+            "archive_reason": null,
+            "compatibility": null,
+            "connection": "redis",
+            "queue": "legacy-orders",
+            "last_history_sequence": 6,
+            "started_at": "2026-09-30T07:03:00.000000Z",
+            "closed_at": "2026-09-30T07:03:30.000000Z",
+            "last_progress_at": "2026-09-30T07:03:30.000000Z"
+          },
+          "payloads": {
+            "codec": "avro",
+            "arguments": {
+              "available": false,
+              "data": null
+            },
+            "output": {
+              "available": false,
+              "codec": null,
+              "data": null
+            }
+          },
+          "summary": {
+            "status": "failed",
+            "status_bucket": "failed",
+            "closed_reason": "failed",
+            "archived_at": null,
+            "archive_command_id": null,
+            "archive_reason": null,
+            "business_key": null,
+            "visibility_labels": [],
+            "search_attributes": [],
+            "is_current_run": true,
+            "started_at": "2026-09-30T07:03:00.000000Z",
+            "closed_at": "2026-09-30T07:03:30.000000Z",
+            "duration_ms": null,
+            "wait_kind": null,
+            "wait_reason": null,
+            "wait_started_at": null,
+            "wait_deadline_at": null,
+            "open_wait_id": null,
+            "resume_source_kind": null,
+            "resume_source_id": null,
+            "next_task_at": null,
+            "next_task_id": null,
+            "next_task_type": null,
+            "next_task_status": null,
+            "next_task_lease_expires_at": null,
+            "liveness_state": null,
+            "liveness_reason": null,
+            "repair_attention": false,
+            "task_problem": false,
+            "task_problem_badge": null,
+            "exception_count": 1,
+            "history_event_count": 6,
+            "history_size_bytes": 5425,
+            "history_fan_out": 0,
+            "continue_as_new_recommended": false,
+            "history_budget_pressure": "ok",
+            "sort_timestamp": "2026-09-30T07:03:30.000000Z",
+            "sort_key": null
+          },
+          "history_events": [
+            {
+              "id": "{status-failed.e1}",
+              "sequence": 1,
+              "type": "WorkflowStarted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T07:03:00.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "origin": {
+                    "engine_source": "v1",
+                    "engine_version": "1.0.68",
+                    "execution_engine": "finish-on-v1"
+                  },
+                  "identity": {
+                    "waterline": {
+                      "source_id": "{id}",
+                      "qualified_workflow_id": "v1:4303",
+                      "legacy_workflow_id": "4303"
+                    },
+                    "standalone": {
+                      "namespace": "{id}-wl1",
+                      "workflow_id": "{status-failed.workflow}",
+                      "run_id": "{status-failed.run}"
+                    },
+                    "relationship": "deterministic_source_qualified_projection",
+                    "collision_policy": "reject_without_overwrite"
+                  },
+                  "task_queue_context": {
+                    "connection": "redis",
+                    "name": "legacy-orders",
+                    "execution_owner": "v1",
+                    "standalone_dispatch": "disabled"
+                  },
+                  "unsupported_fields": [
+                    {
+                      "field": "runtime.replay",
+                      "reason": "v1_history_not_replayable_as_v2",
+                      "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                    },
+                    {
+                      "field": "timers",
+                      "reason": "legacy_timer_state_not_exposed_by_waterline",
+                      "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                    },
+                    {
+                      "field": "payloads.arguments",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.output",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.activity_results",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.signal_arguments",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.exception_values",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    }
+                  ]
+                },
+                "legacy_payloads": {
+                  "arguments": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "a:1:{i:0;s:7:\"order-7\";}",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{status-failed.e2}",
+              "sequence": 2,
+              "type": "ActivityCompleted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:02.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9001,
+                  "legacy_index": 0
+                },
+                "activity": {
+                  "class": "App\\Activities\\ReserveStock",
+                  "logical_time": "2026-09-30T08:00:01.000000Z",
+                  "result": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "b:1;",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{status-failed.e3}",
+              "sequence": 3,
+              "type": "SignalReceived",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:03.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_signal",
+                  "legacy_id": 7001
+                },
+                "signal_name": "approve-λ",
+                "arguments": {
+                  "available": true,
+                  "encoding": "php-serialize",
+                  "value": "a:1:{i:0;s:3:\"yes\";}",
+                  "portable": false,
+                  "unsupported_reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                }
+              }
+            },
+            {
+              "id": "{status-failed.e4}",
+              "sequence": 4,
+              "type": "ActivityFailed",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:04.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_exception",
+                  "legacy_id": 5001
+                },
+                "exception": {
+                  "class": "App\\Activities\\ChargeCard",
+                  "value": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "O:9:\"Exception\":0:{}",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{status-failed.e5}",
+              "sequence": 5,
+              "type": "ActivityCompleted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:05.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9002,
+                  "legacy_index": 1
+                },
+                "activity": {
+                  "class": "App\\Activities\\ChargeCard",
+                  "logical_time": "2026-09-30T08:00:04.500000Z",
+                  "result": {
+                    "available": false,
+                    "encoding": "php-serialize",
+                    "value": null,
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{status-failed.e6}",
+              "sequence": 6,
+              "type": "WorkflowFailed",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T07:03:30.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_status": "FAILED",
+                  "execution_owner": "v1"
+                },
+                "legacy_payloads": {
+                  "output": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "s:9:\"fulfilled\";",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            }
+          ],
+          "linked_intakes_scope": "selected_run",
+          "linked_intakes": [],
+          "commands": [],
+          "signals": [],
+          "updates": [],
+          "tasks": [],
+          "activities": [],
+          "timers": [],
+          "failures": [],
+          "links": {
+            "parents": [],
+            "children": []
+          },
+          "redaction": {
+            "applied": false,
+            "policy": null,
+            "paths": []
+          },
+          "codec_schemas": {
+            "avro": {
+              "encoding": "base64-avro-single-object",
+              "framing": "single_object",
+              "magic_hex": "c301",
+              "current_fingerprint": "e2a33dff55802237",
+              "writer_schemas": {
+                "e2a33dff55802237": {
+                  "schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+                  "fingerprint": "crc64-avro:e2a33dff55802237"
+                }
+              }
+            }
+          },
+          "payload_manifest": {
+            "version": 1,
+            "entries": [
+              {
+                "path": "workflow.memo_payload",
+                "codec": "avro",
+                "available": true,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": "single_object",
+                "avro_prefix_hex": "c301",
+                "writer_schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+                "writer_schema_fingerprint": "crc64-avro:e2a33dff55802237",
+                "diagnostic": null
+              },
+              {
+                "path": "payloads.arguments.data",
+                "codec": "avro",
+                "available": false,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": null,
+                "avro_prefix_hex": null,
+                "writer_schema": null,
+                "writer_schema_fingerprint": null,
+                "diagnostic": "payload_unavailable"
+              },
+              {
+                "path": "payloads.output.data",
+                "codec": "avro",
+                "available": false,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": null,
+                "avro_prefix_hex": null,
+                "writer_schema": null,
+                "writer_schema_fingerprint": null,
+                "diagnostic": "payload_unavailable"
+              }
+            ]
+          },
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.0.68",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4303",
+                "legacy_workflow_id": "4303"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{status-failed.workflow}",
+                "run_id": "{status-failed.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": "redis",
+              "name": "legacy-orders",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.output",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.signal_arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.exception_values",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{status-failed.dedupe}"
+            }
+          },
+          "integrity": {
+            "canonicalization": "json-recursive-ksort-v1",
+            "checksum_algorithm": "sha256",
+            "checksum": "{status-failed.export_checksum}",
+            "signature_algorithm": null,
+            "signature": null,
+            "key_id": null
+          },
+          "integrity_verified": true
+        }
+      },
+      "read_offsets_describe": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{offsets.workflow}",
+          "run_id": "{offsets.run}",
+          "namespace": "{id}-wl1",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "completed",
+          "status_bucket": "completed",
+          "is_terminal": true,
+          "closed_reason": "completed",
+          "task_queue": "legacy-orders",
+          "run_number": 1,
+          "run_count": 1,
+          "is_current_run": true,
+          "continued_from_run_id": null,
+          "resume_step_sequence": null,
+          "recovery_kind": null,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "payload_codec": null,
+          "definition_routing": null,
+          "execution_timeout_seconds": null,
+          "run_timeout_seconds": null,
+          "execution_deadline_at": null,
+          "run_deadline_at": null,
+          "input": null,
+          "output": null,
+          "input_envelope": null,
+          "output_envelope": null,
+          "payload_previews": {
+            "input_omitted": false,
+            "output_omitted": false,
+            "max_encoded_bytes": 2097152
+          },
+          "started_at": "2026-09-30T10:00:00.000000Z",
+          "closed_at": "2026-09-30T10:00:00.000000Z",
+          "last_progress_at": "2026-09-30T10:00:00.000000Z",
+          "wait_kind": null,
+          "wait_reason": null,
+          "memo": [],
+          "search_attributes": [],
+          "actions": {
+            "can_signal": false,
+            "can_query": false,
+            "can_update": false,
+            "can_cancel": false,
+            "can_terminate": false,
+            "can_repair": false,
+            "can_archive": false
+          },
+          "commands_scope": "selected_run",
+          "commands": [],
+          "updates_scope": "selected_run",
+          "updates": [],
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.0.68",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4401",
+                "legacy_workflow_id": "4401"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{offsets.workflow}",
+                "run_id": "{offsets.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": null,
+              "name": "legacy-orders",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.output",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.signal_arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.exception_values",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{offsets.dedupe}"
+            }
+          },
+          "action_blocked_reason": "v1_projection_read_only",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "describe",
+            "workflow_id": "{offsets.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": []
+            },
+            "run_id": "{offsets.run}",
+            "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+            "namespace": "{id}-wl1",
+            "business_key": null,
+            "status": "completed",
+            "status_bucket": "completed",
+            "is_terminal": true,
+            "task_queue": "legacy-orders",
+            "run_number": 1,
+            "run_count": 1,
+            "is_current_run": true,
+            "compatibility": null,
+            "started_at": "2026-09-30T10:00:00.000000Z",
+            "closed_at": "2026-09-30T10:00:00.000000Z",
+            "last_progress_at": "2026-09-30T10:00:00.000000Z",
+            "wait_kind": null,
+            "wait_reason": null
+          }
+        }
+      },
+      "read_offsets_run": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{offsets.workflow}",
+          "run_id": "{offsets.run}",
+          "namespace": "{id}-wl1",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "completed",
+          "status_bucket": "completed",
+          "is_terminal": true,
+          "closed_reason": "completed",
+          "task_queue": "legacy-orders",
+          "run_number": 1,
+          "run_count": 1,
+          "is_current_run": true,
+          "continued_from_run_id": null,
+          "resume_step_sequence": null,
+          "recovery_kind": null,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "payload_codec": null,
+          "definition_routing": null,
+          "execution_timeout_seconds": null,
+          "run_timeout_seconds": null,
+          "execution_deadline_at": null,
+          "run_deadline_at": null,
+          "input": null,
+          "output": null,
+          "input_envelope": null,
+          "output_envelope": null,
+          "payload_previews": {
+            "input_omitted": false,
+            "output_omitted": false,
+            "max_encoded_bytes": 2097152
+          },
+          "started_at": "2026-09-30T10:00:00.000000Z",
+          "closed_at": "2026-09-30T10:00:00.000000Z",
+          "last_progress_at": "2026-09-30T10:00:00.000000Z",
+          "wait_kind": null,
+          "wait_reason": null,
+          "memo": [],
+          "search_attributes": [],
+          "actions": {
+            "can_signal": false,
+            "can_query": false,
+            "can_update": false,
+            "can_cancel": false,
+            "can_terminate": false,
+            "can_repair": false,
+            "can_archive": false
+          },
+          "commands_scope": "selected_run",
+          "commands": [],
+          "updates_scope": "selected_run",
+          "updates": [],
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.0.68",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4401",
+                "legacy_workflow_id": "4401"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{offsets.workflow}",
+                "run_id": "{offsets.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": null,
+              "name": "legacy-orders",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.output",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.signal_arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.exception_values",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{offsets.dedupe}"
+            }
+          },
+          "action_blocked_reason": "v1_projection_read_only",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "describe_run",
+            "workflow_id": "{offsets.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": [
+                "run_id"
+              ],
+              "rejection_fields": [
+                "workflow_id",
+                "run_id",
+                "reason",
+                "message",
+                "retryable",
+                "error_id",
+                "exception"
+              ],
+              "rejection_reasons": [
+                "control_plane_internal_error"
+              ]
+            },
+            "run_id": "{offsets.run}",
+            "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+            "namespace": "{id}-wl1",
+            "business_key": null,
+            "status": "completed",
+            "status_bucket": "completed",
+            "is_terminal": true,
+            "task_queue": "legacy-orders",
+            "run_number": 1,
+            "run_count": 1,
+            "is_current_run": true,
+            "compatibility": null,
+            "started_at": "2026-09-30T10:00:00.000000Z",
+            "closed_at": "2026-09-30T10:00:00.000000Z",
+            "last_progress_at": "2026-09-30T10:00:00.000000Z",
+            "wait_kind": null,
+            "wait_reason": null
+          }
+        }
+      },
+      "read_offsets_runs": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{offsets.workflow}",
+          "run_count": 1,
+          "runs": [
+            {
+              "run_id": "{offsets.run}",
+              "run_number": 1,
+              "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+              "business_key": null,
+              "status": "completed",
+              "status_bucket": "completed",
+              "is_terminal": true,
+              "is_current_run": true,
+              "task_queue": "legacy-orders",
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": "2026-09-30T10:00:00.000000Z",
+              "closed_at": "2026-09-30T10:00:00.000000Z"
+            }
+          ],
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "list_runs",
+            "workflow_id": "{offsets.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": []
+            },
+            "run_count": 1
+          }
+        }
+      },
+      "read_offsets_history": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{offsets.workflow}",
+          "run_id": "{offsets.run}",
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "events": [
+            {
+              "sequence": 1,
+              "event_type": "WorkflowStarted",
+              "timestamp": "2026-09-30T08:00:00.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "origin": {
+                    "engine_source": "v1",
+                    "engine_version": "1.0.68",
+                    "execution_engine": "finish-on-v1"
+                  },
+                  "identity": {
+                    "waterline": {
+                      "source_id": "{id}",
+                      "qualified_workflow_id": "v1:4401",
+                      "legacy_workflow_id": "4401"
+                    },
+                    "standalone": {
+                      "namespace": "{id}-wl1",
+                      "workflow_id": "{offsets.workflow}",
+                      "run_id": "{offsets.run}"
+                    },
+                    "relationship": "deterministic_source_qualified_projection",
+                    "collision_policy": "reject_without_overwrite"
+                  },
+                  "task_queue_context": {
+                    "connection": null,
+                    "name": "legacy-orders",
+                    "execution_owner": "v1",
+                    "standalone_dispatch": "disabled"
+                  },
+                  "unsupported_fields": [
+                    {
+                      "field": "runtime.replay",
+                      "reason": "v1_history_not_replayable_as_v2",
+                      "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                    },
+                    {
+                      "field": "timers",
+                      "reason": "legacy_timer_state_not_exposed_by_waterline",
+                      "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                    },
+                    {
+                      "field": "payloads.output",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.activity_results",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.signal_arguments",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.exception_values",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    }
+                  ]
+                },
+                "legacy_payloads": {
+                  "arguments": {
+                    "available": false,
+                    "encoding": "php-serialize",
+                    "value": null,
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 2,
+              "event_type": "ActivityCompleted",
+              "timestamp": null,
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9003,
+                  "legacy_index": null
+                },
+                "activity": {
+                  "class": "App\\Activities\\Untimed",
+                  "logical_time": null,
+                  "result": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": null,
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 3,
+              "event_type": "SignalReceived",
+              "timestamp": null,
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_signal",
+                  "legacy_id": 7002
+                },
+                "signal_name": "named",
+                "arguments": {
+                  "available": false,
+                  "encoding": "php-serialize",
+                  "value": null,
+                  "portable": false,
+                  "unsupported_reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                }
+              }
+            },
+            {
+              "sequence": 4,
+              "event_type": "SignalReceived",
+              "timestamp": "2026-09-30T08:00:00.500000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_signal",
+                  "legacy_id": 7001
+                },
+                "signal_name": "approve-λ",
+                "arguments": {
+                  "available": true,
+                  "encoding": "php-serialize",
+                  "value": "a:1:{i:0;s:3:\"yes\";}",
+                  "portable": false,
+                  "unsupported_reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                }
+              }
+            },
+            {
+              "sequence": 5,
+              "event_type": "ActivityCompleted",
+              "timestamp": "2026-09-30T08:00:02.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9001,
+                  "legacy_index": 0
+                },
+                "activity": {
+                  "class": "App\\Activities\\ReserveStock",
+                  "logical_time": "2026-09-30T08:00:01.000000Z",
+                  "result": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "b:1;",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 6,
+              "event_type": "ActivityFailed",
+              "timestamp": "2026-09-30T08:00:04.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_exception",
+                  "legacy_id": 5001
+                },
+                "exception": {
+                  "value": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "O:9:\"Exception\":0:{}",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 7,
+              "event_type": "ActivityCompleted",
+              "timestamp": "2026-09-30T08:00:05.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9002,
+                  "legacy_index": 1
+                },
+                "activity": {
+                  "class": "App\\Activities\\ChargeCard",
+                  "logical_time": "2026-09-30T08:00:04.500000Z",
+                  "result": {
+                    "available": false,
+                    "encoding": "php-serialize",
+                    "value": null,
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 8,
+              "event_type": "WorkflowCompleted",
+              "timestamp": "2026-09-30T08:00:00.000000Z",
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_status": "completed",
+                  "execution_owner": "v1"
+                },
+                "legacy_payloads": {
+                  "output": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "s:9:\"fulfilled\";",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            }
+          ],
+          "next_page_token": null,
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.0.68",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4401",
+                "legacy_workflow_id": "4401"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{offsets.workflow}",
+                "run_id": "{offsets.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": null,
+              "name": "legacy-orders",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.output",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.signal_arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.exception_values",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{offsets.dedupe}"
+            }
+          },
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "history",
+            "workflow_id": "{offsets.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id",
+                "run_id"
+              ],
+              "success_fields": [
+                "next_page_token"
+              ],
+              "rejection_fields": [
+                "workflow_id",
+                "run_id",
+                "reason",
+                "message",
+                "retryable",
+                "error_id",
+                "exception"
+              ],
+              "rejection_reasons": [
+                "control_plane_internal_error"
+              ]
+            },
+            "run_id": "{offsets.run}",
+            "compatibility": null,
+            "next_page_token": null
+          }
+        }
+      },
+      "read_offsets_export": {
+        "status": 200,
+        "response": {
+          "schema": "durable-workflow.v2.history-export",
+          "schema_version": 2,
+          "exported_at": "{exported_at}",
+          "dedupe_key": "{offsets.run}:8:2026-09-30T10:00:00.000000Z",
+          "history_complete": true,
+          "workflow": {
+            "instance_id": "{offsets.workflow}",
+            "run_id": "{offsets.run}",
+            "run_number": 1,
+            "is_current_run": true,
+            "current_run_id": "{offsets.run}",
+            "current_run_source": "run_order_fallback",
+            "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+            "workflow_class": "App\\Workflows\\Legacy\\OrderFulfillment",
+            "source_runtime": "standalone_server",
+            "source_process_class": "server_http_node",
+            "business_key": null,
+            "visibility_labels": [],
+            "memo": [],
+            "memo_payload": {
+              "codec": "avro",
+              "blob": "wwHioz3/VYAiNw4A"
+            },
+            "search_attributes": [],
+            "status": "completed",
+            "status_bucket": "completed",
+            "closed_reason": "completed",
+            "archived_at": null,
+            "archive_command_id": null,
+            "archive_reason": null,
+            "compatibility": null,
+            "connection": null,
+            "queue": "legacy-orders",
+            "last_history_sequence": 8,
+            "started_at": "2026-09-30T10:00:00.000000Z",
+            "closed_at": "2026-09-30T10:00:00.000000Z",
+            "last_progress_at": "2026-09-30T10:00:00.000000Z"
+          },
+          "payloads": {
+            "codec": "avro",
+            "arguments": {
+              "available": false,
+              "data": null
+            },
+            "output": {
+              "available": false,
+              "codec": null,
+              "data": null
+            }
+          },
+          "summary": {
+            "status": "completed",
+            "status_bucket": "completed",
+            "closed_reason": "completed",
+            "archived_at": null,
+            "archive_command_id": null,
+            "archive_reason": null,
+            "business_key": null,
+            "visibility_labels": [],
+            "search_attributes": [],
+            "is_current_run": true,
+            "started_at": "2026-09-30T10:00:00.000000Z",
+            "closed_at": "2026-09-30T10:00:00.000000Z",
+            "duration_ms": null,
+            "wait_kind": null,
+            "wait_reason": null,
+            "wait_started_at": null,
+            "wait_deadline_at": null,
+            "open_wait_id": null,
+            "resume_source_kind": null,
+            "resume_source_id": null,
+            "next_task_at": null,
+            "next_task_id": null,
+            "next_task_type": null,
+            "next_task_status": null,
+            "next_task_lease_expires_at": null,
+            "liveness_state": null,
+            "liveness_reason": null,
+            "repair_attention": false,
+            "task_problem": false,
+            "task_problem_badge": null,
+            "exception_count": 1,
+            "history_event_count": 8,
+            "history_size_bytes": 6242,
+            "history_fan_out": 0,
+            "continue_as_new_recommended": false,
+            "history_budget_pressure": "ok",
+            "sort_timestamp": "2026-09-30T10:00:00.000000Z",
+            "sort_key": null
+          },
+          "history_events": [
+            {
+              "id": "{offsets.e1}",
+              "sequence": 1,
+              "type": "WorkflowStarted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:00.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "origin": {
+                    "engine_source": "v1",
+                    "engine_version": "1.0.68",
+                    "execution_engine": "finish-on-v1"
+                  },
+                  "identity": {
+                    "waterline": {
+                      "source_id": "{id}",
+                      "qualified_workflow_id": "v1:4401",
+                      "legacy_workflow_id": "4401"
+                    },
+                    "standalone": {
+                      "namespace": "{id}-wl1",
+                      "workflow_id": "{offsets.workflow}",
+                      "run_id": "{offsets.run}"
+                    },
+                    "relationship": "deterministic_source_qualified_projection",
+                    "collision_policy": "reject_without_overwrite"
+                  },
+                  "task_queue_context": {
+                    "connection": null,
+                    "name": "legacy-orders",
+                    "execution_owner": "v1",
+                    "standalone_dispatch": "disabled"
+                  },
+                  "unsupported_fields": [
+                    {
+                      "field": "runtime.replay",
+                      "reason": "v1_history_not_replayable_as_v2",
+                      "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                    },
+                    {
+                      "field": "timers",
+                      "reason": "legacy_timer_state_not_exposed_by_waterline",
+                      "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                    },
+                    {
+                      "field": "payloads.output",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.activity_results",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.signal_arguments",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    },
+                    {
+                      "field": "payloads.exception_values",
+                      "reason": "legacy_php_serialization_not_portable",
+                      "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                    }
+                  ]
+                },
+                "legacy_payloads": {
+                  "arguments": {
+                    "available": false,
+                    "encoding": "php-serialize",
+                    "value": null,
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{offsets.e2}",
+              "sequence": 2,
+              "type": "ActivityCompleted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9003,
+                  "legacy_index": null
+                },
+                "activity": {
+                  "class": "App\\Activities\\Untimed",
+                  "logical_time": null,
+                  "result": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": null,
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{offsets.e3}",
+              "sequence": 3,
+              "type": "SignalReceived",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": null,
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_signal",
+                  "legacy_id": 7002
+                },
+                "signal_name": "named",
+                "arguments": {
+                  "available": false,
+                  "encoding": "php-serialize",
+                  "value": null,
+                  "portable": false,
+                  "unsupported_reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                }
+              }
+            },
+            {
+              "id": "{offsets.e4}",
+              "sequence": 4,
+              "type": "SignalReceived",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:00.500000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_signal",
+                  "legacy_id": 7001
+                },
+                "signal_name": "approve-λ",
+                "arguments": {
+                  "available": true,
+                  "encoding": "php-serialize",
+                  "value": "a:1:{i:0;s:3:\"yes\";}",
+                  "portable": false,
+                  "unsupported_reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                }
+              }
+            },
+            {
+              "id": "{offsets.e5}",
+              "sequence": 5,
+              "type": "ActivityCompleted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:02.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9001,
+                  "legacy_index": 0
+                },
+                "activity": {
+                  "class": "App\\Activities\\ReserveStock",
+                  "logical_time": "2026-09-30T08:00:01.000000Z",
+                  "result": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "b:1;",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{offsets.e6}",
+              "sequence": 6,
+              "type": "ActivityFailed",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:04.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_exception",
+                  "legacy_id": 5001
+                },
+                "exception": {
+                  "class": "App\\Activities\\ChargeCard",
+                  "value": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "O:9:\"Exception\":0:{}",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{offsets.e7}",
+              "sequence": 7,
+              "type": "ActivityCompleted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:05.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_record": "workflow_log",
+                  "legacy_id": 9002,
+                  "legacy_index": 1
+                },
+                "activity": {
+                  "class": "App\\Activities\\ChargeCard",
+                  "logical_time": "2026-09-30T08:00:04.500000Z",
+                  "result": {
+                    "available": false,
+                    "encoding": "php-serialize",
+                    "value": null,
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{offsets.e8}",
+              "sequence": 8,
+              "type": "WorkflowCompleted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": "2026-09-30T08:00:00.000000Z",
+              "payload": {
+                "migration_projection": {
+                  "source_status": "completed",
+                  "execution_owner": "v1"
+                },
+                "legacy_payloads": {
+                  "output": {
+                    "available": true,
+                    "encoding": "php-serialize",
+                    "value": "s:9:\"fulfilled\";",
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            }
+          ],
+          "linked_intakes_scope": "selected_run",
+          "linked_intakes": [],
+          "commands": [],
+          "signals": [],
+          "updates": [],
+          "tasks": [],
+          "activities": [],
+          "timers": [],
+          "failures": [],
+          "links": {
+            "parents": [],
+            "children": []
+          },
+          "redaction": {
+            "applied": false,
+            "policy": null,
+            "paths": []
+          },
+          "codec_schemas": {
+            "avro": {
+              "encoding": "base64-avro-single-object",
+              "framing": "single_object",
+              "magic_hex": "c301",
+              "current_fingerprint": "e2a33dff55802237",
+              "writer_schemas": {
+                "e2a33dff55802237": {
+                  "schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+                  "fingerprint": "crc64-avro:e2a33dff55802237"
+                }
+              }
+            }
+          },
+          "payload_manifest": {
+            "version": 1,
+            "entries": [
+              {
+                "path": "workflow.memo_payload",
+                "codec": "avro",
+                "available": true,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": "single_object",
+                "avro_prefix_hex": "c301",
+                "writer_schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+                "writer_schema_fingerprint": "crc64-avro:e2a33dff55802237",
+                "diagnostic": null
+              },
+              {
+                "path": "payloads.arguments.data",
+                "codec": "avro",
+                "available": false,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": null,
+                "avro_prefix_hex": null,
+                "writer_schema": null,
+                "writer_schema_fingerprint": null,
+                "diagnostic": "payload_unavailable"
+              },
+              {
+                "path": "payloads.output.data",
+                "codec": "avro",
+                "available": false,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": null,
+                "avro_prefix_hex": null,
+                "writer_schema": null,
+                "writer_schema_fingerprint": null,
+                "diagnostic": "payload_unavailable"
+              },
+              {
+                "path": "history_events.7.payload.output",
+                "codec": "avro",
+                "available": false,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": null,
+                "avro_prefix_hex": null,
+                "writer_schema": null,
+                "writer_schema_fingerprint": null,
+                "diagnostic": "payload_unavailable"
+              }
+            ]
+          },
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.0.68",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4401",
+                "legacy_workflow_id": "4401"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{offsets.workflow}",
+                "run_id": "{offsets.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": null,
+              "name": "legacy-orders",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.output",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.signal_arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.exception_values",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{offsets.dedupe}"
+            }
+          },
+          "integrity": {
+            "canonicalization": "json-recursive-ksort-v1",
+            "checksum_algorithm": "sha256",
+            "checksum": "{offsets.export_checksum}",
+            "signature_algorithm": null,
+            "signature": null,
+            "key_id": null
+          },
+          "integrity_verified": true
+        }
+      },
+      "read_bare_describe": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{bare.workflow}",
+          "run_id": "{bare.run}",
+          "namespace": "{id}-wl1",
+          "workflow_type": "App\\Workflows\\Legacy\\Bare",
+          "business_key": null,
+          "status": "completed",
+          "status_bucket": "completed",
+          "is_terminal": true,
+          "closed_reason": "completed",
+          "task_queue": null,
+          "run_number": 1,
+          "run_count": 1,
+          "is_current_run": true,
+          "continued_from_run_id": null,
+          "resume_step_sequence": null,
+          "recovery_kind": null,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "payload_codec": null,
+          "definition_routing": null,
+          "execution_timeout_seconds": null,
+          "run_timeout_seconds": null,
+          "execution_deadline_at": null,
+          "run_deadline_at": null,
+          "input": null,
+          "output": null,
+          "input_envelope": null,
+          "output_envelope": null,
+          "payload_previews": {
+            "input_omitted": false,
+            "output_omitted": false,
+            "max_encoded_bytes": 2097152
+          },
+          "started_at": null,
+          "closed_at": null,
+          "last_progress_at": null,
+          "wait_kind": null,
+          "wait_reason": null,
+          "memo": [],
+          "search_attributes": [],
+          "actions": {
+            "can_signal": false,
+            "can_query": false,
+            "can_update": false,
+            "can_cancel": false,
+            "can_terminate": false,
+            "can_repair": false,
+            "can_archive": false
+          },
+          "commands_scope": "selected_run",
+          "commands": [],
+          "updates_scope": "selected_run",
+          "updates": [],
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.x",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4501",
+                "legacy_workflow_id": "4501"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{bare.workflow}",
+                "run_id": "{bare.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": null,
+              "name": null,
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{bare.dedupe}"
+            }
+          },
+          "action_blocked_reason": "v1_projection_read_only",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "describe",
+            "workflow_id": "{bare.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": []
+            },
+            "run_id": "{bare.run}",
+            "workflow_type": "App\\Workflows\\Legacy\\Bare",
+            "namespace": "{id}-wl1",
+            "business_key": null,
+            "status": "completed",
+            "status_bucket": "completed",
+            "is_terminal": true,
+            "task_queue": null,
+            "run_number": 1,
+            "run_count": 1,
+            "is_current_run": true,
+            "compatibility": null,
+            "started_at": null,
+            "closed_at": null,
+            "last_progress_at": null,
+            "wait_kind": null,
+            "wait_reason": null
+          }
+        }
+      },
+      "read_bare_run": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{bare.workflow}",
+          "run_id": "{bare.run}",
+          "namespace": "{id}-wl1",
+          "workflow_type": "App\\Workflows\\Legacy\\Bare",
+          "business_key": null,
+          "status": "completed",
+          "status_bucket": "completed",
+          "is_terminal": true,
+          "closed_reason": "completed",
+          "task_queue": null,
+          "run_number": 1,
+          "run_count": 1,
+          "is_current_run": true,
+          "continued_from_run_id": null,
+          "resume_step_sequence": null,
+          "recovery_kind": null,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "payload_codec": null,
+          "definition_routing": null,
+          "execution_timeout_seconds": null,
+          "run_timeout_seconds": null,
+          "execution_deadline_at": null,
+          "run_deadline_at": null,
+          "input": null,
+          "output": null,
+          "input_envelope": null,
+          "output_envelope": null,
+          "payload_previews": {
+            "input_omitted": false,
+            "output_omitted": false,
+            "max_encoded_bytes": 2097152
+          },
+          "started_at": null,
+          "closed_at": null,
+          "last_progress_at": null,
+          "wait_kind": null,
+          "wait_reason": null,
+          "memo": [],
+          "search_attributes": [],
+          "actions": {
+            "can_signal": false,
+            "can_query": false,
+            "can_update": false,
+            "can_cancel": false,
+            "can_terminate": false,
+            "can_repair": false,
+            "can_archive": false
+          },
+          "commands_scope": "selected_run",
+          "commands": [],
+          "updates_scope": "selected_run",
+          "updates": [],
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.x",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4501",
+                "legacy_workflow_id": "4501"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{bare.workflow}",
+                "run_id": "{bare.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": null,
+              "name": null,
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{bare.dedupe}"
+            }
+          },
+          "action_blocked_reason": "v1_projection_read_only",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "describe_run",
+            "workflow_id": "{bare.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": [
+                "run_id"
+              ],
+              "rejection_fields": [
+                "workflow_id",
+                "run_id",
+                "reason",
+                "message",
+                "retryable",
+                "error_id",
+                "exception"
+              ],
+              "rejection_reasons": [
+                "control_plane_internal_error"
+              ]
+            },
+            "run_id": "{bare.run}",
+            "workflow_type": "App\\Workflows\\Legacy\\Bare",
+            "namespace": "{id}-wl1",
+            "business_key": null,
+            "status": "completed",
+            "status_bucket": "completed",
+            "is_terminal": true,
+            "task_queue": null,
+            "run_number": 1,
+            "run_count": 1,
+            "is_current_run": true,
+            "compatibility": null,
+            "started_at": null,
+            "closed_at": null,
+            "last_progress_at": null,
+            "wait_kind": null,
+            "wait_reason": null
+          }
+        }
+      },
+      "read_bare_runs": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{bare.workflow}",
+          "run_count": 1,
+          "runs": [
+            {
+              "run_id": "{bare.run}",
+              "run_number": 1,
+              "workflow_type": "App\\Workflows\\Legacy\\Bare",
+              "business_key": null,
+              "status": "completed",
+              "status_bucket": "completed",
+              "is_terminal": true,
+              "is_current_run": true,
+              "task_queue": null,
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": null,
+              "closed_at": null
+            }
+          ],
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "list_runs",
+            "workflow_id": "{bare.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": []
+            },
+            "run_count": 1
+          }
+        }
+      },
+      "read_bare_history": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{bare.workflow}",
+          "run_id": "{bare.run}",
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "events": [
+            {
+              "sequence": 1,
+              "event_type": "WorkflowStarted",
+              "timestamp": null,
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "origin": {
+                    "engine_source": "v1",
+                    "engine_version": "1.x",
+                    "execution_engine": "finish-on-v1"
+                  },
+                  "identity": {
+                    "waterline": {
+                      "source_id": "{id}",
+                      "qualified_workflow_id": "v1:4501",
+                      "legacy_workflow_id": "4501"
+                    },
+                    "standalone": {
+                      "namespace": "{id}-wl1",
+                      "workflow_id": "{bare.workflow}",
+                      "run_id": "{bare.run}"
+                    },
+                    "relationship": "deterministic_source_qualified_projection",
+                    "collision_policy": "reject_without_overwrite"
+                  },
+                  "task_queue_context": {
+                    "connection": null,
+                    "name": null,
+                    "execution_owner": "v1",
+                    "standalone_dispatch": "disabled"
+                  },
+                  "unsupported_fields": [
+                    {
+                      "field": "runtime.replay",
+                      "reason": "v1_history_not_replayable_as_v2",
+                      "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                    },
+                    {
+                      "field": "timers",
+                      "reason": "legacy_timer_state_not_exposed_by_waterline",
+                      "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                    }
+                  ]
+                },
+                "legacy_payloads": {
+                  "arguments": {
+                    "available": false,
+                    "encoding": "php-serialize",
+                    "value": null,
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "sequence": 2,
+              "event_type": "WorkflowCompleted",
+              "timestamp": null,
+              "principal": null,
+              "payload": {
+                "migration_projection": {
+                  "source_status": "completed",
+                  "execution_owner": "v1"
+                },
+                "legacy_payloads": {
+                  "output": {
+                    "available": false,
+                    "encoding": "php-serialize",
+                    "value": null,
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            }
+          ],
+          "next_page_token": null,
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.x",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4501",
+                "legacy_workflow_id": "4501"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{bare.workflow}",
+                "run_id": "{bare.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": null,
+              "name": null,
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{bare.dedupe}"
+            }
+          },
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "history",
+            "workflow_id": "{bare.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id",
+                "run_id"
+              ],
+              "success_fields": [
+                "next_page_token"
+              ],
+              "rejection_fields": [
+                "workflow_id",
+                "run_id",
+                "reason",
+                "message",
+                "retryable",
+                "error_id",
+                "exception"
+              ],
+              "rejection_reasons": [
+                "control_plane_internal_error"
+              ]
+            },
+            "run_id": "{bare.run}",
+            "compatibility": null,
+            "next_page_token": null
+          }
+        }
+      },
+      "read_bare_export": {
+        "status": 200,
+        "response": {
+          "schema": "durable-workflow.v2.history-export",
+          "schema_version": 2,
+          "exported_at": "{exported_at}",
+          "dedupe_key": "{bare.run}:2:{bare.imported_at}",
+          "history_complete": true,
+          "workflow": {
+            "instance_id": "{bare.workflow}",
+            "run_id": "{bare.run}",
+            "run_number": 1,
+            "is_current_run": true,
+            "current_run_id": "{bare.run}",
+            "current_run_source": "run_order_fallback",
+            "workflow_type": "App\\Workflows\\Legacy\\Bare",
+            "workflow_class": "App\\Workflows\\Legacy\\Bare",
+            "source_runtime": "standalone_server",
+            "source_process_class": "server_http_node",
+            "business_key": null,
+            "visibility_labels": [],
+            "memo": [],
+            "memo_payload": {
+              "codec": "avro",
+              "blob": "wwHioz3/VYAiNw4A"
+            },
+            "search_attributes": [],
+            "status": "completed",
+            "status_bucket": "completed",
+            "closed_reason": "completed",
+            "archived_at": null,
+            "archive_command_id": null,
+            "archive_reason": null,
+            "compatibility": null,
+            "connection": null,
+            "queue": null,
+            "last_history_sequence": 2,
+            "started_at": null,
+            "closed_at": null,
+            "last_progress_at": null
+          },
+          "payloads": {
+            "codec": "avro",
+            "arguments": {
+              "available": false,
+              "data": null
+            },
+            "output": {
+              "available": false,
+              "codec": null,
+              "data": null
+            }
+          },
+          "summary": {
+            "status": "completed",
+            "status_bucket": "completed",
+            "closed_reason": "completed",
+            "archived_at": null,
+            "archive_command_id": null,
+            "archive_reason": null,
+            "business_key": null,
+            "visibility_labels": [],
+            "search_attributes": [],
+            "is_current_run": true,
+            "started_at": null,
+            "closed_at": null,
+            "duration_ms": null,
+            "wait_kind": null,
+            "wait_reason": null,
+            "wait_started_at": null,
+            "wait_deadline_at": null,
+            "open_wait_id": null,
+            "resume_source_kind": null,
+            "resume_source_id": null,
+            "next_task_at": null,
+            "next_task_id": null,
+            "next_task_type": null,
+            "next_task_status": null,
+            "next_task_lease_expires_at": null,
+            "liveness_state": null,
+            "liveness_reason": null,
+            "repair_attention": false,
+            "task_problem": false,
+            "task_problem_badge": null,
+            "exception_count": 0,
+            "history_event_count": 2,
+            "history_size_bytes": 1856,
+            "history_fan_out": 0,
+            "continue_as_new_recommended": false,
+            "history_budget_pressure": "ok",
+            "sort_timestamp": "{bare.imported_at}",
+            "sort_key": null
+          },
+          "history_events": [
+            {
+              "id": "{bare.e1}",
+              "sequence": 1,
+              "type": "WorkflowStarted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": null,
+              "payload": {
+                "migration_projection": {
+                  "origin": {
+                    "engine_source": "v1",
+                    "engine_version": "1.x",
+                    "execution_engine": "finish-on-v1"
+                  },
+                  "identity": {
+                    "waterline": {
+                      "source_id": "{id}",
+                      "qualified_workflow_id": "v1:4501",
+                      "legacy_workflow_id": "4501"
+                    },
+                    "standalone": {
+                      "namespace": "{id}-wl1",
+                      "workflow_id": "{bare.workflow}",
+                      "run_id": "{bare.run}"
+                    },
+                    "relationship": "deterministic_source_qualified_projection",
+                    "collision_policy": "reject_without_overwrite"
+                  },
+                  "task_queue_context": {
+                    "connection": null,
+                    "name": null,
+                    "execution_owner": "v1",
+                    "standalone_dispatch": "disabled"
+                  },
+                  "unsupported_fields": [
+                    {
+                      "field": "runtime.replay",
+                      "reason": "v1_history_not_replayable_as_v2",
+                      "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                    },
+                    {
+                      "field": "timers",
+                      "reason": "legacy_timer_state_not_exposed_by_waterline",
+                      "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                    }
+                  ]
+                },
+                "legacy_payloads": {
+                  "arguments": {
+                    "available": false,
+                    "encoding": "php-serialize",
+                    "value": null,
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            },
+            {
+              "id": "{bare.e2}",
+              "sequence": 2,
+              "type": "WorkflowCompleted",
+              "workflow_task_id": null,
+              "workflow_command_id": null,
+              "recorded_at": null,
+              "payload": {
+                "migration_projection": {
+                  "source_status": "completed",
+                  "execution_owner": "v1"
+                },
+                "legacy_payloads": {
+                  "output": {
+                    "available": false,
+                    "encoding": "php-serialize",
+                    "value": null,
+                    "portable": false,
+                    "unsupported_reason": "legacy_php_serialization_not_portable",
+                    "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                  }
+                }
+              }
+            }
+          ],
+          "linked_intakes_scope": "selected_run",
+          "linked_intakes": [],
+          "commands": [],
+          "signals": [],
+          "updates": [],
+          "tasks": [],
+          "activities": [],
+          "timers": [],
+          "failures": [],
+          "links": {
+            "parents": [],
+            "children": []
+          },
+          "redaction": {
+            "applied": false,
+            "policy": null,
+            "paths": []
+          },
+          "codec_schemas": {
+            "avro": {
+              "encoding": "base64-avro-single-object",
+              "framing": "single_object",
+              "magic_hex": "c301",
+              "current_fingerprint": "e2a33dff55802237",
+              "writer_schemas": {
+                "e2a33dff55802237": {
+                  "schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+                  "fingerprint": "crc64-avro:e2a33dff55802237"
+                }
+              }
+            }
+          },
+          "payload_manifest": {
+            "version": 1,
+            "entries": [
+              {
+                "path": "workflow.memo_payload",
+                "codec": "avro",
+                "available": true,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": "single_object",
+                "avro_prefix_hex": "c301",
+                "writer_schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+                "writer_schema_fingerprint": "crc64-avro:e2a33dff55802237",
+                "diagnostic": null
+              },
+              {
+                "path": "payloads.arguments.data",
+                "codec": "avro",
+                "available": false,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": null,
+                "avro_prefix_hex": null,
+                "writer_schema": null,
+                "writer_schema_fingerprint": null,
+                "diagnostic": "payload_unavailable"
+              },
+              {
+                "path": "payloads.output.data",
+                "codec": "avro",
+                "available": false,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": null,
+                "avro_prefix_hex": null,
+                "writer_schema": null,
+                "writer_schema_fingerprint": null,
+                "diagnostic": "payload_unavailable"
+              },
+              {
+                "path": "history_events.1.payload.output",
+                "codec": "avro",
+                "available": false,
+                "redacted": false,
+                "encoding": "base64-avro-single-object",
+                "avro_framing": null,
+                "avro_prefix_hex": null,
+                "writer_schema": null,
+                "writer_schema_fingerprint": null,
+                "diagnostic": "payload_unavailable"
+              }
+            ]
+          },
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.x",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4501",
+                "legacy_workflow_id": "4501"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{bare.workflow}",
+                "run_id": "{bare.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": null,
+              "name": null,
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{bare.dedupe}"
+            }
+          },
+          "integrity": {
+            "canonicalization": "json-recursive-ksort-v1",
+            "checksum_algorithm": "sha256",
+            "checksum": "{bare.export_checksum}",
+            "signature_algorithm": null,
+            "signature": null,
+            "key_id": null
+          },
+          "integrity_verified": true
+        }
+      },
+      "read_list": {
+        "status": 200,
+        "response": {
+          "workflows": [
+            {
+              "workflow_id": "{bare.workflow}",
+              "run_id": "{bare.run}",
+              "workflow_type": "App\\Workflows\\Legacy\\Bare",
+              "business_key": null,
+              "status": "completed",
+              "status_bucket": "completed",
+              "task_queue": null,
+              "is_terminal": true,
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": null,
+              "closed_at": null,
+              "search_attributes": []
+            },
+            {
+              "workflow_id": "{offsets.workflow}",
+              "run_id": "{offsets.run}",
+              "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+              "business_key": null,
+              "status": "completed",
+              "status_bucket": "completed",
+              "task_queue": "legacy-orders",
+              "is_terminal": true,
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": "2026-09-30T10:00:00.000000Z",
+              "closed_at": "2026-09-30T10:00:00.000000Z",
+              "search_attributes": []
+            },
+            {
+              "workflow_id": "{running.workflow}",
+              "run_id": "{running.run}",
+              "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+              "business_key": null,
+              "status": "running",
+              "status_bucket": "running",
+              "task_queue": "legacy-billing",
+              "is_terminal": false,
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": "2026-09-30T09:00:00.000000Z",
+              "closed_at": null,
+              "search_attributes": []
+            },
+            {
+              "workflow_id": "{completed.workflow}",
+              "run_id": "{completed.run}",
+              "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+              "business_key": null,
+              "status": "completed",
+              "status_bucket": "completed",
+              "task_queue": "legacy-orders",
+              "is_terminal": true,
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": "2026-09-30T08:00:00.000000Z",
+              "closed_at": "2026-09-30T08:00:06.000000Z",
+              "search_attributes": []
+            },
+            {
+              "workflow_id": "{status-continued.workflow}",
+              "run_id": "{status-continued.run}",
+              "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+              "business_key": null,
+              "status": "completed",
+              "status_bucket": "completed",
+              "task_queue": "legacy-orders",
+              "is_terminal": true,
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": "2026-09-30T07:06:00.000000Z",
+              "closed_at": "2026-09-30T07:06:30.000000Z",
+              "search_attributes": []
+            },
+            {
+              "workflow_id": "{status-terminated.workflow}",
+              "run_id": "{status-terminated.run}",
+              "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+              "business_key": null,
+              "status": "terminated",
+              "status_bucket": "failed",
+              "task_queue": "legacy-orders",
+              "is_terminal": true,
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": "2026-09-30T07:05:00.000000Z",
+              "closed_at": "2026-09-30T07:05:30.000000Z",
+              "search_attributes": []
+            },
+            {
+              "workflow_id": "{status-cancelled.workflow}",
+              "run_id": "{status-cancelled.run}",
+              "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+              "business_key": null,
+              "status": "cancelled",
+              "status_bucket": "failed",
+              "task_queue": "legacy-orders",
+              "is_terminal": true,
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": "2026-09-30T07:04:00.000000Z",
+              "closed_at": "2026-09-30T07:04:30.000000Z",
+              "search_attributes": []
+            },
+            {
+              "workflow_id": "{status-failed.workflow}",
+              "run_id": "{status-failed.run}",
+              "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+              "business_key": null,
+              "status": "failed",
+              "status_bucket": "failed",
+              "task_queue": "legacy-orders",
+              "is_terminal": true,
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": "2026-09-30T07:03:00.000000Z",
+              "closed_at": "2026-09-30T07:03:30.000000Z",
+              "search_attributes": []
+            },
+            {
+              "workflow_id": "{status-waiting.workflow}",
+              "run_id": "{status-waiting.run}",
+              "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+              "business_key": null,
+              "status": "waiting",
+              "status_bucket": "running",
+              "task_queue": "legacy-orders",
+              "is_terminal": false,
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": "2026-09-30T07:02:00.000000Z",
+              "closed_at": null,
+              "search_attributes": []
+            },
+            {
+              "workflow_id": "{status-pending.workflow}",
+              "run_id": "{status-pending.run}",
+              "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+              "business_key": null,
+              "status": "pending",
+              "status_bucket": "running",
+              "task_queue": "legacy-orders",
+              "is_terminal": false,
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": "2026-09-30T07:01:00.000000Z",
+              "closed_at": null,
+              "search_attributes": []
+            },
+            {
+              "workflow_id": "{status-created.workflow}",
+              "run_id": "{status-created.run}",
+              "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+              "business_key": null,
+              "status": "pending",
+              "status_bucket": "running",
+              "task_queue": "legacy-orders",
+              "is_terminal": false,
+              "compatibility": null,
+              "compatibility_status": "compatible",
+              "compatibility_supported_in_fleet": true,
+              "compatibility_fleet_reason": null,
+              "started_at": "2026-09-30T07:00:00.000000Z",
+              "closed_at": null,
+              "search_attributes": []
+            }
+          ],
+          "workflow_count": 11,
+          "next_page_token": null,
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "list",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": []
+            },
+            "workflow_count": 11,
+            "next_page_token": null
+          }
+        }
+      },
+      "read_list_alt": {
+        "status": 200,
+        "response": {
+          "workflows": [],
+          "workflow_count": 0,
+          "next_page_token": null,
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "list",
+            "workflow_id": null,
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [],
+              "success_fields": []
+            },
+            "workflow_count": 0,
+            "next_page_token": null
+          }
+        }
+      },
+      "refuse_running": {
+        "signal": {
+          "status": 409,
+          "response": {
+            "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}",
+            "operation": "signal",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "signal",
+              "workflow_id": "{running.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id",
+                  "operation_name",
+                  "operation_name_field"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "signal_name",
+                  "command_status",
+                  "command_source",
+                  "target_scope",
+                  "outcome",
+                  "reason",
+                  "rejection_reason",
+                  "rejection_category",
+                  "message",
+                  "command_contract_source",
+                  "command_contract_backfill_needed",
+                  "command_contract_backfill_available",
+                  "declared_signals",
+                  "signal_admission",
+                  "retryable",
+                  "error_id"
+                ],
+                "rejection_reasons": [
+                  "instance_not_found",
+                  "historical_run_command_rejected",
+                  "unknown_signal",
+                  "invalid_signal_arguments",
+                  "run_not_active",
+                  "instance_not_started",
+                  "selected_run_not_current",
+                  "configured_workflow_type_invalid",
+                  "v1_projection_read_only",
+                  "backend_lock_pressure",
+                  "control_plane_internal_error"
+                ]
+              },
+              "operation_name": "approve",
+              "operation_name_field": "signal_name",
+              "run_id": "{running.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "run_signal": {
+          "status": 409,
+          "response": {
+            "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}",
+            "operation": "signal",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "signal",
+              "workflow_id": "{running.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id",
+                  "operation_name",
+                  "operation_name_field"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "signal_name",
+                  "command_status",
+                  "command_source",
+                  "target_scope",
+                  "outcome",
+                  "reason",
+                  "rejection_reason",
+                  "rejection_category",
+                  "message",
+                  "command_contract_source",
+                  "command_contract_backfill_needed",
+                  "command_contract_backfill_available",
+                  "declared_signals",
+                  "signal_admission",
+                  "retryable",
+                  "error_id"
+                ],
+                "rejection_reasons": [
+                  "instance_not_found",
+                  "historical_run_command_rejected",
+                  "unknown_signal",
+                  "invalid_signal_arguments",
+                  "run_not_active",
+                  "instance_not_started",
+                  "selected_run_not_current",
+                  "configured_workflow_type_invalid",
+                  "v1_projection_read_only",
+                  "backend_lock_pressure",
+                  "control_plane_internal_error"
+                ]
+              },
+              "operation_name": "approve",
+              "operation_name_field": "signal_name",
+              "run_id": "{running.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "query": {
+          "status": 409,
+          "response": {
+            "message": "Operation [query] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}",
+            "operation": "query",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "query",
+              "workflow_id": "{running.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id",
+                  "operation_name",
+                  "operation_name_field"
+                ],
+                "success_fields": [
+                  "result",
+                  "result_envelope"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "query_name",
+                  "target_scope",
+                  "result",
+                  "reason",
+                  "message",
+                  "run_status",
+                  "is_terminal",
+                  "blocked_reason",
+                  "validation_errors"
+                ],
+                "rejection_reasons": [
+                  "instance_not_found",
+                  "historical_run_command_rejected",
+                  "run_not_active",
+                  "query_not_found",
+                  "rejected_unknown_query",
+                  "invalid_query_arguments",
+                  "workflow_definition_unavailable",
+                  "query_rejected",
+                  "query_worker_unavailable",
+                  "query_worker_incompatible",
+                  "query_task_queue_full",
+                  "query_task_queue_unavailable",
+                  "query_task_not_claimed",
+                  "query_worker_execution_timeout",
+                  "query_worker_timeout",
+                  "v1_projection_read_only"
+                ]
+              },
+              "operation_name": "status",
+              "operation_name_field": "query_name",
+              "run_id": "{running.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [query] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "update": {
+          "status": 409,
+          "response": {
+            "message": "Operation [update] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}",
+            "operation": "update",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "update",
+              "workflow_id": "{running.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id",
+                  "operation_name",
+                  "operation_name_field"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "update_id",
+                  "update_name",
+                  "update_status",
+                  "outcome",
+                  "reason",
+                  "rejection_reason",
+                  "validation_errors",
+                  "retryable",
+                  "message",
+                  "remediation"
+                ],
+                "rejection_reasons": [
+                  "update_validator_rejected",
+                  "update_validator_contract_missing",
+                  "update_validation_request_id_required",
+                  "update_validation_idempotency_conflict",
+                  "update_validation_capability_unsupported",
+                  "update_validator_worker_unavailable",
+                  "update_validator_worker_incompatible",
+                  "update_validator_worker_lost",
+                  "update_validation_task_not_claimed",
+                  "update_validation_execution_timeout",
+                  "duplicate_update_validation_completion",
+                  "stale_update_validation_completion",
+                  "invalid_update_arguments",
+                  "v1_projection_read_only"
+                ]
+              },
+              "operation_name": "rename",
+              "operation_name_field": "update_name",
+              "run_id": "{running.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [update] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "cancel": {
+          "status": 409,
+          "response": {
+            "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}",
+            "operation": "cancel",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "cancel",
+              "workflow_id": "{running.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "reason",
+                  "message",
+                  "remediation"
+                ],
+                "rejection_reasons": [
+                  "v1_projection_read_only"
+                ]
+              },
+              "run_id": "{running.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "run_cancel": {
+          "status": 409,
+          "response": {
+            "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}",
+            "operation": "cancel",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "cancel",
+              "workflow_id": "{running.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "reason",
+                  "message",
+                  "remediation"
+                ],
+                "rejection_reasons": [
+                  "v1_projection_read_only"
+                ]
+              },
+              "run_id": "{running.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "terminate": {
+          "status": 409,
+          "response": {
+            "message": "Operation [terminate] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}",
+            "operation": "terminate",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "terminate",
+              "workflow_id": "{running.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "reason",
+                  "message",
+                  "remediation"
+                ],
+                "rejection_reasons": [
+                  "v1_projection_read_only"
+                ]
+              },
+              "run_id": "{running.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [terminate] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "repair": {
+          "status": 409,
+          "response": {
+            "message": "Operation [repair] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}",
+            "operation": "repair",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "repair",
+              "workflow_id": "{running.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "reason",
+                  "message",
+                  "remediation"
+                ],
+                "rejection_reasons": [
+                  "v1_projection_read_only"
+                ]
+              },
+              "run_id": "{running.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [repair] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "archive": {
+          "status": 409,
+          "response": {
+            "message": "Operation [archive] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}",
+            "operation": "archive",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "archive",
+              "workflow_id": "{running.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "reason",
+                  "message",
+                  "remediation"
+                ],
+                "rejection_reasons": [
+                  "v1_projection_read_only"
+                ]
+              },
+              "run_id": "{running.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [archive] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "redrive": {
+          "status": 409,
+          "response": {
+            "message": "Operation [redrive] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}",
+            "operation": "redrive",
+            "execution_owner": "v1"
+          }
+        },
+        "request_cancellation": {
+          "status": 409,
+          "response": {
+            "reason": "legacy_v1_operation_not_supported",
+            "message": "Imported legacy workflows do not support cooperative cancellation."
+          }
+        }
+      },
+      "refuse_completed": {
+        "signal": {
+          "status": 409,
+          "response": {
+            "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}",
+            "operation": "signal",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "signal",
+              "workflow_id": "{completed.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id",
+                  "operation_name",
+                  "operation_name_field"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "signal_name",
+                  "command_status",
+                  "command_source",
+                  "target_scope",
+                  "outcome",
+                  "reason",
+                  "rejection_reason",
+                  "rejection_category",
+                  "message",
+                  "command_contract_source",
+                  "command_contract_backfill_needed",
+                  "command_contract_backfill_available",
+                  "declared_signals",
+                  "signal_admission",
+                  "retryable",
+                  "error_id"
+                ],
+                "rejection_reasons": [
+                  "instance_not_found",
+                  "historical_run_command_rejected",
+                  "unknown_signal",
+                  "invalid_signal_arguments",
+                  "run_not_active",
+                  "instance_not_started",
+                  "selected_run_not_current",
+                  "configured_workflow_type_invalid",
+                  "v1_projection_read_only",
+                  "backend_lock_pressure",
+                  "control_plane_internal_error"
+                ]
+              },
+              "operation_name": "approve",
+              "operation_name_field": "signal_name",
+              "run_id": "{completed.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "run_signal": {
+          "status": 409,
+          "response": {
+            "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}",
+            "operation": "signal",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "signal",
+              "workflow_id": "{completed.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id",
+                  "operation_name",
+                  "operation_name_field"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "signal_name",
+                  "command_status",
+                  "command_source",
+                  "target_scope",
+                  "outcome",
+                  "reason",
+                  "rejection_reason",
+                  "rejection_category",
+                  "message",
+                  "command_contract_source",
+                  "command_contract_backfill_needed",
+                  "command_contract_backfill_available",
+                  "declared_signals",
+                  "signal_admission",
+                  "retryable",
+                  "error_id"
+                ],
+                "rejection_reasons": [
+                  "instance_not_found",
+                  "historical_run_command_rejected",
+                  "unknown_signal",
+                  "invalid_signal_arguments",
+                  "run_not_active",
+                  "instance_not_started",
+                  "selected_run_not_current",
+                  "configured_workflow_type_invalid",
+                  "v1_projection_read_only",
+                  "backend_lock_pressure",
+                  "control_plane_internal_error"
+                ]
+              },
+              "operation_name": "approve",
+              "operation_name_field": "signal_name",
+              "run_id": "{completed.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "query": {
+          "status": 409,
+          "response": {
+            "message": "Operation [query] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}",
+            "operation": "query",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "query",
+              "workflow_id": "{completed.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id",
+                  "operation_name",
+                  "operation_name_field"
+                ],
+                "success_fields": [
+                  "result",
+                  "result_envelope"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "query_name",
+                  "target_scope",
+                  "result",
+                  "reason",
+                  "message",
+                  "run_status",
+                  "is_terminal",
+                  "blocked_reason",
+                  "validation_errors"
+                ],
+                "rejection_reasons": [
+                  "instance_not_found",
+                  "historical_run_command_rejected",
+                  "run_not_active",
+                  "query_not_found",
+                  "rejected_unknown_query",
+                  "invalid_query_arguments",
+                  "workflow_definition_unavailable",
+                  "query_rejected",
+                  "query_worker_unavailable",
+                  "query_worker_incompatible",
+                  "query_task_queue_full",
+                  "query_task_queue_unavailable",
+                  "query_task_not_claimed",
+                  "query_worker_execution_timeout",
+                  "query_worker_timeout",
+                  "v1_projection_read_only"
+                ]
+              },
+              "operation_name": "status",
+              "operation_name_field": "query_name",
+              "run_id": "{completed.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [query] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "update": {
+          "status": 409,
+          "response": {
+            "message": "Operation [update] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}",
+            "operation": "update",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "update",
+              "workflow_id": "{completed.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id",
+                  "operation_name",
+                  "operation_name_field"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "update_id",
+                  "update_name",
+                  "update_status",
+                  "outcome",
+                  "reason",
+                  "rejection_reason",
+                  "validation_errors",
+                  "retryable",
+                  "message",
+                  "remediation"
+                ],
+                "rejection_reasons": [
+                  "update_validator_rejected",
+                  "update_validator_contract_missing",
+                  "update_validation_request_id_required",
+                  "update_validation_idempotency_conflict",
+                  "update_validation_capability_unsupported",
+                  "update_validator_worker_unavailable",
+                  "update_validator_worker_incompatible",
+                  "update_validator_worker_lost",
+                  "update_validation_task_not_claimed",
+                  "update_validation_execution_timeout",
+                  "duplicate_update_validation_completion",
+                  "stale_update_validation_completion",
+                  "invalid_update_arguments",
+                  "v1_projection_read_only"
+                ]
+              },
+              "operation_name": "rename",
+              "operation_name_field": "update_name",
+              "run_id": "{completed.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [update] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "cancel": {
+          "status": 409,
+          "response": {
+            "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}",
+            "operation": "cancel",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "cancel",
+              "workflow_id": "{completed.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "reason",
+                  "message",
+                  "remediation"
+                ],
+                "rejection_reasons": [
+                  "v1_projection_read_only"
+                ]
+              },
+              "run_id": "{completed.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "run_cancel": {
+          "status": 409,
+          "response": {
+            "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}",
+            "operation": "cancel",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "cancel",
+              "workflow_id": "{completed.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "reason",
+                  "message",
+                  "remediation"
+                ],
+                "rejection_reasons": [
+                  "v1_projection_read_only"
+                ]
+              },
+              "run_id": "{completed.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "terminate": {
+          "status": 409,
+          "response": {
+            "message": "Operation [terminate] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}",
+            "operation": "terminate",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "terminate",
+              "workflow_id": "{completed.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "reason",
+                  "message",
+                  "remediation"
+                ],
+                "rejection_reasons": [
+                  "v1_projection_read_only"
+                ]
+              },
+              "run_id": "{completed.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [terminate] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "repair": {
+          "status": 409,
+          "response": {
+            "message": "Operation [repair] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}",
+            "operation": "repair",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "repair",
+              "workflow_id": "{completed.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "reason",
+                  "message",
+                  "remediation"
+                ],
+                "rejection_reasons": [
+                  "v1_projection_read_only"
+                ]
+              },
+              "run_id": "{completed.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [repair] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "archive": {
+          "status": 409,
+          "response": {
+            "message": "Operation [archive] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}",
+            "operation": "archive",
+            "execution_owner": "v1",
+            "control_plane": {
+              "schema": "durable-workflow.v2.control-plane-response",
+              "version": 1,
+              "operation": "archive",
+              "workflow_id": "{completed.workflow}",
+              "contract": {
+                "schema": "durable-workflow.v2.control-plane-response.contract",
+                "version": 1,
+                "legacy_field_policy": "reject_non_canonical",
+                "legacy_fields": {
+                  "query": "query_name",
+                  "signal": "signal_name",
+                  "update": "update_name",
+                  "wait_policy": "wait_for"
+                },
+                "required_fields": [
+                  "workflow_id"
+                ],
+                "success_fields": [
+                  "outcome"
+                ],
+                "rejection_fields": [
+                  "workflow_id",
+                  "run_id",
+                  "reason",
+                  "message",
+                  "remediation"
+                ],
+                "rejection_reasons": [
+                  "v1_projection_read_only"
+                ]
+              },
+              "run_id": "{completed.run}",
+              "reason": "v1_projection_read_only",
+              "message": "Operation [archive] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+              "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+              "execution_owner": "v1"
+            }
+          }
+        },
+        "redrive": {
+          "status": 409,
+          "response": {
+            "message": "Operation [redrive] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+            "reason": "v1_projection_read_only",
+            "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}",
+            "operation": "redrive",
+            "execution_owner": "v1"
+          }
+        },
+        "request_cancellation": {
+          "status": 409,
+          "response": {
+            "reason": "legacy_v1_operation_not_supported",
+            "message": "Imported legacy workflows do not support cooperative cancellation."
+          }
+        }
+      },
+      "refused_running_describe": {
+        "status": 200,
+        "response": {
+          "workflow_id": "{running.workflow}",
+          "run_id": "{running.run}",
+          "namespace": "{id}-wl1",
+          "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+          "business_key": null,
+          "status": "running",
+          "status_bucket": "running",
+          "is_terminal": false,
+          "closed_reason": null,
+          "task_queue": "legacy-billing",
+          "run_number": 1,
+          "run_count": 1,
+          "is_current_run": true,
+          "continued_from_run_id": null,
+          "resume_step_sequence": null,
+          "recovery_kind": null,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "payload_codec": null,
+          "definition_routing": null,
+          "execution_timeout_seconds": null,
+          "run_timeout_seconds": null,
+          "execution_deadline_at": null,
+          "run_deadline_at": null,
+          "input": null,
+          "output": null,
+          "input_envelope": null,
+          "output_envelope": null,
+          "payload_previews": {
+            "input_omitted": false,
+            "output_omitted": false,
+            "max_encoded_bytes": 2097152
+          },
+          "started_at": "2026-09-30T09:00:00.000000Z",
+          "closed_at": null,
+          "last_progress_at": "2026-09-30T09:00:00.000000Z",
+          "wait_kind": null,
+          "wait_reason": null,
+          "memo": [],
+          "search_attributes": [],
+          "actions": {
+            "can_signal": false,
+            "can_query": false,
+            "can_update": false,
+            "can_cancel": false,
+            "can_terminate": false,
+            "can_repair": false,
+            "can_archive": false
+          },
+          "commands_scope": "selected_run",
+          "commands": [],
+          "updates_scope": "selected_run",
+          "updates": [],
+          "migration_projection": {
+            "origin": {
+              "engine_source": "v1",
+              "engine_version": "1.x",
+              "execution_engine": "finish-on-v1"
+            },
+            "identity": {
+              "waterline": {
+                "source_id": "{id}",
+                "qualified_workflow_id": "v1:4201",
+                "legacy_workflow_id": "4201"
+              },
+              "standalone": {
+                "namespace": "{id}-wl1",
+                "workflow_id": "{running.workflow}",
+                "run_id": "{running.run}"
+              },
+              "relationship": "deterministic_source_qualified_projection",
+              "collision_policy": "reject_without_overwrite"
+            },
+            "task_queue_context": {
+              "connection": "database",
+              "name": "legacy-billing",
+              "execution_owner": "v1",
+              "standalone_dispatch": "disabled"
+            },
+            "unsupported_fields": [
+              {
+                "field": "runtime.replay",
+                "reason": "v1_history_not_replayable_as_v2",
+                "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+              },
+              {
+                "field": "timers",
+                "reason": "legacy_timer_state_not_exposed_by_waterline",
+                "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+              },
+              {
+                "field": "payloads.arguments",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "payloads.activity_results",
+                "reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              },
+              {
+                "field": "runtime.execution",
+                "reason": "finish_on_v1_execution_not_transferable",
+                "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+              }
+            ],
+            "projection": {
+              "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+              "version": 1,
+              "read_only": true,
+              "execution_owner": "v1",
+              "imported_at": "{imported_at}",
+              "dedupe_key": "{running.dedupe}"
+            }
+          },
+          "action_blocked_reason": "v1_projection_read_only",
+          "control_plane": {
+            "schema": "durable-workflow.v2.control-plane-response",
+            "version": 1,
+            "operation": "describe",
+            "workflow_id": "{running.workflow}",
+            "contract": {
+              "schema": "durable-workflow.v2.control-plane-response.contract",
+              "version": 1,
+              "legacy_field_policy": "reject_non_canonical",
+              "legacy_fields": {
+                "query": "query_name",
+                "signal": "signal_name",
+                "update": "update_name",
+                "wait_policy": "wait_for"
+              },
+              "required_fields": [
+                "workflow_id"
+              ],
+              "success_fields": []
+            },
+            "run_id": "{running.run}",
+            "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+            "namespace": "{id}-wl1",
+            "business_key": null,
+            "status": "running",
+            "status_bucket": "running",
+            "is_terminal": false,
+            "task_queue": "legacy-billing",
+            "run_number": 1,
+            "run_count": 1,
+            "is_current_run": true,
+            "compatibility": null,
+            "started_at": "2026-09-30T09:00:00.000000Z",
+            "closed_at": null,
+            "last_progress_at": "2026-09-30T09:00:00.000000Z",
+            "wait_kind": null,
+            "wait_reason": null
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/tests/Fixtures/ServerParityExpected/waterline-import-observation.json b/tests/Fixtures/ServerParityExpected/waterline-import-observation.json
new file mode 100644
index 000000000..d534a50d0
--- /dev/null
+++ b/tests/Fixtures/ServerParityExpected/waterline-import-observation.json
@@ -0,0 +1,10634 @@
+{
+  "applicable": true,
+  "namespace": "pr1-waterline-import-wl1",
+  "alternate_namespace": "pr1-waterline-import-wl1alt",
+  "native_namespace": "pr1-waterline-import-wl1native",
+  "source_id": "pr1-waterline-import",
+  "gate_unauthenticated": {
+    "status": 401,
+    "response": {
+      "reason": "unauthorized",
+      "message": "Invalid or missing authentication token.",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "reason": "unauthorized",
+        "message": "Invalid or missing authentication token."
+      }
+    }
+  },
+  "gate_missing_version": {
+    "status": 400,
+    "response": {
+      "message": "Missing control-plane version header.",
+      "reason": "missing_control_plane_version",
+      "supported_version": "2",
+      "requested_version": null,
+      "remediation": "Send the X-Durable-Workflow-Control-Plane-Version: 2 header on control-plane requests.",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "reason": "missing_control_plane_version",
+        "message": "Missing control-plane version header.",
+        "remediation": "Send the X-Durable-Workflow-Control-Plane-Version: 2 header on control-plane requests."
+      }
+    }
+  },
+  "gate_unsupported_version": {
+    "status": 400,
+    "response": {
+      "message": "Unsupported control-plane version.",
+      "reason": "unsupported_control_plane_version",
+      "supported_version": "2",
+      "requested_version": "3",
+      "remediation": "Client requested control-plane version 3; this server only supports 2. Upgrade the client to a release that targets control-plane 2, or connect to a server that supports 3.",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "reason": "unsupported_control_plane_version",
+        "message": "Unsupported control-plane version.",
+        "remediation": "Client requested control-plane version 3; this server only supports 2. Upgrade the client to a release that targets control-plane 2, or connect to a server that supports 3."
+      }
+    }
+  },
+  "gate_unknown_namespace": {
+    "status": 404,
+    "response": {
+      "message": "Namespace 'pr1-waterline-import-missing' does not exist.",
+      "reason": "namespace_not_found",
+      "namespace": "pr1-waterline-import-missing",
+      "remediation": "Register the namespace via POST /api/namespaces, or send an X-Namespace header naming an existing namespace.",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "namespace": "pr1-waterline-import-missing",
+        "reason": "namespace_not_found",
+        "message": "Namespace 'pr1-waterline-import-missing' does not exist.",
+        "remediation": "Register the namespace via POST /api/namespaces, or send an X-Namespace header naming an existing namespace."
+      }
+    }
+  },
+  "gate_text_plain": {
+    "status": 415,
+    "response": {
+      "message": "Request bodies must use a JSON media type.",
+      "reason": "unsupported_media_type",
+      "accepted_content_types": [
+        "application/json",
+        "application/*+json"
+      ],
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "reason": "unsupported_media_type",
+        "message": "Request bodies must use a JSON media type."
+      }
+    }
+  },
+  "gate_malformed_json": {
+    "status": 400,
+    "response": {
+      "message": "Request bodies must contain valid JSON.",
+      "reason": "malformed_json",
+      "json_error": "Syntax error",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "reason": "malformed_json",
+        "message": "Request bodies must contain valid JSON."
+      }
+    }
+  },
+  "validate_empty": {
+    "status": 422,
+    "response": {
+      "message": "The source id field is required. (and 1 more error)",
+      "reason": "validation_failed",
+      "errors": {
+        "source_id": [
+          "The source id field is required."
+        ],
+        "workflow": [
+          "The workflow field is required."
+        ]
+      },
+      "validation_errors": {
+        "source_id": [
+          "The source id field is required."
+        ],
+        "workflow": [
+          "The workflow field is required."
+        ]
+      },
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "reason": "validation_failed",
+        "validation_errors": {
+          "source_id": [
+            "The source id field is required."
+          ],
+          "workflow": [
+            "The workflow field is required."
+          ]
+        },
+        "message": "The source id field is required. (and 1 more error)"
+      }
+    }
+  },
+  "validate_source_id_blank": {
+    "status": 422,
+    "response": {
+      "message": "The source id field is required.",
+      "reason": "validation_failed",
+      "errors": {
+        "source_id": [
+          "The source id field is required."
+        ]
+      },
+      "validation_errors": {
+        "source_id": [
+          "The source id field is required."
+        ]
+      },
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "reason": "validation_failed",
+        "validation_errors": {
+          "source_id": [
+            "The source id field is required."
+          ]
+        },
+        "message": "The source id field is required."
+      }
+    }
+  },
+  "validate_source_id_number": {
+    "status": 422,
+    "response": {
+      "message": "The source id field must be a string.",
+      "reason": "validation_failed",
+      "errors": {
+        "source_id": [
+          "The source id field must be a string."
+        ]
+      },
+      "validation_errors": {
+        "source_id": [
+          "The source id field must be a string."
+        ]
+      },
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "reason": "validation_failed",
+        "validation_errors": {
+          "source_id": [
+            "The source id field must be a string."
+          ]
+        },
+        "message": "The source id field must be a string."
+      }
+    }
+  },
+  "validate_source_id_long": {
+    "status": 422,
+    "response": {
+      "message": "The source id field must not be greater than 64 characters.",
+      "reason": "validation_failed",
+      "errors": {
+        "source_id": [
+          "The source id field must not be greater than 64 characters."
+        ]
+      },
+      "validation_errors": {
+        "source_id": [
+          "The source id field must not be greater than 64 characters."
+        ]
+      },
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "reason": "validation_failed",
+        "validation_errors": {
+          "source_id": [
+            "The source id field must not be greater than 64 characters."
+          ]
+        },
+        "message": "The source id field must not be greater than 64 characters."
+      }
+    }
+  },
+  "validate_workflow_empty": {
+    "status": 422,
+    "response": {
+      "message": "The workflow field is required.",
+      "reason": "validation_failed",
+      "errors": {
+        "workflow": [
+          "The workflow field is required."
+        ]
+      },
+      "validation_errors": {
+        "workflow": [
+          "The workflow field is required."
+        ]
+      },
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "reason": "validation_failed",
+        "validation_errors": {
+          "workflow": [
+            "The workflow field is required."
+          ]
+        },
+        "message": "The workflow field is required."
+      }
+    }
+  },
+  "validate_workflow_string": {
+    "status": 422,
+    "response": {
+      "message": "The workflow field must be an array.",
+      "reason": "validation_failed",
+      "errors": {
+        "workflow": [
+          "The workflow field must be an array."
+        ]
+      },
+      "validation_errors": {
+        "workflow": [
+          "The workflow field must be an array."
+        ]
+      },
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "reason": "validation_failed",
+        "validation_errors": {
+          "workflow": [
+            "The workflow field must be an array."
+          ]
+        },
+        "message": "The workflow field must be an array."
+      }
+    }
+  },
+  "validate_dry_run": {
+    "status": 422,
+    "response": {
+      "message": "The dry run field must be true or false.",
+      "reason": "validation_failed",
+      "errors": {
+        "dry_run": [
+          "The dry run field must be true or false."
+        ]
+      },
+      "validation_errors": {
+        "dry_run": [
+          "The dry run field must be true or false."
+        ]
+      },
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "reason": "validation_failed",
+        "validation_errors": {
+          "dry_run": [
+            "The dry run field must be true or false."
+          ]
+        },
+        "message": "The dry run field must be true or false."
+      }
+    }
+  },
+  "reject_source_id": {
+    "status": 409,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "rejected",
+      "projection_only": true,
+      "identity": null,
+      "dedupe_key": null,
+      "unsupported_fields": [],
+      "errors": [
+        {
+          "reason": "invalid_source_id",
+          "message": "source_id must be 1-64 stable URL-safe characters.",
+          "remediation": "Use a deployment-stable identifier such as legacy-prod-us-east."
+        }
+      ],
+      "reason": "invalid_source_id",
+      "message": "source_id must be 1-64 stable URL-safe characters.",
+      "remediation": "Use a deployment-stable identifier such as legacy-prod-us-east.",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "rejected",
+        "reason": "invalid_source_id",
+        "message": "source_id must be 1-64 stable URL-safe characters.",
+        "remediation": "Use a deployment-stable identifier such as legacy-prod-us-east.",
+        "identity": null
+      }
+    }
+  },
+  "reject_unqualified": {
+    "status": 409,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "rejected",
+      "projection_only": true,
+      "identity": null,
+      "dedupe_key": null,
+      "unsupported_fields": [],
+      "errors": [
+        {
+          "reason": "unqualified_v1_identity",
+          "message": "The Waterline workflow must carry operator_id or id in v1:<workflow-id> form.",
+          "remediation": "Export the detail from the Waterline hybrid migration API."
+        }
+      ],
+      "reason": "unqualified_v1_identity",
+      "message": "The Waterline workflow must carry operator_id or id in v1:<workflow-id> form.",
+      "remediation": "Export the detail from the Waterline hybrid migration API.",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "rejected",
+        "reason": "unqualified_v1_identity",
+        "message": "The Waterline workflow must carry operator_id or id in v1:<workflow-id> form.",
+        "remediation": "Export the detail from the Waterline hybrid migration API.",
+        "identity": null
+      }
+    }
+  },
+  "reject_mismatch": {
+    "status": 409,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "rejected",
+      "projection_only": true,
+      "identity": null,
+      "dedupe_key": null,
+      "unsupported_fields": [],
+      "errors": [
+        {
+          "reason": "v1_identity_mismatch",
+          "message": "legacy_id does not match the qualified Waterline identity.",
+          "remediation": "Re-export the workflow detail without editing its identity fields."
+        }
+      ],
+      "reason": "v1_identity_mismatch",
+      "message": "legacy_id does not match the qualified Waterline identity.",
+      "remediation": "Re-export the workflow detail without editing its identity fields.",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "rejected",
+        "reason": "v1_identity_mismatch",
+        "message": "legacy_id does not match the qualified Waterline identity.",
+        "remediation": "Re-export the workflow detail without editing its identity fields.",
+        "identity": null
+      }
+    }
+  },
+  "reject_engine": {
+    "status": 409,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "rejected",
+      "projection_only": true,
+      "identity": null,
+      "dedupe_key": null,
+      "unsupported_fields": [],
+      "errors": [
+        {
+          "reason": "unsupported_source_engine",
+          "message": "Only Waterline engine_source=v1 projections are accepted.",
+          "remediation": "Use embedded-v2 import for v2-origin history bundles."
+        }
+      ],
+      "reason": "unsupported_source_engine",
+      "message": "Only Waterline engine_source=v1 projections are accepted.",
+      "remediation": "Use embedded-v2 import for v2-origin history bundles.",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "rejected",
+        "reason": "unsupported_source_engine",
+        "message": "Only Waterline engine_source=v1 projections are accepted.",
+        "remediation": "Use embedded-v2 import for v2-origin history bundles.",
+        "identity": null
+      }
+    }
+  },
+  "reject_class": {
+    "status": 409,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "rejected",
+      "projection_only": true,
+      "identity": null,
+      "dedupe_key": null,
+      "unsupported_fields": [],
+      "errors": [
+        {
+          "reason": "missing_v1_workflow_class",
+          "message": "The Waterline projection does not identify the workflow class.",
+          "remediation": "Export the complete v1 workflow detail response."
+        }
+      ],
+      "reason": "missing_v1_workflow_class",
+      "message": "The Waterline projection does not identify the workflow class.",
+      "remediation": "Export the complete v1 workflow detail response.",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "rejected",
+        "reason": "missing_v1_workflow_class",
+        "message": "The Waterline projection does not identify the workflow class.",
+        "remediation": "Export the complete v1 workflow detail response.",
+        "identity": null
+      }
+    }
+  },
+  "reject_status": {
+    "status": 409,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "rejected",
+      "projection_only": true,
+      "identity": null,
+      "dedupe_key": null,
+      "unsupported_fields": [],
+      "errors": [
+        {
+          "reason": "unsupported_v1_status",
+          "message": "The v1 workflow status cannot be represented by the standalone v2 visibility model.",
+          "remediation": "Complete or normalize the workflow on v1, then export it again."
+        }
+      ],
+      "reason": "unsupported_v1_status",
+      "message": "The v1 workflow status cannot be represented by the standalone v2 visibility model.",
+      "remediation": "Complete or normalize the workflow on v1, then export it again.",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "rejected",
+        "reason": "unsupported_v1_status",
+        "message": "The v1 workflow status cannot be represented by the standalone v2 visibility model.",
+        "remediation": "Complete or normalize the workflow on v1, then export it again.",
+        "identity": null
+      }
+    }
+  },
+  "reject_all": {
+    "status": 409,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "rejected",
+      "projection_only": true,
+      "identity": null,
+      "dedupe_key": null,
+      "unsupported_fields": [],
+      "errors": [
+        {
+          "reason": "invalid_source_id",
+          "message": "source_id must be 1-64 stable URL-safe characters.",
+          "remediation": "Use a deployment-stable identifier such as legacy-prod-us-east."
+        },
+        {
+          "reason": "unqualified_v1_identity",
+          "message": "The Waterline workflow must carry operator_id or id in v1:<workflow-id> form.",
+          "remediation": "Export the detail from the Waterline hybrid migration API."
+        },
+        {
+          "reason": "v1_identity_mismatch",
+          "message": "legacy_id does not match the qualified Waterline identity.",
+          "remediation": "Re-export the workflow detail without editing its identity fields."
+        },
+        {
+          "reason": "unsupported_source_engine",
+          "message": "Only Waterline engine_source=v1 projections are accepted.",
+          "remediation": "Use embedded-v2 import for v2-origin history bundles."
+        },
+        {
+          "reason": "missing_v1_workflow_class",
+          "message": "The Waterline projection does not identify the workflow class.",
+          "remediation": "Export the complete v1 workflow detail response."
+        },
+        {
+          "reason": "unsupported_v1_status",
+          "message": "The v1 workflow status cannot be represented by the standalone v2 visibility model.",
+          "remediation": "Complete or normalize the workflow on v1, then export it again."
+        }
+      ],
+      "reason": "invalid_source_id",
+      "message": "source_id must be 1-64 stable URL-safe characters.",
+      "remediation": "Use a deployment-stable identifier such as legacy-prod-us-east.",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "rejected",
+        "reason": "invalid_source_id",
+        "message": "source_id must be 1-64 stable URL-safe characters.",
+        "remediation": "Use a deployment-stable identifier such as legacy-prod-us-east.",
+        "identity": null
+      }
+    }
+  },
+  "operator_id_first": {
+    "status": 200,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "dry_run",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4101",
+          "legacy_workflow_id": "4101"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{completed.workflow}",
+          "run_id": "{completed.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{completed.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        }
+      ],
+      "errors": [],
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "dry_run",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4101",
+            "legacy_workflow_id": "4101"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "dry_run": {
+    "status": 200,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "dry_run",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4101",
+          "legacy_workflow_id": "4101"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{completed.workflow}",
+          "run_id": "{completed.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{completed.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        }
+      ],
+      "errors": [],
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "dry_run",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4101",
+            "legacy_workflow_id": "4101"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "dry_run_describe": {
+    "status": 404,
+    "response": {
+      "message": "Workflow not found.",
+      "reason": "instance_not_found",
+      "workflow_id": "{completed.workflow}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "describe",
+        "workflow_id": "{completed.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": []
+        },
+        "reason": "instance_not_found",
+        "message": "Workflow not found."
+      }
+    }
+  },
+  "project": {
+    "status": 201,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "projected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4101",
+          "legacy_workflow_id": "4101"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{completed.workflow}",
+          "run_id": "{completed.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{completed.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        }
+      ],
+      "errors": [],
+      "imported_at": "{imported_at}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "projected",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4101",
+            "legacy_workflow_id": "4101"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "repeat": {
+    "status": 200,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "already_projected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4101",
+          "legacy_workflow_id": "4101"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{completed.workflow}",
+          "run_id": "{completed.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{completed.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        }
+      ],
+      "errors": [],
+      "imported_at": "{imported_at}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "already_projected",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4101",
+            "legacy_workflow_id": "4101"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "repeat_dry_run": {
+    "status": 200,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "already_projected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4101",
+          "legacy_workflow_id": "4101"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{completed.workflow}",
+          "run_id": "{completed.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{completed.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        }
+      ],
+      "errors": [],
+      "imported_at": "{imported_at}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "already_projected",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4101",
+            "legacy_workflow_id": "4101"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "repeat_trimmed": {
+    "status": 200,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "already_projected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4101",
+          "legacy_workflow_id": "4101"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{completed.workflow}",
+          "run_id": "{completed.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{completed.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        }
+      ],
+      "errors": [],
+      "imported_at": "{imported_at}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "already_projected",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4101",
+            "legacy_workflow_id": "4101"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "changed": {
+    "status": 409,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "rejected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4101",
+          "legacy_workflow_id": "4101"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{completed.workflow}",
+          "run_id": "{completed.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{changed.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        }
+      ],
+      "errors": [],
+      "reason": "v1_projection_changed",
+      "message": "This v1 identity was already projected from different source state.",
+      "remediation": "Inspect the existing projection and resolve it before importing a different snapshot of the same v1 identity.",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "rejected",
+        "reason": "v1_projection_changed",
+        "message": "This v1 identity was already projected from different source state.",
+        "remediation": "Inspect the existing projection and resolve it before importing a different snapshot of the same v1 identity.",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4101",
+            "legacy_workflow_id": "4101"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "other_namespace": {
+    "status": 409,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "rejected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4101",
+          "legacy_workflow_id": "4101"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{completed.workflow}",
+          "run_id": "{completed.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{completed.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        }
+      ],
+      "errors": [],
+      "requested_namespace": "pr1-waterline-import-wl1alt",
+      "reason": "v1_projection_namespace_collision",
+      "message": "This v1 identity is already projected in a different standalone namespace.",
+      "remediation": "Repeat the operation in the existing pr1-waterline-import-wl1 namespace, or choose a different stable source_id for an independent projection.",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "rejected",
+        "reason": "v1_projection_namespace_collision",
+        "message": "This v1 identity is already projected in a different standalone namespace.",
+        "remediation": "Repeat the operation in the existing pr1-waterline-import-wl1 namespace, or choose a different stable source_id for an independent projection.",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4101",
+            "legacy_workflow_id": "4101"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "status_created": {
+    "status": 201,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "projected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4300",
+          "legacy_workflow_id": "4300"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{status-created.workflow}",
+          "run_id": "{status-created.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{status-created.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "runtime.execution",
+          "reason": "finish_on_v1_execution_not_transferable",
+          "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+        }
+      ],
+      "errors": [],
+      "imported_at": "{imported_at}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "projected",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4300",
+            "legacy_workflow_id": "4300"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{status-created.workflow}",
+            "run_id": "{status-created.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "status_pending": {
+    "status": 201,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "projected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4301",
+          "legacy_workflow_id": "4301"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{status-pending.workflow}",
+          "run_id": "{status-pending.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{status-pending.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "runtime.execution",
+          "reason": "finish_on_v1_execution_not_transferable",
+          "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+        }
+      ],
+      "errors": [],
+      "imported_at": "{imported_at}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "projected",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4301",
+            "legacy_workflow_id": "4301"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{status-pending.workflow}",
+            "run_id": "{status-pending.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "status_waiting": {
+    "status": 201,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "projected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4302",
+          "legacy_workflow_id": "4302"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{status-waiting.workflow}",
+          "run_id": "{status-waiting.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{status-waiting.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "runtime.execution",
+          "reason": "finish_on_v1_execution_not_transferable",
+          "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+        }
+      ],
+      "errors": [],
+      "imported_at": "{imported_at}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "projected",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4302",
+            "legacy_workflow_id": "4302"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{status-waiting.workflow}",
+            "run_id": "{status-waiting.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "status_failed": {
+    "status": 201,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "projected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4303",
+          "legacy_workflow_id": "4303"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{status-failed.workflow}",
+          "run_id": "{status-failed.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{status-failed.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        }
+      ],
+      "errors": [],
+      "imported_at": "{imported_at}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "projected",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4303",
+            "legacy_workflow_id": "4303"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{status-failed.workflow}",
+            "run_id": "{status-failed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "status_cancelled": {
+    "status": 201,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "projected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4304",
+          "legacy_workflow_id": "4304"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{status-cancelled.workflow}",
+          "run_id": "{status-cancelled.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{status-cancelled.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        }
+      ],
+      "errors": [],
+      "imported_at": "{imported_at}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "projected",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4304",
+            "legacy_workflow_id": "4304"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{status-cancelled.workflow}",
+            "run_id": "{status-cancelled.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "status_terminated": {
+    "status": 201,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "projected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4305",
+          "legacy_workflow_id": "4305"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{status-terminated.workflow}",
+          "run_id": "{status-terminated.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{status-terminated.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        }
+      ],
+      "errors": [],
+      "imported_at": "{imported_at}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "projected",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4305",
+            "legacy_workflow_id": "4305"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{status-terminated.workflow}",
+            "run_id": "{status-terminated.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "status_continued": {
+    "status": 201,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "projected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4306",
+          "legacy_workflow_id": "4306"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{status-continued.workflow}",
+          "run_id": "{status-continued.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{status-continued.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        }
+      ],
+      "errors": [],
+      "imported_at": "{imported_at}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "projected",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4306",
+            "legacy_workflow_id": "4306"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{status-continued.workflow}",
+            "run_id": "{status-continued.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "running": {
+    "status": 201,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "projected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4201",
+          "legacy_workflow_id": "4201"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{running.workflow}",
+          "run_id": "{running.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{running.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "runtime.execution",
+          "reason": "finish_on_v1_execution_not_transferable",
+          "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+        }
+      ],
+      "errors": [],
+      "imported_at": "{imported_at}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "projected",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4201",
+            "legacy_workflow_id": "4201"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "offsets": {
+    "status": 201,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "projected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4401",
+          "legacy_workflow_id": "4401"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{offsets.workflow}",
+          "run_id": "{offsets.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{offsets.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        }
+      ],
+      "errors": [],
+      "imported_at": "{imported_at}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "projected",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4401",
+            "legacy_workflow_id": "4401"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{offsets.workflow}",
+            "run_id": "{offsets.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "bare": {
+    "status": 201,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "projected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4501",
+          "legacy_workflow_id": "4501"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{bare.workflow}",
+          "run_id": "{bare.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{bare.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        }
+      ],
+      "errors": [],
+      "imported_at": "{imported_at}",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "projected",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4501",
+            "legacy_workflow_id": "4501"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{bare.workflow}",
+            "run_id": "{bare.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "native_start_status": 201,
+  "native_collision": {
+    "status": 409,
+    "response": {
+      "schema": "durable-workflow.v2.waterline-v1-projection.report",
+      "schema_version": 1,
+      "status": "rejected",
+      "projection_only": true,
+      "identity": {
+        "waterline": {
+          "source_id": "pr1-waterline-import",
+          "qualified_workflow_id": "v1:4601",
+          "legacy_workflow_id": "4601"
+        },
+        "standalone": {
+          "namespace": "pr1-waterline-import-wl1",
+          "workflow_id": "{collision.workflow}",
+          "run_id": "{collision.run}"
+        },
+        "relationship": "deterministic_source_qualified_projection",
+        "collision_policy": "reject_without_overwrite"
+      },
+      "dedupe_key": "{collision.dedupe}",
+      "unsupported_fields": [
+        {
+          "field": "runtime.replay",
+          "reason": "v1_history_not_replayable_as_v2",
+          "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+        },
+        {
+          "field": "timers",
+          "reason": "legacy_timer_state_not_exposed_by_waterline",
+          "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+        },
+        {
+          "field": "payloads.arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.output",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.activity_results",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.signal_arguments",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        },
+        {
+          "field": "payloads.exception_values",
+          "reason": "legacy_php_serialization_not_portable",
+          "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+        }
+      ],
+      "errors": [],
+      "reason": "native_v2_identity_collision",
+      "message": "The mapped standalone identity is already owned by a native or unrelated v2 execution.",
+      "remediation": "Choose a different stable source_id; the server will not overwrite the colliding v2 execution.",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "import_waterline_v1",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": [
+            "status",
+            "identity"
+          ],
+          "rejection_fields": [
+            "status",
+            "reason",
+            "message",
+            "remediation",
+            "identity"
+          ],
+          "rejection_reasons": [
+            "invalid_source_id",
+            "unqualified_v1_identity",
+            "v1_identity_mismatch",
+            "unsupported_source_engine",
+            "missing_v1_workflow_class",
+            "unsupported_v1_status",
+            "v1_projection_changed",
+            "v1_projection_namespace_collision",
+            "v1_projection_storage_inconsistent",
+            "native_v2_identity_collision",
+            "target_write_failed"
+          ]
+        },
+        "status": "rejected",
+        "reason": "native_v2_identity_collision",
+        "message": "The mapped standalone identity is already owned by a native or unrelated v2 execution.",
+        "remediation": "Choose a different stable source_id; the server will not overwrite the colliding v2 execution.",
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4601",
+            "legacy_workflow_id": "4601"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{collision.workflow}",
+            "run_id": "{collision.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        }
+      }
+    }
+  },
+  "read_project_describe": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{completed.workflow}",
+      "run_id": "{completed.run}",
+      "namespace": "pr1-waterline-import-wl1",
+      "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+      "business_key": null,
+      "status": "completed",
+      "status_bucket": "completed",
+      "is_terminal": true,
+      "closed_reason": "completed",
+      "task_queue": "legacy-orders",
+      "run_number": 1,
+      "run_count": 1,
+      "is_current_run": true,
+      "continued_from_run_id": null,
+      "resume_step_sequence": null,
+      "recovery_kind": null,
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "payload_codec": null,
+      "definition_routing": null,
+      "execution_timeout_seconds": null,
+      "run_timeout_seconds": null,
+      "execution_deadline_at": null,
+      "run_deadline_at": null,
+      "input": null,
+      "output": null,
+      "input_envelope": null,
+      "output_envelope": null,
+      "payload_previews": {
+        "input_omitted": false,
+        "output_omitted": false,
+        "max_encoded_bytes": 2097152
+      },
+      "started_at": "2026-09-30T08:00:00.000000Z",
+      "closed_at": "2026-09-30T08:00:06.000000Z",
+      "last_progress_at": "2026-09-30T08:00:06.000000Z",
+      "wait_kind": null,
+      "wait_reason": null,
+      "memo": [],
+      "search_attributes": [],
+      "actions": {
+        "can_signal": false,
+        "can_query": false,
+        "can_update": false,
+        "can_cancel": false,
+        "can_terminate": false,
+        "can_repair": false,
+        "can_archive": false
+      },
+      "commands_scope": "selected_run",
+      "commands": [],
+      "updates_scope": "selected_run",
+      "updates": [],
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.0.68",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4101",
+            "legacy_workflow_id": "4101"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": "redis",
+          "name": "legacy-orders",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.output",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.signal_arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.exception_values",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{completed.dedupe}"
+        }
+      },
+      "action_blocked_reason": "v1_projection_read_only",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "describe",
+        "workflow_id": "{completed.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": []
+        },
+        "run_id": "{completed.run}",
+        "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+        "namespace": "pr1-waterline-import-wl1",
+        "business_key": null,
+        "status": "completed",
+        "status_bucket": "completed",
+        "is_terminal": true,
+        "task_queue": "legacy-orders",
+        "run_number": 1,
+        "run_count": 1,
+        "is_current_run": true,
+        "compatibility": null,
+        "started_at": "2026-09-30T08:00:00.000000Z",
+        "closed_at": "2026-09-30T08:00:06.000000Z",
+        "last_progress_at": "2026-09-30T08:00:06.000000Z",
+        "wait_kind": null,
+        "wait_reason": null
+      }
+    }
+  },
+  "read_project_run": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{completed.workflow}",
+      "run_id": "{completed.run}",
+      "namespace": "pr1-waterline-import-wl1",
+      "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+      "business_key": null,
+      "status": "completed",
+      "status_bucket": "completed",
+      "is_terminal": true,
+      "closed_reason": "completed",
+      "task_queue": "legacy-orders",
+      "run_number": 1,
+      "run_count": 1,
+      "is_current_run": true,
+      "continued_from_run_id": null,
+      "resume_step_sequence": null,
+      "recovery_kind": null,
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "payload_codec": null,
+      "definition_routing": null,
+      "execution_timeout_seconds": null,
+      "run_timeout_seconds": null,
+      "execution_deadline_at": null,
+      "run_deadline_at": null,
+      "input": null,
+      "output": null,
+      "input_envelope": null,
+      "output_envelope": null,
+      "payload_previews": {
+        "input_omitted": false,
+        "output_omitted": false,
+        "max_encoded_bytes": 2097152
+      },
+      "started_at": "2026-09-30T08:00:00.000000Z",
+      "closed_at": "2026-09-30T08:00:06.000000Z",
+      "last_progress_at": "2026-09-30T08:00:06.000000Z",
+      "wait_kind": null,
+      "wait_reason": null,
+      "memo": [],
+      "search_attributes": [],
+      "actions": {
+        "can_signal": false,
+        "can_query": false,
+        "can_update": false,
+        "can_cancel": false,
+        "can_terminate": false,
+        "can_repair": false,
+        "can_archive": false
+      },
+      "commands_scope": "selected_run",
+      "commands": [],
+      "updates_scope": "selected_run",
+      "updates": [],
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.0.68",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4101",
+            "legacy_workflow_id": "4101"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": "redis",
+          "name": "legacy-orders",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.output",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.signal_arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.exception_values",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{completed.dedupe}"
+        }
+      },
+      "action_blocked_reason": "v1_projection_read_only",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "describe_run",
+        "workflow_id": "{completed.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": [
+            "run_id"
+          ],
+          "rejection_fields": [
+            "workflow_id",
+            "run_id",
+            "reason",
+            "message",
+            "retryable",
+            "error_id",
+            "exception"
+          ],
+          "rejection_reasons": [
+            "control_plane_internal_error"
+          ]
+        },
+        "run_id": "{completed.run}",
+        "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+        "namespace": "pr1-waterline-import-wl1",
+        "business_key": null,
+        "status": "completed",
+        "status_bucket": "completed",
+        "is_terminal": true,
+        "task_queue": "legacy-orders",
+        "run_number": 1,
+        "run_count": 1,
+        "is_current_run": true,
+        "compatibility": null,
+        "started_at": "2026-09-30T08:00:00.000000Z",
+        "closed_at": "2026-09-30T08:00:06.000000Z",
+        "last_progress_at": "2026-09-30T08:00:06.000000Z",
+        "wait_kind": null,
+        "wait_reason": null
+      }
+    }
+  },
+  "read_project_runs": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{completed.workflow}",
+      "run_count": 1,
+      "runs": [
+        {
+          "run_id": "{completed.run}",
+          "run_number": 1,
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "completed",
+          "status_bucket": "completed",
+          "is_terminal": true,
+          "is_current_run": true,
+          "task_queue": "legacy-orders",
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": "2026-09-30T08:00:00.000000Z",
+          "closed_at": "2026-09-30T08:00:06.000000Z"
+        }
+      ],
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "list_runs",
+        "workflow_id": "{completed.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": []
+        },
+        "run_count": 1
+      }
+    }
+  },
+  "read_project_history": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{completed.workflow}",
+      "run_id": "{completed.run}",
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "events": [
+        {
+          "sequence": 1,
+          "event_type": "WorkflowStarted",
+          "timestamp": "2026-09-30T08:00:00.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "origin": {
+                "engine_source": "v1",
+                "engine_version": "1.0.68",
+                "execution_engine": "finish-on-v1"
+              },
+              "identity": {
+                "waterline": {
+                  "source_id": "pr1-waterline-import",
+                  "qualified_workflow_id": "v1:4101",
+                  "legacy_workflow_id": "4101"
+                },
+                "standalone": {
+                  "namespace": "pr1-waterline-import-wl1",
+                  "workflow_id": "{completed.workflow}",
+                  "run_id": "{completed.run}"
+                },
+                "relationship": "deterministic_source_qualified_projection",
+                "collision_policy": "reject_without_overwrite"
+              },
+              "task_queue_context": {
+                "connection": "redis",
+                "name": "legacy-orders",
+                "execution_owner": "v1",
+                "standalone_dispatch": "disabled"
+              },
+              "unsupported_fields": [
+                {
+                  "field": "runtime.replay",
+                  "reason": "v1_history_not_replayable_as_v2",
+                  "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                },
+                {
+                  "field": "timers",
+                  "reason": "legacy_timer_state_not_exposed_by_waterline",
+                  "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                },
+                {
+                  "field": "payloads.arguments",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.output",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.activity_results",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.signal_arguments",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.exception_values",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                }
+              ]
+            },
+            "legacy_payloads": {
+              "arguments": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "a:1:{i:0;s:7:\"order-7\";}",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 2,
+          "event_type": "ActivityCompleted",
+          "timestamp": "2026-09-30T08:00:02.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9001,
+              "legacy_index": 0
+            },
+            "activity": {
+              "class": "App\\Activities\\ReserveStock",
+              "logical_time": "2026-09-30T08:00:01.000000Z",
+              "result": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "b:1;",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 3,
+          "event_type": "SignalReceived",
+          "timestamp": "2026-09-30T08:00:03.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_signal",
+              "legacy_id": 7001
+            },
+            "signal_name": "approve-λ",
+            "arguments": {
+              "available": true,
+              "encoding": "php-serialize",
+              "value": "a:1:{i:0;s:3:\"yes\";}",
+              "portable": false,
+              "unsupported_reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          }
+        },
+        {
+          "sequence": 4,
+          "event_type": "ActivityFailed",
+          "timestamp": "2026-09-30T08:00:04.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_exception",
+              "legacy_id": 5001
+            },
+            "exception": {
+              "value": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "O:9:\"Exception\":0:{}",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 5,
+          "event_type": "ActivityCompleted",
+          "timestamp": "2026-09-30T08:00:05.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9002,
+              "legacy_index": 1
+            },
+            "activity": {
+              "class": "App\\Activities\\ChargeCard",
+              "logical_time": "2026-09-30T08:00:04.500000Z",
+              "result": {
+                "available": false,
+                "encoding": "php-serialize",
+                "value": null,
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 6,
+          "event_type": "WorkflowCompleted",
+          "timestamp": "2026-09-30T08:00:06.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_status": "completed",
+              "execution_owner": "v1"
+            },
+            "legacy_payloads": {
+              "output": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "s:9:\"fulfilled\";",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        }
+      ],
+      "next_page_token": null,
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.0.68",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4101",
+            "legacy_workflow_id": "4101"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": "redis",
+          "name": "legacy-orders",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.output",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.signal_arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.exception_values",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{completed.dedupe}"
+        }
+      },
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "history",
+        "workflow_id": "{completed.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id",
+            "run_id"
+          ],
+          "success_fields": [
+            "next_page_token"
+          ],
+          "rejection_fields": [
+            "workflow_id",
+            "run_id",
+            "reason",
+            "message",
+            "retryable",
+            "error_id",
+            "exception"
+          ],
+          "rejection_reasons": [
+            "control_plane_internal_error"
+          ]
+        },
+        "run_id": "{completed.run}",
+        "compatibility": null,
+        "next_page_token": null
+      }
+    }
+  },
+  "read_project_export": {
+    "status": 200,
+    "response": {
+      "schema": "durable-workflow.v2.history-export",
+      "schema_version": 2,
+      "exported_at": "{exported_at}",
+      "dedupe_key": "{completed.run}:6:2026-09-30T08:00:06.000000Z",
+      "history_complete": true,
+      "workflow": {
+        "instance_id": "{completed.workflow}",
+        "run_id": "{completed.run}",
+        "run_number": 1,
+        "is_current_run": true,
+        "current_run_id": "{completed.run}",
+        "current_run_source": "run_order_fallback",
+        "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+        "workflow_class": "App\\Workflows\\Legacy\\OrderFulfillment",
+        "source_runtime": "standalone_server",
+        "source_process_class": "server_http_node",
+        "business_key": null,
+        "visibility_labels": [],
+        "memo": [],
+        "memo_payload": {
+          "codec": "avro",
+          "blob": "wwHioz3/VYAiNw4A"
+        },
+        "search_attributes": [],
+        "status": "completed",
+        "status_bucket": "completed",
+        "closed_reason": "completed",
+        "archived_at": null,
+        "archive_command_id": null,
+        "archive_reason": null,
+        "compatibility": null,
+        "connection": "redis",
+        "queue": "legacy-orders",
+        "last_history_sequence": 6,
+        "started_at": "2026-09-30T08:00:00.000000Z",
+        "closed_at": "2026-09-30T08:00:06.000000Z",
+        "last_progress_at": "2026-09-30T08:00:06.000000Z"
+      },
+      "payloads": {
+        "codec": "avro",
+        "arguments": {
+          "available": false,
+          "data": null
+        },
+        "output": {
+          "available": false,
+          "codec": null,
+          "data": null
+        }
+      },
+      "summary": {
+        "status": "completed",
+        "status_bucket": "completed",
+        "closed_reason": "completed",
+        "archived_at": null,
+        "archive_command_id": null,
+        "archive_reason": null,
+        "business_key": null,
+        "visibility_labels": [],
+        "search_attributes": [],
+        "is_current_run": true,
+        "started_at": "2026-09-30T08:00:00.000000Z",
+        "closed_at": "2026-09-30T08:00:06.000000Z",
+        "duration_ms": null,
+        "wait_kind": null,
+        "wait_reason": null,
+        "wait_started_at": null,
+        "wait_deadline_at": null,
+        "open_wait_id": null,
+        "resume_source_kind": null,
+        "resume_source_id": null,
+        "next_task_at": null,
+        "next_task_id": null,
+        "next_task_type": null,
+        "next_task_status": null,
+        "next_task_lease_expires_at": null,
+        "liveness_state": null,
+        "liveness_reason": null,
+        "repair_attention": false,
+        "task_problem": false,
+        "task_problem_badge": null,
+        "exception_count": 1,
+        "history_event_count": 6,
+        "history_size_bytes": 5431,
+        "history_fan_out": 0,
+        "continue_as_new_recommended": false,
+        "history_budget_pressure": "ok",
+        "sort_timestamp": "2026-09-30T08:00:06.000000Z",
+        "sort_key": null
+      },
+      "history_events": [
+        {
+          "id": "{completed.e1}",
+          "sequence": 1,
+          "type": "WorkflowStarted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:00.000000Z",
+          "payload": {
+            "migration_projection": {
+              "origin": {
+                "engine_source": "v1",
+                "engine_version": "1.0.68",
+                "execution_engine": "finish-on-v1"
+              },
+              "identity": {
+                "waterline": {
+                  "source_id": "pr1-waterline-import",
+                  "qualified_workflow_id": "v1:4101",
+                  "legacy_workflow_id": "4101"
+                },
+                "standalone": {
+                  "namespace": "pr1-waterline-import-wl1",
+                  "workflow_id": "{completed.workflow}",
+                  "run_id": "{completed.run}"
+                },
+                "relationship": "deterministic_source_qualified_projection",
+                "collision_policy": "reject_without_overwrite"
+              },
+              "task_queue_context": {
+                "connection": "redis",
+                "name": "legacy-orders",
+                "execution_owner": "v1",
+                "standalone_dispatch": "disabled"
+              },
+              "unsupported_fields": [
+                {
+                  "field": "runtime.replay",
+                  "reason": "v1_history_not_replayable_as_v2",
+                  "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                },
+                {
+                  "field": "timers",
+                  "reason": "legacy_timer_state_not_exposed_by_waterline",
+                  "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                },
+                {
+                  "field": "payloads.arguments",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.output",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.activity_results",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.signal_arguments",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.exception_values",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                }
+              ]
+            },
+            "legacy_payloads": {
+              "arguments": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "a:1:{i:0;s:7:\"order-7\";}",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{completed.e2}",
+          "sequence": 2,
+          "type": "ActivityCompleted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:02.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9001,
+              "legacy_index": 0
+            },
+            "activity": {
+              "class": "App\\Activities\\ReserveStock",
+              "logical_time": "2026-09-30T08:00:01.000000Z",
+              "result": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "b:1;",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{completed.e3}",
+          "sequence": 3,
+          "type": "SignalReceived",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:03.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_signal",
+              "legacy_id": 7001
+            },
+            "signal_name": "approve-λ",
+            "arguments": {
+              "available": true,
+              "encoding": "php-serialize",
+              "value": "a:1:{i:0;s:3:\"yes\";}",
+              "portable": false,
+              "unsupported_reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          }
+        },
+        {
+          "id": "{completed.e4}",
+          "sequence": 4,
+          "type": "ActivityFailed",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:04.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_exception",
+              "legacy_id": 5001
+            },
+            "exception": {
+              "class": "App\\Activities\\ChargeCard",
+              "value": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "O:9:\"Exception\":0:{}",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{completed.e5}",
+          "sequence": 5,
+          "type": "ActivityCompleted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:05.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9002,
+              "legacy_index": 1
+            },
+            "activity": {
+              "class": "App\\Activities\\ChargeCard",
+              "logical_time": "2026-09-30T08:00:04.500000Z",
+              "result": {
+                "available": false,
+                "encoding": "php-serialize",
+                "value": null,
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{completed.e6}",
+          "sequence": 6,
+          "type": "WorkflowCompleted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:06.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_status": "completed",
+              "execution_owner": "v1"
+            },
+            "legacy_payloads": {
+              "output": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "s:9:\"fulfilled\";",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        }
+      ],
+      "linked_intakes_scope": "selected_run",
+      "linked_intakes": [],
+      "commands": [],
+      "signals": [],
+      "updates": [],
+      "tasks": [],
+      "activities": [],
+      "timers": [],
+      "failures": [],
+      "links": {
+        "parents": [],
+        "children": []
+      },
+      "redaction": {
+        "applied": false,
+        "policy": null,
+        "paths": []
+      },
+      "codec_schemas": {
+        "avro": {
+          "encoding": "base64-avro-single-object",
+          "framing": "single_object",
+          "magic_hex": "c301",
+          "current_fingerprint": "e2a33dff55802237",
+          "writer_schemas": {
+            "e2a33dff55802237": {
+              "schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+              "fingerprint": "crc64-avro:e2a33dff55802237"
+            }
+          }
+        }
+      },
+      "payload_manifest": {
+        "version": 1,
+        "entries": [
+          {
+            "path": "workflow.memo_payload",
+            "codec": "avro",
+            "available": true,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": "single_object",
+            "avro_prefix_hex": "c301",
+            "writer_schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+            "writer_schema_fingerprint": "crc64-avro:e2a33dff55802237",
+            "diagnostic": null
+          },
+          {
+            "path": "payloads.arguments.data",
+            "codec": "avro",
+            "available": false,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": null,
+            "avro_prefix_hex": null,
+            "writer_schema": null,
+            "writer_schema_fingerprint": null,
+            "diagnostic": "payload_unavailable"
+          },
+          {
+            "path": "payloads.output.data",
+            "codec": "avro",
+            "available": false,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": null,
+            "avro_prefix_hex": null,
+            "writer_schema": null,
+            "writer_schema_fingerprint": null,
+            "diagnostic": "payload_unavailable"
+          },
+          {
+            "path": "history_events.5.payload.output",
+            "codec": "avro",
+            "available": false,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": null,
+            "avro_prefix_hex": null,
+            "writer_schema": null,
+            "writer_schema_fingerprint": null,
+            "diagnostic": "payload_unavailable"
+          }
+        ]
+      },
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.0.68",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4101",
+            "legacy_workflow_id": "4101"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{completed.workflow}",
+            "run_id": "{completed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": "redis",
+          "name": "legacy-orders",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.output",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.signal_arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.exception_values",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{completed.dedupe}"
+        }
+      },
+      "integrity": {
+        "canonicalization": "json-recursive-ksort-v1",
+        "checksum_algorithm": "sha256",
+        "checksum": "{completed.export_checksum}",
+        "signature_algorithm": null,
+        "signature": null,
+        "key_id": null
+      },
+      "integrity_verified": true
+    }
+  },
+  "read_running_describe": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{running.workflow}",
+      "run_id": "{running.run}",
+      "namespace": "pr1-waterline-import-wl1",
+      "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+      "business_key": null,
+      "status": "running",
+      "status_bucket": "running",
+      "is_terminal": false,
+      "closed_reason": null,
+      "task_queue": "legacy-billing",
+      "run_number": 1,
+      "run_count": 1,
+      "is_current_run": true,
+      "continued_from_run_id": null,
+      "resume_step_sequence": null,
+      "recovery_kind": null,
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "payload_codec": null,
+      "definition_routing": null,
+      "execution_timeout_seconds": null,
+      "run_timeout_seconds": null,
+      "execution_deadline_at": null,
+      "run_deadline_at": null,
+      "input": null,
+      "output": null,
+      "input_envelope": null,
+      "output_envelope": null,
+      "payload_previews": {
+        "input_omitted": false,
+        "output_omitted": false,
+        "max_encoded_bytes": 2097152
+      },
+      "started_at": "2026-09-30T09:00:00.000000Z",
+      "closed_at": null,
+      "last_progress_at": "2026-09-30T09:00:00.000000Z",
+      "wait_kind": null,
+      "wait_reason": null,
+      "memo": [],
+      "search_attributes": [],
+      "actions": {
+        "can_signal": false,
+        "can_query": false,
+        "can_update": false,
+        "can_cancel": false,
+        "can_terminate": false,
+        "can_repair": false,
+        "can_archive": false
+      },
+      "commands_scope": "selected_run",
+      "commands": [],
+      "updates_scope": "selected_run",
+      "updates": [],
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.x",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4201",
+            "legacy_workflow_id": "4201"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": "database",
+          "name": "legacy-billing",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "runtime.execution",
+            "reason": "finish_on_v1_execution_not_transferable",
+            "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{running.dedupe}"
+        }
+      },
+      "action_blocked_reason": "v1_projection_read_only",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "describe",
+        "workflow_id": "{running.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": []
+        },
+        "run_id": "{running.run}",
+        "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+        "namespace": "pr1-waterline-import-wl1",
+        "business_key": null,
+        "status": "running",
+        "status_bucket": "running",
+        "is_terminal": false,
+        "task_queue": "legacy-billing",
+        "run_number": 1,
+        "run_count": 1,
+        "is_current_run": true,
+        "compatibility": null,
+        "started_at": "2026-09-30T09:00:00.000000Z",
+        "closed_at": null,
+        "last_progress_at": "2026-09-30T09:00:00.000000Z",
+        "wait_kind": null,
+        "wait_reason": null
+      }
+    }
+  },
+  "read_running_run": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{running.workflow}",
+      "run_id": "{running.run}",
+      "namespace": "pr1-waterline-import-wl1",
+      "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+      "business_key": null,
+      "status": "running",
+      "status_bucket": "running",
+      "is_terminal": false,
+      "closed_reason": null,
+      "task_queue": "legacy-billing",
+      "run_number": 1,
+      "run_count": 1,
+      "is_current_run": true,
+      "continued_from_run_id": null,
+      "resume_step_sequence": null,
+      "recovery_kind": null,
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "payload_codec": null,
+      "definition_routing": null,
+      "execution_timeout_seconds": null,
+      "run_timeout_seconds": null,
+      "execution_deadline_at": null,
+      "run_deadline_at": null,
+      "input": null,
+      "output": null,
+      "input_envelope": null,
+      "output_envelope": null,
+      "payload_previews": {
+        "input_omitted": false,
+        "output_omitted": false,
+        "max_encoded_bytes": 2097152
+      },
+      "started_at": "2026-09-30T09:00:00.000000Z",
+      "closed_at": null,
+      "last_progress_at": "2026-09-30T09:00:00.000000Z",
+      "wait_kind": null,
+      "wait_reason": null,
+      "memo": [],
+      "search_attributes": [],
+      "actions": {
+        "can_signal": false,
+        "can_query": false,
+        "can_update": false,
+        "can_cancel": false,
+        "can_terminate": false,
+        "can_repair": false,
+        "can_archive": false
+      },
+      "commands_scope": "selected_run",
+      "commands": [],
+      "updates_scope": "selected_run",
+      "updates": [],
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.x",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4201",
+            "legacy_workflow_id": "4201"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": "database",
+          "name": "legacy-billing",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "runtime.execution",
+            "reason": "finish_on_v1_execution_not_transferable",
+            "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{running.dedupe}"
+        }
+      },
+      "action_blocked_reason": "v1_projection_read_only",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "describe_run",
+        "workflow_id": "{running.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": [
+            "run_id"
+          ],
+          "rejection_fields": [
+            "workflow_id",
+            "run_id",
+            "reason",
+            "message",
+            "retryable",
+            "error_id",
+            "exception"
+          ],
+          "rejection_reasons": [
+            "control_plane_internal_error"
+          ]
+        },
+        "run_id": "{running.run}",
+        "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+        "namespace": "pr1-waterline-import-wl1",
+        "business_key": null,
+        "status": "running",
+        "status_bucket": "running",
+        "is_terminal": false,
+        "task_queue": "legacy-billing",
+        "run_number": 1,
+        "run_count": 1,
+        "is_current_run": true,
+        "compatibility": null,
+        "started_at": "2026-09-30T09:00:00.000000Z",
+        "closed_at": null,
+        "last_progress_at": "2026-09-30T09:00:00.000000Z",
+        "wait_kind": null,
+        "wait_reason": null
+      }
+    }
+  },
+  "read_running_runs": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{running.workflow}",
+      "run_count": 1,
+      "runs": [
+        {
+          "run_id": "{running.run}",
+          "run_number": 1,
+          "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+          "business_key": null,
+          "status": "running",
+          "status_bucket": "running",
+          "is_terminal": false,
+          "is_current_run": true,
+          "task_queue": "legacy-billing",
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": "2026-09-30T09:00:00.000000Z",
+          "closed_at": null
+        }
+      ],
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "list_runs",
+        "workflow_id": "{running.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": []
+        },
+        "run_count": 1
+      }
+    }
+  },
+  "read_running_history": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{running.workflow}",
+      "run_id": "{running.run}",
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "events": [
+        {
+          "sequence": 1,
+          "event_type": "WorkflowStarted",
+          "timestamp": "2026-09-30T09:00:00.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "origin": {
+                "engine_source": "v1",
+                "engine_version": "1.x",
+                "execution_engine": "finish-on-v1"
+              },
+              "identity": {
+                "waterline": {
+                  "source_id": "pr1-waterline-import",
+                  "qualified_workflow_id": "v1:4201",
+                  "legacy_workflow_id": "4201"
+                },
+                "standalone": {
+                  "namespace": "pr1-waterline-import-wl1",
+                  "workflow_id": "{running.workflow}",
+                  "run_id": "{running.run}"
+                },
+                "relationship": "deterministic_source_qualified_projection",
+                "collision_policy": "reject_without_overwrite"
+              },
+              "task_queue_context": {
+                "connection": "database",
+                "name": "legacy-billing",
+                "execution_owner": "v1",
+                "standalone_dispatch": "disabled"
+              },
+              "unsupported_fields": [
+                {
+                  "field": "runtime.replay",
+                  "reason": "v1_history_not_replayable_as_v2",
+                  "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                },
+                {
+                  "field": "timers",
+                  "reason": "legacy_timer_state_not_exposed_by_waterline",
+                  "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                },
+                {
+                  "field": "payloads.arguments",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.activity_results",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "runtime.execution",
+                  "reason": "finish_on_v1_execution_not_transferable",
+                  "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+                }
+              ]
+            },
+            "legacy_payloads": {
+              "arguments": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "a:0:{}",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 2,
+          "event_type": "ActivityCompleted",
+          "timestamp": "2026-09-30T09:00:02.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9101,
+              "legacy_index": 0
+            },
+            "activity": {
+              "class": "App\\Activities\\Bill",
+              "logical_time": "2026-09-30T09:00:01.000000Z",
+              "result": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "i:42;",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        }
+      ],
+      "next_page_token": null,
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.x",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4201",
+            "legacy_workflow_id": "4201"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": "database",
+          "name": "legacy-billing",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "runtime.execution",
+            "reason": "finish_on_v1_execution_not_transferable",
+            "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{running.dedupe}"
+        }
+      },
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "history",
+        "workflow_id": "{running.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id",
+            "run_id"
+          ],
+          "success_fields": [
+            "next_page_token"
+          ],
+          "rejection_fields": [
+            "workflow_id",
+            "run_id",
+            "reason",
+            "message",
+            "retryable",
+            "error_id",
+            "exception"
+          ],
+          "rejection_reasons": [
+            "control_plane_internal_error"
+          ]
+        },
+        "run_id": "{running.run}",
+        "compatibility": null,
+        "next_page_token": null
+      }
+    }
+  },
+  "read_running_export": {
+    "status": 200,
+    "response": {
+      "schema": "durable-workflow.v2.history-export",
+      "schema_version": 2,
+      "exported_at": "{exported_at}",
+      "dedupe_key": "{running.run}:2:2026-09-30T09:00:00.000000Z",
+      "history_complete": false,
+      "workflow": {
+        "instance_id": "{running.workflow}",
+        "run_id": "{running.run}",
+        "run_number": 1,
+        "is_current_run": true,
+        "current_run_id": "{running.run}",
+        "current_run_source": "run_order_fallback",
+        "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+        "workflow_class": "App\\Workflows\\Legacy\\Subscription",
+        "source_runtime": "standalone_server",
+        "source_process_class": "server_http_node",
+        "business_key": null,
+        "visibility_labels": [],
+        "memo": [],
+        "memo_payload": {
+          "codec": "avro",
+          "blob": "wwHioz3/VYAiNw4A"
+        },
+        "search_attributes": [],
+        "status": "running",
+        "status_bucket": "running",
+        "closed_reason": null,
+        "archived_at": null,
+        "archive_command_id": null,
+        "archive_reason": null,
+        "compatibility": null,
+        "connection": "database",
+        "queue": "legacy-billing",
+        "last_history_sequence": 2,
+        "started_at": "2026-09-30T09:00:00.000000Z",
+        "closed_at": null,
+        "last_progress_at": "2026-09-30T09:00:00.000000Z"
+      },
+      "payloads": {
+        "codec": "avro",
+        "arguments": {
+          "available": false,
+          "data": null
+        },
+        "output": {
+          "available": false,
+          "codec": null,
+          "data": null
+        }
+      },
+      "summary": {
+        "status": "running",
+        "status_bucket": "running",
+        "closed_reason": null,
+        "archived_at": null,
+        "archive_command_id": null,
+        "archive_reason": null,
+        "business_key": null,
+        "visibility_labels": [],
+        "search_attributes": [],
+        "is_current_run": true,
+        "started_at": "2026-09-30T09:00:00.000000Z",
+        "closed_at": null,
+        "duration_ms": null,
+        "wait_kind": null,
+        "wait_reason": null,
+        "wait_started_at": null,
+        "wait_deadline_at": null,
+        "open_wait_id": null,
+        "resume_source_kind": null,
+        "resume_source_id": null,
+        "next_task_at": null,
+        "next_task_id": null,
+        "next_task_type": null,
+        "next_task_status": null,
+        "next_task_lease_expires_at": null,
+        "liveness_state": "external_v1",
+        "liveness_reason": "Execution remains owned by the source v1 runtime; this standalone row is read-only.",
+        "repair_attention": false,
+        "task_problem": false,
+        "task_problem_badge": null,
+        "exception_count": 0,
+        "history_event_count": 2,
+        "history_size_bytes": 2683,
+        "history_fan_out": 0,
+        "continue_as_new_recommended": false,
+        "history_budget_pressure": "ok",
+        "sort_timestamp": "2026-09-30T09:00:00.000000Z",
+        "sort_key": null
+      },
+      "history_events": [
+        {
+          "id": "{running.e1}",
+          "sequence": 1,
+          "type": "WorkflowStarted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T09:00:00.000000Z",
+          "payload": {
+            "migration_projection": {
+              "origin": {
+                "engine_source": "v1",
+                "engine_version": "1.x",
+                "execution_engine": "finish-on-v1"
+              },
+              "identity": {
+                "waterline": {
+                  "source_id": "pr1-waterline-import",
+                  "qualified_workflow_id": "v1:4201",
+                  "legacy_workflow_id": "4201"
+                },
+                "standalone": {
+                  "namespace": "pr1-waterline-import-wl1",
+                  "workflow_id": "{running.workflow}",
+                  "run_id": "{running.run}"
+                },
+                "relationship": "deterministic_source_qualified_projection",
+                "collision_policy": "reject_without_overwrite"
+              },
+              "task_queue_context": {
+                "connection": "database",
+                "name": "legacy-billing",
+                "execution_owner": "v1",
+                "standalone_dispatch": "disabled"
+              },
+              "unsupported_fields": [
+                {
+                  "field": "runtime.replay",
+                  "reason": "v1_history_not_replayable_as_v2",
+                  "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                },
+                {
+                  "field": "timers",
+                  "reason": "legacy_timer_state_not_exposed_by_waterline",
+                  "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                },
+                {
+                  "field": "payloads.arguments",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.activity_results",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "runtime.execution",
+                  "reason": "finish_on_v1_execution_not_transferable",
+                  "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+                }
+              ]
+            },
+            "legacy_payloads": {
+              "arguments": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "a:0:{}",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{running.e2}",
+          "sequence": 2,
+          "type": "ActivityCompleted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T09:00:02.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9101,
+              "legacy_index": 0
+            },
+            "activity": {
+              "class": "App\\Activities\\Bill",
+              "logical_time": "2026-09-30T09:00:01.000000Z",
+              "result": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "i:42;",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        }
+      ],
+      "linked_intakes_scope": "selected_run",
+      "linked_intakes": [],
+      "commands": [],
+      "signals": [],
+      "updates": [],
+      "tasks": [],
+      "activities": [],
+      "timers": [],
+      "failures": [],
+      "links": {
+        "parents": [],
+        "children": []
+      },
+      "redaction": {
+        "applied": false,
+        "policy": null,
+        "paths": []
+      },
+      "codec_schemas": {
+        "avro": {
+          "encoding": "base64-avro-single-object",
+          "framing": "single_object",
+          "magic_hex": "c301",
+          "current_fingerprint": "e2a33dff55802237",
+          "writer_schemas": {
+            "e2a33dff55802237": {
+              "schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+              "fingerprint": "crc64-avro:e2a33dff55802237"
+            }
+          }
+        }
+      },
+      "payload_manifest": {
+        "version": 1,
+        "entries": [
+          {
+            "path": "workflow.memo_payload",
+            "codec": "avro",
+            "available": true,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": "single_object",
+            "avro_prefix_hex": "c301",
+            "writer_schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+            "writer_schema_fingerprint": "crc64-avro:e2a33dff55802237",
+            "diagnostic": null
+          },
+          {
+            "path": "payloads.arguments.data",
+            "codec": "avro",
+            "available": false,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": null,
+            "avro_prefix_hex": null,
+            "writer_schema": null,
+            "writer_schema_fingerprint": null,
+            "diagnostic": "payload_unavailable"
+          },
+          {
+            "path": "payloads.output.data",
+            "codec": "avro",
+            "available": false,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": null,
+            "avro_prefix_hex": null,
+            "writer_schema": null,
+            "writer_schema_fingerprint": null,
+            "diagnostic": "payload_unavailable"
+          }
+        ]
+      },
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.x",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4201",
+            "legacy_workflow_id": "4201"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": "database",
+          "name": "legacy-billing",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "runtime.execution",
+            "reason": "finish_on_v1_execution_not_transferable",
+            "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{running.dedupe}"
+        }
+      },
+      "integrity": {
+        "canonicalization": "json-recursive-ksort-v1",
+        "checksum_algorithm": "sha256",
+        "checksum": "{running.export_checksum}",
+        "signature_algorithm": null,
+        "signature": null,
+        "key_id": null
+      },
+      "integrity_verified": true
+    }
+  },
+  "read_failed_describe": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{status-failed.workflow}",
+      "run_id": "{status-failed.run}",
+      "namespace": "pr1-waterline-import-wl1",
+      "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+      "business_key": null,
+      "status": "failed",
+      "status_bucket": "failed",
+      "is_terminal": true,
+      "closed_reason": "failed",
+      "task_queue": "legacy-orders",
+      "run_number": 1,
+      "run_count": 1,
+      "is_current_run": true,
+      "continued_from_run_id": null,
+      "resume_step_sequence": null,
+      "recovery_kind": null,
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "payload_codec": null,
+      "definition_routing": null,
+      "execution_timeout_seconds": null,
+      "run_timeout_seconds": null,
+      "execution_deadline_at": null,
+      "run_deadline_at": null,
+      "input": null,
+      "output": null,
+      "input_envelope": null,
+      "output_envelope": null,
+      "payload_previews": {
+        "input_omitted": false,
+        "output_omitted": false,
+        "max_encoded_bytes": 2097152
+      },
+      "started_at": "2026-09-30T07:03:00.000000Z",
+      "closed_at": "2026-09-30T07:03:30.000000Z",
+      "last_progress_at": "2026-09-30T07:03:30.000000Z",
+      "wait_kind": null,
+      "wait_reason": null,
+      "memo": [],
+      "search_attributes": [],
+      "actions": {
+        "can_signal": false,
+        "can_query": false,
+        "can_update": false,
+        "can_cancel": false,
+        "can_terminate": false,
+        "can_repair": false,
+        "can_archive": false
+      },
+      "commands_scope": "selected_run",
+      "commands": [],
+      "updates_scope": "selected_run",
+      "updates": [],
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.0.68",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4303",
+            "legacy_workflow_id": "4303"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{status-failed.workflow}",
+            "run_id": "{status-failed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": "redis",
+          "name": "legacy-orders",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.output",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.signal_arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.exception_values",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{status-failed.dedupe}"
+        }
+      },
+      "action_blocked_reason": "v1_projection_read_only",
+      "error": null,
+      "failure": {
+        "activity_failures": [
+          {
+            "event_sequence": 4,
+            "event_type": "ActivityFailed"
+          }
+        ]
+      },
+      "exception": null,
+      "failures": [],
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "describe",
+        "workflow_id": "{status-failed.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": []
+        },
+        "run_id": "{status-failed.run}",
+        "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+        "namespace": "pr1-waterline-import-wl1",
+        "business_key": null,
+        "status": "failed",
+        "status_bucket": "failed",
+        "is_terminal": true,
+        "task_queue": "legacy-orders",
+        "run_number": 1,
+        "run_count": 1,
+        "is_current_run": true,
+        "compatibility": null,
+        "started_at": "2026-09-30T07:03:00.000000Z",
+        "closed_at": "2026-09-30T07:03:30.000000Z",
+        "last_progress_at": "2026-09-30T07:03:30.000000Z",
+        "wait_kind": null,
+        "wait_reason": null,
+        "exception": null
+      }
+    }
+  },
+  "read_failed_run": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{status-failed.workflow}",
+      "run_id": "{status-failed.run}",
+      "namespace": "pr1-waterline-import-wl1",
+      "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+      "business_key": null,
+      "status": "failed",
+      "status_bucket": "failed",
+      "is_terminal": true,
+      "closed_reason": "failed",
+      "task_queue": "legacy-orders",
+      "run_number": 1,
+      "run_count": 1,
+      "is_current_run": true,
+      "continued_from_run_id": null,
+      "resume_step_sequence": null,
+      "recovery_kind": null,
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "payload_codec": null,
+      "definition_routing": null,
+      "execution_timeout_seconds": null,
+      "run_timeout_seconds": null,
+      "execution_deadline_at": null,
+      "run_deadline_at": null,
+      "input": null,
+      "output": null,
+      "input_envelope": null,
+      "output_envelope": null,
+      "payload_previews": {
+        "input_omitted": false,
+        "output_omitted": false,
+        "max_encoded_bytes": 2097152
+      },
+      "started_at": "2026-09-30T07:03:00.000000Z",
+      "closed_at": "2026-09-30T07:03:30.000000Z",
+      "last_progress_at": "2026-09-30T07:03:30.000000Z",
+      "wait_kind": null,
+      "wait_reason": null,
+      "memo": [],
+      "search_attributes": [],
+      "actions": {
+        "can_signal": false,
+        "can_query": false,
+        "can_update": false,
+        "can_cancel": false,
+        "can_terminate": false,
+        "can_repair": false,
+        "can_archive": false
+      },
+      "commands_scope": "selected_run",
+      "commands": [],
+      "updates_scope": "selected_run",
+      "updates": [],
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.0.68",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4303",
+            "legacy_workflow_id": "4303"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{status-failed.workflow}",
+            "run_id": "{status-failed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": "redis",
+          "name": "legacy-orders",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.output",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.signal_arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.exception_values",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{status-failed.dedupe}"
+        }
+      },
+      "action_blocked_reason": "v1_projection_read_only",
+      "error": null,
+      "failure": {
+        "activity_failures": [
+          {
+            "event_sequence": 4,
+            "event_type": "ActivityFailed"
+          }
+        ]
+      },
+      "exception": null,
+      "failures": [],
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "describe_run",
+        "workflow_id": "{status-failed.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": [
+            "run_id"
+          ],
+          "rejection_fields": [
+            "workflow_id",
+            "run_id",
+            "reason",
+            "message",
+            "retryable",
+            "error_id",
+            "exception"
+          ],
+          "rejection_reasons": [
+            "control_plane_internal_error"
+          ]
+        },
+        "run_id": "{status-failed.run}",
+        "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+        "namespace": "pr1-waterline-import-wl1",
+        "business_key": null,
+        "status": "failed",
+        "status_bucket": "failed",
+        "is_terminal": true,
+        "task_queue": "legacy-orders",
+        "run_number": 1,
+        "run_count": 1,
+        "is_current_run": true,
+        "compatibility": null,
+        "started_at": "2026-09-30T07:03:00.000000Z",
+        "closed_at": "2026-09-30T07:03:30.000000Z",
+        "last_progress_at": "2026-09-30T07:03:30.000000Z",
+        "wait_kind": null,
+        "wait_reason": null,
+        "exception": null
+      }
+    }
+  },
+  "read_failed_runs": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{status-failed.workflow}",
+      "run_count": 1,
+      "runs": [
+        {
+          "run_id": "{status-failed.run}",
+          "run_number": 1,
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "failed",
+          "status_bucket": "failed",
+          "is_terminal": true,
+          "is_current_run": true,
+          "task_queue": "legacy-orders",
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": "2026-09-30T07:03:00.000000Z",
+          "closed_at": "2026-09-30T07:03:30.000000Z"
+        }
+      ],
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "list_runs",
+        "workflow_id": "{status-failed.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": []
+        },
+        "run_count": 1
+      }
+    }
+  },
+  "read_failed_history": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{status-failed.workflow}",
+      "run_id": "{status-failed.run}",
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "events": [
+        {
+          "sequence": 1,
+          "event_type": "WorkflowStarted",
+          "timestamp": "2026-09-30T07:03:00.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "origin": {
+                "engine_source": "v1",
+                "engine_version": "1.0.68",
+                "execution_engine": "finish-on-v1"
+              },
+              "identity": {
+                "waterline": {
+                  "source_id": "pr1-waterline-import",
+                  "qualified_workflow_id": "v1:4303",
+                  "legacy_workflow_id": "4303"
+                },
+                "standalone": {
+                  "namespace": "pr1-waterline-import-wl1",
+                  "workflow_id": "{status-failed.workflow}",
+                  "run_id": "{status-failed.run}"
+                },
+                "relationship": "deterministic_source_qualified_projection",
+                "collision_policy": "reject_without_overwrite"
+              },
+              "task_queue_context": {
+                "connection": "redis",
+                "name": "legacy-orders",
+                "execution_owner": "v1",
+                "standalone_dispatch": "disabled"
+              },
+              "unsupported_fields": [
+                {
+                  "field": "runtime.replay",
+                  "reason": "v1_history_not_replayable_as_v2",
+                  "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                },
+                {
+                  "field": "timers",
+                  "reason": "legacy_timer_state_not_exposed_by_waterline",
+                  "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                },
+                {
+                  "field": "payloads.arguments",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.output",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.activity_results",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.signal_arguments",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.exception_values",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                }
+              ]
+            },
+            "legacy_payloads": {
+              "arguments": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "a:1:{i:0;s:7:\"order-7\";}",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 2,
+          "event_type": "ActivityCompleted",
+          "timestamp": "2026-09-30T08:00:02.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9001,
+              "legacy_index": 0
+            },
+            "activity": {
+              "class": "App\\Activities\\ReserveStock",
+              "logical_time": "2026-09-30T08:00:01.000000Z",
+              "result": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "b:1;",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 3,
+          "event_type": "SignalReceived",
+          "timestamp": "2026-09-30T08:00:03.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_signal",
+              "legacy_id": 7001
+            },
+            "signal_name": "approve-λ",
+            "arguments": {
+              "available": true,
+              "encoding": "php-serialize",
+              "value": "a:1:{i:0;s:3:\"yes\";}",
+              "portable": false,
+              "unsupported_reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          }
+        },
+        {
+          "sequence": 4,
+          "event_type": "ActivityFailed",
+          "timestamp": "2026-09-30T08:00:04.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_exception",
+              "legacy_id": 5001
+            },
+            "exception": {
+              "value": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "O:9:\"Exception\":0:{}",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 5,
+          "event_type": "ActivityCompleted",
+          "timestamp": "2026-09-30T08:00:05.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9002,
+              "legacy_index": 1
+            },
+            "activity": {
+              "class": "App\\Activities\\ChargeCard",
+              "logical_time": "2026-09-30T08:00:04.500000Z",
+              "result": {
+                "available": false,
+                "encoding": "php-serialize",
+                "value": null,
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 6,
+          "event_type": "WorkflowFailed",
+          "timestamp": "2026-09-30T07:03:30.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_status": "FAILED",
+              "execution_owner": "v1"
+            },
+            "legacy_payloads": {
+              "output": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "s:9:\"fulfilled\";",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        }
+      ],
+      "next_page_token": null,
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.0.68",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4303",
+            "legacy_workflow_id": "4303"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{status-failed.workflow}",
+            "run_id": "{status-failed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": "redis",
+          "name": "legacy-orders",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.output",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.signal_arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.exception_values",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{status-failed.dedupe}"
+        }
+      },
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "history",
+        "workflow_id": "{status-failed.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id",
+            "run_id"
+          ],
+          "success_fields": [
+            "next_page_token"
+          ],
+          "rejection_fields": [
+            "workflow_id",
+            "run_id",
+            "reason",
+            "message",
+            "retryable",
+            "error_id",
+            "exception"
+          ],
+          "rejection_reasons": [
+            "control_plane_internal_error"
+          ]
+        },
+        "run_id": "{status-failed.run}",
+        "compatibility": null,
+        "next_page_token": null
+      }
+    }
+  },
+  "read_failed_export": {
+    "status": 200,
+    "response": {
+      "schema": "durable-workflow.v2.history-export",
+      "schema_version": 2,
+      "exported_at": "{exported_at}",
+      "dedupe_key": "{status-failed.run}:6:2026-09-30T07:03:30.000000Z",
+      "history_complete": true,
+      "workflow": {
+        "instance_id": "{status-failed.workflow}",
+        "run_id": "{status-failed.run}",
+        "run_number": 1,
+        "is_current_run": true,
+        "current_run_id": "{status-failed.run}",
+        "current_run_source": "run_order_fallback",
+        "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+        "workflow_class": "App\\Workflows\\Legacy\\OrderFulfillment",
+        "source_runtime": "standalone_server",
+        "source_process_class": "server_http_node",
+        "business_key": null,
+        "visibility_labels": [],
+        "memo": [],
+        "memo_payload": {
+          "codec": "avro",
+          "blob": "wwHioz3/VYAiNw4A"
+        },
+        "search_attributes": [],
+        "status": "failed",
+        "status_bucket": "failed",
+        "closed_reason": "failed",
+        "archived_at": null,
+        "archive_command_id": null,
+        "archive_reason": null,
+        "compatibility": null,
+        "connection": "redis",
+        "queue": "legacy-orders",
+        "last_history_sequence": 6,
+        "started_at": "2026-09-30T07:03:00.000000Z",
+        "closed_at": "2026-09-30T07:03:30.000000Z",
+        "last_progress_at": "2026-09-30T07:03:30.000000Z"
+      },
+      "payloads": {
+        "codec": "avro",
+        "arguments": {
+          "available": false,
+          "data": null
+        },
+        "output": {
+          "available": false,
+          "codec": null,
+          "data": null
+        }
+      },
+      "summary": {
+        "status": "failed",
+        "status_bucket": "failed",
+        "closed_reason": "failed",
+        "archived_at": null,
+        "archive_command_id": null,
+        "archive_reason": null,
+        "business_key": null,
+        "visibility_labels": [],
+        "search_attributes": [],
+        "is_current_run": true,
+        "started_at": "2026-09-30T07:03:00.000000Z",
+        "closed_at": "2026-09-30T07:03:30.000000Z",
+        "duration_ms": null,
+        "wait_kind": null,
+        "wait_reason": null,
+        "wait_started_at": null,
+        "wait_deadline_at": null,
+        "open_wait_id": null,
+        "resume_source_kind": null,
+        "resume_source_id": null,
+        "next_task_at": null,
+        "next_task_id": null,
+        "next_task_type": null,
+        "next_task_status": null,
+        "next_task_lease_expires_at": null,
+        "liveness_state": null,
+        "liveness_reason": null,
+        "repair_attention": false,
+        "task_problem": false,
+        "task_problem_badge": null,
+        "exception_count": 1,
+        "history_event_count": 6,
+        "history_size_bytes": 5425,
+        "history_fan_out": 0,
+        "continue_as_new_recommended": false,
+        "history_budget_pressure": "ok",
+        "sort_timestamp": "2026-09-30T07:03:30.000000Z",
+        "sort_key": null
+      },
+      "history_events": [
+        {
+          "id": "{status-failed.e1}",
+          "sequence": 1,
+          "type": "WorkflowStarted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T07:03:00.000000Z",
+          "payload": {
+            "migration_projection": {
+              "origin": {
+                "engine_source": "v1",
+                "engine_version": "1.0.68",
+                "execution_engine": "finish-on-v1"
+              },
+              "identity": {
+                "waterline": {
+                  "source_id": "pr1-waterline-import",
+                  "qualified_workflow_id": "v1:4303",
+                  "legacy_workflow_id": "4303"
+                },
+                "standalone": {
+                  "namespace": "pr1-waterline-import-wl1",
+                  "workflow_id": "{status-failed.workflow}",
+                  "run_id": "{status-failed.run}"
+                },
+                "relationship": "deterministic_source_qualified_projection",
+                "collision_policy": "reject_without_overwrite"
+              },
+              "task_queue_context": {
+                "connection": "redis",
+                "name": "legacy-orders",
+                "execution_owner": "v1",
+                "standalone_dispatch": "disabled"
+              },
+              "unsupported_fields": [
+                {
+                  "field": "runtime.replay",
+                  "reason": "v1_history_not_replayable_as_v2",
+                  "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                },
+                {
+                  "field": "timers",
+                  "reason": "legacy_timer_state_not_exposed_by_waterline",
+                  "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                },
+                {
+                  "field": "payloads.arguments",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.output",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.activity_results",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.signal_arguments",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.exception_values",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                }
+              ]
+            },
+            "legacy_payloads": {
+              "arguments": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "a:1:{i:0;s:7:\"order-7\";}",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{status-failed.e2}",
+          "sequence": 2,
+          "type": "ActivityCompleted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:02.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9001,
+              "legacy_index": 0
+            },
+            "activity": {
+              "class": "App\\Activities\\ReserveStock",
+              "logical_time": "2026-09-30T08:00:01.000000Z",
+              "result": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "b:1;",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{status-failed.e3}",
+          "sequence": 3,
+          "type": "SignalReceived",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:03.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_signal",
+              "legacy_id": 7001
+            },
+            "signal_name": "approve-λ",
+            "arguments": {
+              "available": true,
+              "encoding": "php-serialize",
+              "value": "a:1:{i:0;s:3:\"yes\";}",
+              "portable": false,
+              "unsupported_reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          }
+        },
+        {
+          "id": "{status-failed.e4}",
+          "sequence": 4,
+          "type": "ActivityFailed",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:04.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_exception",
+              "legacy_id": 5001
+            },
+            "exception": {
+              "class": "App\\Activities\\ChargeCard",
+              "value": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "O:9:\"Exception\":0:{}",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{status-failed.e5}",
+          "sequence": 5,
+          "type": "ActivityCompleted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:05.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9002,
+              "legacy_index": 1
+            },
+            "activity": {
+              "class": "App\\Activities\\ChargeCard",
+              "logical_time": "2026-09-30T08:00:04.500000Z",
+              "result": {
+                "available": false,
+                "encoding": "php-serialize",
+                "value": null,
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{status-failed.e6}",
+          "sequence": 6,
+          "type": "WorkflowFailed",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T07:03:30.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_status": "FAILED",
+              "execution_owner": "v1"
+            },
+            "legacy_payloads": {
+              "output": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "s:9:\"fulfilled\";",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        }
+      ],
+      "linked_intakes_scope": "selected_run",
+      "linked_intakes": [],
+      "commands": [],
+      "signals": [],
+      "updates": [],
+      "tasks": [],
+      "activities": [],
+      "timers": [],
+      "failures": [],
+      "links": {
+        "parents": [],
+        "children": []
+      },
+      "redaction": {
+        "applied": false,
+        "policy": null,
+        "paths": []
+      },
+      "codec_schemas": {
+        "avro": {
+          "encoding": "base64-avro-single-object",
+          "framing": "single_object",
+          "magic_hex": "c301",
+          "current_fingerprint": "e2a33dff55802237",
+          "writer_schemas": {
+            "e2a33dff55802237": {
+              "schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+              "fingerprint": "crc64-avro:e2a33dff55802237"
+            }
+          }
+        }
+      },
+      "payload_manifest": {
+        "version": 1,
+        "entries": [
+          {
+            "path": "workflow.memo_payload",
+            "codec": "avro",
+            "available": true,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": "single_object",
+            "avro_prefix_hex": "c301",
+            "writer_schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+            "writer_schema_fingerprint": "crc64-avro:e2a33dff55802237",
+            "diagnostic": null
+          },
+          {
+            "path": "payloads.arguments.data",
+            "codec": "avro",
+            "available": false,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": null,
+            "avro_prefix_hex": null,
+            "writer_schema": null,
+            "writer_schema_fingerprint": null,
+            "diagnostic": "payload_unavailable"
+          },
+          {
+            "path": "payloads.output.data",
+            "codec": "avro",
+            "available": false,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": null,
+            "avro_prefix_hex": null,
+            "writer_schema": null,
+            "writer_schema_fingerprint": null,
+            "diagnostic": "payload_unavailable"
+          }
+        ]
+      },
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.0.68",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4303",
+            "legacy_workflow_id": "4303"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{status-failed.workflow}",
+            "run_id": "{status-failed.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": "redis",
+          "name": "legacy-orders",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.output",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.signal_arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.exception_values",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{status-failed.dedupe}"
+        }
+      },
+      "integrity": {
+        "canonicalization": "json-recursive-ksort-v1",
+        "checksum_algorithm": "sha256",
+        "checksum": "{status-failed.export_checksum}",
+        "signature_algorithm": null,
+        "signature": null,
+        "key_id": null
+      },
+      "integrity_verified": true
+    }
+  },
+  "read_offsets_describe": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{offsets.workflow}",
+      "run_id": "{offsets.run}",
+      "namespace": "pr1-waterline-import-wl1",
+      "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+      "business_key": null,
+      "status": "completed",
+      "status_bucket": "completed",
+      "is_terminal": true,
+      "closed_reason": "completed",
+      "task_queue": "legacy-orders",
+      "run_number": 1,
+      "run_count": 1,
+      "is_current_run": true,
+      "continued_from_run_id": null,
+      "resume_step_sequence": null,
+      "recovery_kind": null,
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "payload_codec": null,
+      "definition_routing": null,
+      "execution_timeout_seconds": null,
+      "run_timeout_seconds": null,
+      "execution_deadline_at": null,
+      "run_deadline_at": null,
+      "input": null,
+      "output": null,
+      "input_envelope": null,
+      "output_envelope": null,
+      "payload_previews": {
+        "input_omitted": false,
+        "output_omitted": false,
+        "max_encoded_bytes": 2097152
+      },
+      "started_at": "2026-09-30T10:00:00.000000Z",
+      "closed_at": "2026-09-30T10:00:00.000000Z",
+      "last_progress_at": "2026-09-30T10:00:00.000000Z",
+      "wait_kind": null,
+      "wait_reason": null,
+      "memo": [],
+      "search_attributes": [],
+      "actions": {
+        "can_signal": false,
+        "can_query": false,
+        "can_update": false,
+        "can_cancel": false,
+        "can_terminate": false,
+        "can_repair": false,
+        "can_archive": false
+      },
+      "commands_scope": "selected_run",
+      "commands": [],
+      "updates_scope": "selected_run",
+      "updates": [],
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.0.68",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4401",
+            "legacy_workflow_id": "4401"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{offsets.workflow}",
+            "run_id": "{offsets.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": null,
+          "name": "legacy-orders",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.output",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.signal_arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.exception_values",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{offsets.dedupe}"
+        }
+      },
+      "action_blocked_reason": "v1_projection_read_only",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "describe",
+        "workflow_id": "{offsets.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": []
+        },
+        "run_id": "{offsets.run}",
+        "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+        "namespace": "pr1-waterline-import-wl1",
+        "business_key": null,
+        "status": "completed",
+        "status_bucket": "completed",
+        "is_terminal": true,
+        "task_queue": "legacy-orders",
+        "run_number": 1,
+        "run_count": 1,
+        "is_current_run": true,
+        "compatibility": null,
+        "started_at": "2026-09-30T10:00:00.000000Z",
+        "closed_at": "2026-09-30T10:00:00.000000Z",
+        "last_progress_at": "2026-09-30T10:00:00.000000Z",
+        "wait_kind": null,
+        "wait_reason": null
+      }
+    }
+  },
+  "read_offsets_run": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{offsets.workflow}",
+      "run_id": "{offsets.run}",
+      "namespace": "pr1-waterline-import-wl1",
+      "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+      "business_key": null,
+      "status": "completed",
+      "status_bucket": "completed",
+      "is_terminal": true,
+      "closed_reason": "completed",
+      "task_queue": "legacy-orders",
+      "run_number": 1,
+      "run_count": 1,
+      "is_current_run": true,
+      "continued_from_run_id": null,
+      "resume_step_sequence": null,
+      "recovery_kind": null,
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "payload_codec": null,
+      "definition_routing": null,
+      "execution_timeout_seconds": null,
+      "run_timeout_seconds": null,
+      "execution_deadline_at": null,
+      "run_deadline_at": null,
+      "input": null,
+      "output": null,
+      "input_envelope": null,
+      "output_envelope": null,
+      "payload_previews": {
+        "input_omitted": false,
+        "output_omitted": false,
+        "max_encoded_bytes": 2097152
+      },
+      "started_at": "2026-09-30T10:00:00.000000Z",
+      "closed_at": "2026-09-30T10:00:00.000000Z",
+      "last_progress_at": "2026-09-30T10:00:00.000000Z",
+      "wait_kind": null,
+      "wait_reason": null,
+      "memo": [],
+      "search_attributes": [],
+      "actions": {
+        "can_signal": false,
+        "can_query": false,
+        "can_update": false,
+        "can_cancel": false,
+        "can_terminate": false,
+        "can_repair": false,
+        "can_archive": false
+      },
+      "commands_scope": "selected_run",
+      "commands": [],
+      "updates_scope": "selected_run",
+      "updates": [],
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.0.68",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4401",
+            "legacy_workflow_id": "4401"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{offsets.workflow}",
+            "run_id": "{offsets.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": null,
+          "name": "legacy-orders",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.output",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.signal_arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.exception_values",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{offsets.dedupe}"
+        }
+      },
+      "action_blocked_reason": "v1_projection_read_only",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "describe_run",
+        "workflow_id": "{offsets.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": [
+            "run_id"
+          ],
+          "rejection_fields": [
+            "workflow_id",
+            "run_id",
+            "reason",
+            "message",
+            "retryable",
+            "error_id",
+            "exception"
+          ],
+          "rejection_reasons": [
+            "control_plane_internal_error"
+          ]
+        },
+        "run_id": "{offsets.run}",
+        "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+        "namespace": "pr1-waterline-import-wl1",
+        "business_key": null,
+        "status": "completed",
+        "status_bucket": "completed",
+        "is_terminal": true,
+        "task_queue": "legacy-orders",
+        "run_number": 1,
+        "run_count": 1,
+        "is_current_run": true,
+        "compatibility": null,
+        "started_at": "2026-09-30T10:00:00.000000Z",
+        "closed_at": "2026-09-30T10:00:00.000000Z",
+        "last_progress_at": "2026-09-30T10:00:00.000000Z",
+        "wait_kind": null,
+        "wait_reason": null
+      }
+    }
+  },
+  "read_offsets_runs": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{offsets.workflow}",
+      "run_count": 1,
+      "runs": [
+        {
+          "run_id": "{offsets.run}",
+          "run_number": 1,
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "completed",
+          "status_bucket": "completed",
+          "is_terminal": true,
+          "is_current_run": true,
+          "task_queue": "legacy-orders",
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": "2026-09-30T10:00:00.000000Z",
+          "closed_at": "2026-09-30T10:00:00.000000Z"
+        }
+      ],
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "list_runs",
+        "workflow_id": "{offsets.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": []
+        },
+        "run_count": 1
+      }
+    }
+  },
+  "read_offsets_history": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{offsets.workflow}",
+      "run_id": "{offsets.run}",
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "events": [
+        {
+          "sequence": 1,
+          "event_type": "WorkflowStarted",
+          "timestamp": "2026-09-30T08:00:00.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "origin": {
+                "engine_source": "v1",
+                "engine_version": "1.0.68",
+                "execution_engine": "finish-on-v1"
+              },
+              "identity": {
+                "waterline": {
+                  "source_id": "pr1-waterline-import",
+                  "qualified_workflow_id": "v1:4401",
+                  "legacy_workflow_id": "4401"
+                },
+                "standalone": {
+                  "namespace": "pr1-waterline-import-wl1",
+                  "workflow_id": "{offsets.workflow}",
+                  "run_id": "{offsets.run}"
+                },
+                "relationship": "deterministic_source_qualified_projection",
+                "collision_policy": "reject_without_overwrite"
+              },
+              "task_queue_context": {
+                "connection": null,
+                "name": "legacy-orders",
+                "execution_owner": "v1",
+                "standalone_dispatch": "disabled"
+              },
+              "unsupported_fields": [
+                {
+                  "field": "runtime.replay",
+                  "reason": "v1_history_not_replayable_as_v2",
+                  "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                },
+                {
+                  "field": "timers",
+                  "reason": "legacy_timer_state_not_exposed_by_waterline",
+                  "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                },
+                {
+                  "field": "payloads.output",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.activity_results",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.signal_arguments",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.exception_values",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                }
+              ]
+            },
+            "legacy_payloads": {
+              "arguments": {
+                "available": false,
+                "encoding": "php-serialize",
+                "value": null,
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 2,
+          "event_type": "ActivityCompleted",
+          "timestamp": null,
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9003,
+              "legacy_index": null
+            },
+            "activity": {
+              "class": "App\\Activities\\Untimed",
+              "logical_time": null,
+              "result": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": null,
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 3,
+          "event_type": "SignalReceived",
+          "timestamp": null,
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_signal",
+              "legacy_id": 7002
+            },
+            "signal_name": "named",
+            "arguments": {
+              "available": false,
+              "encoding": "php-serialize",
+              "value": null,
+              "portable": false,
+              "unsupported_reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          }
+        },
+        {
+          "sequence": 4,
+          "event_type": "SignalReceived",
+          "timestamp": "2026-09-30T08:00:00.500000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_signal",
+              "legacy_id": 7001
+            },
+            "signal_name": "approve-λ",
+            "arguments": {
+              "available": true,
+              "encoding": "php-serialize",
+              "value": "a:1:{i:0;s:3:\"yes\";}",
+              "portable": false,
+              "unsupported_reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          }
+        },
+        {
+          "sequence": 5,
+          "event_type": "ActivityCompleted",
+          "timestamp": "2026-09-30T08:00:02.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9001,
+              "legacy_index": 0
+            },
+            "activity": {
+              "class": "App\\Activities\\ReserveStock",
+              "logical_time": "2026-09-30T08:00:01.000000Z",
+              "result": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "b:1;",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 6,
+          "event_type": "ActivityFailed",
+          "timestamp": "2026-09-30T08:00:04.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_exception",
+              "legacy_id": 5001
+            },
+            "exception": {
+              "value": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "O:9:\"Exception\":0:{}",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 7,
+          "event_type": "ActivityCompleted",
+          "timestamp": "2026-09-30T08:00:05.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9002,
+              "legacy_index": 1
+            },
+            "activity": {
+              "class": "App\\Activities\\ChargeCard",
+              "logical_time": "2026-09-30T08:00:04.500000Z",
+              "result": {
+                "available": false,
+                "encoding": "php-serialize",
+                "value": null,
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 8,
+          "event_type": "WorkflowCompleted",
+          "timestamp": "2026-09-30T08:00:00.000000Z",
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_status": "completed",
+              "execution_owner": "v1"
+            },
+            "legacy_payloads": {
+              "output": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "s:9:\"fulfilled\";",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        }
+      ],
+      "next_page_token": null,
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.0.68",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4401",
+            "legacy_workflow_id": "4401"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{offsets.workflow}",
+            "run_id": "{offsets.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": null,
+          "name": "legacy-orders",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.output",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.signal_arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.exception_values",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{offsets.dedupe}"
+        }
+      },
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "history",
+        "workflow_id": "{offsets.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id",
+            "run_id"
+          ],
+          "success_fields": [
+            "next_page_token"
+          ],
+          "rejection_fields": [
+            "workflow_id",
+            "run_id",
+            "reason",
+            "message",
+            "retryable",
+            "error_id",
+            "exception"
+          ],
+          "rejection_reasons": [
+            "control_plane_internal_error"
+          ]
+        },
+        "run_id": "{offsets.run}",
+        "compatibility": null,
+        "next_page_token": null
+      }
+    }
+  },
+  "read_offsets_export": {
+    "status": 200,
+    "response": {
+      "schema": "durable-workflow.v2.history-export",
+      "schema_version": 2,
+      "exported_at": "{exported_at}",
+      "dedupe_key": "{offsets.run}:8:2026-09-30T10:00:00.000000Z",
+      "history_complete": true,
+      "workflow": {
+        "instance_id": "{offsets.workflow}",
+        "run_id": "{offsets.run}",
+        "run_number": 1,
+        "is_current_run": true,
+        "current_run_id": "{offsets.run}",
+        "current_run_source": "run_order_fallback",
+        "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+        "workflow_class": "App\\Workflows\\Legacy\\OrderFulfillment",
+        "source_runtime": "standalone_server",
+        "source_process_class": "server_http_node",
+        "business_key": null,
+        "visibility_labels": [],
+        "memo": [],
+        "memo_payload": {
+          "codec": "avro",
+          "blob": "wwHioz3/VYAiNw4A"
+        },
+        "search_attributes": [],
+        "status": "completed",
+        "status_bucket": "completed",
+        "closed_reason": "completed",
+        "archived_at": null,
+        "archive_command_id": null,
+        "archive_reason": null,
+        "compatibility": null,
+        "connection": null,
+        "queue": "legacy-orders",
+        "last_history_sequence": 8,
+        "started_at": "2026-09-30T10:00:00.000000Z",
+        "closed_at": "2026-09-30T10:00:00.000000Z",
+        "last_progress_at": "2026-09-30T10:00:00.000000Z"
+      },
+      "payloads": {
+        "codec": "avro",
+        "arguments": {
+          "available": false,
+          "data": null
+        },
+        "output": {
+          "available": false,
+          "codec": null,
+          "data": null
+        }
+      },
+      "summary": {
+        "status": "completed",
+        "status_bucket": "completed",
+        "closed_reason": "completed",
+        "archived_at": null,
+        "archive_command_id": null,
+        "archive_reason": null,
+        "business_key": null,
+        "visibility_labels": [],
+        "search_attributes": [],
+        "is_current_run": true,
+        "started_at": "2026-09-30T10:00:00.000000Z",
+        "closed_at": "2026-09-30T10:00:00.000000Z",
+        "duration_ms": null,
+        "wait_kind": null,
+        "wait_reason": null,
+        "wait_started_at": null,
+        "wait_deadline_at": null,
+        "open_wait_id": null,
+        "resume_source_kind": null,
+        "resume_source_id": null,
+        "next_task_at": null,
+        "next_task_id": null,
+        "next_task_type": null,
+        "next_task_status": null,
+        "next_task_lease_expires_at": null,
+        "liveness_state": null,
+        "liveness_reason": null,
+        "repair_attention": false,
+        "task_problem": false,
+        "task_problem_badge": null,
+        "exception_count": 1,
+        "history_event_count": 8,
+        "history_size_bytes": 6242,
+        "history_fan_out": 0,
+        "continue_as_new_recommended": false,
+        "history_budget_pressure": "ok",
+        "sort_timestamp": "2026-09-30T10:00:00.000000Z",
+        "sort_key": null
+      },
+      "history_events": [
+        {
+          "id": "{offsets.e1}",
+          "sequence": 1,
+          "type": "WorkflowStarted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:00.000000Z",
+          "payload": {
+            "migration_projection": {
+              "origin": {
+                "engine_source": "v1",
+                "engine_version": "1.0.68",
+                "execution_engine": "finish-on-v1"
+              },
+              "identity": {
+                "waterline": {
+                  "source_id": "pr1-waterline-import",
+                  "qualified_workflow_id": "v1:4401",
+                  "legacy_workflow_id": "4401"
+                },
+                "standalone": {
+                  "namespace": "pr1-waterline-import-wl1",
+                  "workflow_id": "{offsets.workflow}",
+                  "run_id": "{offsets.run}"
+                },
+                "relationship": "deterministic_source_qualified_projection",
+                "collision_policy": "reject_without_overwrite"
+              },
+              "task_queue_context": {
+                "connection": null,
+                "name": "legacy-orders",
+                "execution_owner": "v1",
+                "standalone_dispatch": "disabled"
+              },
+              "unsupported_fields": [
+                {
+                  "field": "runtime.replay",
+                  "reason": "v1_history_not_replayable_as_v2",
+                  "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                },
+                {
+                  "field": "timers",
+                  "reason": "legacy_timer_state_not_exposed_by_waterline",
+                  "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                },
+                {
+                  "field": "payloads.output",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.activity_results",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.signal_arguments",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                },
+                {
+                  "field": "payloads.exception_values",
+                  "reason": "legacy_php_serialization_not_portable",
+                  "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+                }
+              ]
+            },
+            "legacy_payloads": {
+              "arguments": {
+                "available": false,
+                "encoding": "php-serialize",
+                "value": null,
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{offsets.e2}",
+          "sequence": 2,
+          "type": "ActivityCompleted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9003,
+              "legacy_index": null
+            },
+            "activity": {
+              "class": "App\\Activities\\Untimed",
+              "logical_time": null,
+              "result": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": null,
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{offsets.e3}",
+          "sequence": 3,
+          "type": "SignalReceived",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": null,
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_signal",
+              "legacy_id": 7002
+            },
+            "signal_name": "named",
+            "arguments": {
+              "available": false,
+              "encoding": "php-serialize",
+              "value": null,
+              "portable": false,
+              "unsupported_reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          }
+        },
+        {
+          "id": "{offsets.e4}",
+          "sequence": 4,
+          "type": "SignalReceived",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:00.500000Z",
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_signal",
+              "legacy_id": 7001
+            },
+            "signal_name": "approve-λ",
+            "arguments": {
+              "available": true,
+              "encoding": "php-serialize",
+              "value": "a:1:{i:0;s:3:\"yes\";}",
+              "portable": false,
+              "unsupported_reason": "legacy_php_serialization_not_portable",
+              "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+            }
+          }
+        },
+        {
+          "id": "{offsets.e5}",
+          "sequence": 5,
+          "type": "ActivityCompleted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:02.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9001,
+              "legacy_index": 0
+            },
+            "activity": {
+              "class": "App\\Activities\\ReserveStock",
+              "logical_time": "2026-09-30T08:00:01.000000Z",
+              "result": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "b:1;",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{offsets.e6}",
+          "sequence": 6,
+          "type": "ActivityFailed",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:04.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_exception",
+              "legacy_id": 5001
+            },
+            "exception": {
+              "class": "App\\Activities\\ChargeCard",
+              "value": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "O:9:\"Exception\":0:{}",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{offsets.e7}",
+          "sequence": 7,
+          "type": "ActivityCompleted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:05.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_record": "workflow_log",
+              "legacy_id": 9002,
+              "legacy_index": 1
+            },
+            "activity": {
+              "class": "App\\Activities\\ChargeCard",
+              "logical_time": "2026-09-30T08:00:04.500000Z",
+              "result": {
+                "available": false,
+                "encoding": "php-serialize",
+                "value": null,
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{offsets.e8}",
+          "sequence": 8,
+          "type": "WorkflowCompleted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": "2026-09-30T08:00:00.000000Z",
+          "payload": {
+            "migration_projection": {
+              "source_status": "completed",
+              "execution_owner": "v1"
+            },
+            "legacy_payloads": {
+              "output": {
+                "available": true,
+                "encoding": "php-serialize",
+                "value": "s:9:\"fulfilled\";",
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        }
+      ],
+      "linked_intakes_scope": "selected_run",
+      "linked_intakes": [],
+      "commands": [],
+      "signals": [],
+      "updates": [],
+      "tasks": [],
+      "activities": [],
+      "timers": [],
+      "failures": [],
+      "links": {
+        "parents": [],
+        "children": []
+      },
+      "redaction": {
+        "applied": false,
+        "policy": null,
+        "paths": []
+      },
+      "codec_schemas": {
+        "avro": {
+          "encoding": "base64-avro-single-object",
+          "framing": "single_object",
+          "magic_hex": "c301",
+          "current_fingerprint": "e2a33dff55802237",
+          "writer_schemas": {
+            "e2a33dff55802237": {
+              "schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+              "fingerprint": "crc64-avro:e2a33dff55802237"
+            }
+          }
+        }
+      },
+      "payload_manifest": {
+        "version": 1,
+        "entries": [
+          {
+            "path": "workflow.memo_payload",
+            "codec": "avro",
+            "available": true,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": "single_object",
+            "avro_prefix_hex": "c301",
+            "writer_schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+            "writer_schema_fingerprint": "crc64-avro:e2a33dff55802237",
+            "diagnostic": null
+          },
+          {
+            "path": "payloads.arguments.data",
+            "codec": "avro",
+            "available": false,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": null,
+            "avro_prefix_hex": null,
+            "writer_schema": null,
+            "writer_schema_fingerprint": null,
+            "diagnostic": "payload_unavailable"
+          },
+          {
+            "path": "payloads.output.data",
+            "codec": "avro",
+            "available": false,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": null,
+            "avro_prefix_hex": null,
+            "writer_schema": null,
+            "writer_schema_fingerprint": null,
+            "diagnostic": "payload_unavailable"
+          },
+          {
+            "path": "history_events.7.payload.output",
+            "codec": "avro",
+            "available": false,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": null,
+            "avro_prefix_hex": null,
+            "writer_schema": null,
+            "writer_schema_fingerprint": null,
+            "diagnostic": "payload_unavailable"
+          }
+        ]
+      },
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.0.68",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4401",
+            "legacy_workflow_id": "4401"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{offsets.workflow}",
+            "run_id": "{offsets.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": null,
+          "name": "legacy-orders",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.output",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.signal_arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.exception_values",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{offsets.dedupe}"
+        }
+      },
+      "integrity": {
+        "canonicalization": "json-recursive-ksort-v1",
+        "checksum_algorithm": "sha256",
+        "checksum": "{offsets.export_checksum}",
+        "signature_algorithm": null,
+        "signature": null,
+        "key_id": null
+      },
+      "integrity_verified": true
+    }
+  },
+  "read_bare_describe": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{bare.workflow}",
+      "run_id": "{bare.run}",
+      "namespace": "pr1-waterline-import-wl1",
+      "workflow_type": "App\\Workflows\\Legacy\\Bare",
+      "business_key": null,
+      "status": "completed",
+      "status_bucket": "completed",
+      "is_terminal": true,
+      "closed_reason": "completed",
+      "task_queue": null,
+      "run_number": 1,
+      "run_count": 1,
+      "is_current_run": true,
+      "continued_from_run_id": null,
+      "resume_step_sequence": null,
+      "recovery_kind": null,
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "payload_codec": null,
+      "definition_routing": null,
+      "execution_timeout_seconds": null,
+      "run_timeout_seconds": null,
+      "execution_deadline_at": null,
+      "run_deadline_at": null,
+      "input": null,
+      "output": null,
+      "input_envelope": null,
+      "output_envelope": null,
+      "payload_previews": {
+        "input_omitted": false,
+        "output_omitted": false,
+        "max_encoded_bytes": 2097152
+      },
+      "started_at": null,
+      "closed_at": null,
+      "last_progress_at": null,
+      "wait_kind": null,
+      "wait_reason": null,
+      "memo": [],
+      "search_attributes": [],
+      "actions": {
+        "can_signal": false,
+        "can_query": false,
+        "can_update": false,
+        "can_cancel": false,
+        "can_terminate": false,
+        "can_repair": false,
+        "can_archive": false
+      },
+      "commands_scope": "selected_run",
+      "commands": [],
+      "updates_scope": "selected_run",
+      "updates": [],
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.x",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4501",
+            "legacy_workflow_id": "4501"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{bare.workflow}",
+            "run_id": "{bare.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": null,
+          "name": null,
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{bare.dedupe}"
+        }
+      },
+      "action_blocked_reason": "v1_projection_read_only",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "describe",
+        "workflow_id": "{bare.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": []
+        },
+        "run_id": "{bare.run}",
+        "workflow_type": "App\\Workflows\\Legacy\\Bare",
+        "namespace": "pr1-waterline-import-wl1",
+        "business_key": null,
+        "status": "completed",
+        "status_bucket": "completed",
+        "is_terminal": true,
+        "task_queue": null,
+        "run_number": 1,
+        "run_count": 1,
+        "is_current_run": true,
+        "compatibility": null,
+        "started_at": null,
+        "closed_at": null,
+        "last_progress_at": null,
+        "wait_kind": null,
+        "wait_reason": null
+      }
+    }
+  },
+  "read_bare_run": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{bare.workflow}",
+      "run_id": "{bare.run}",
+      "namespace": "pr1-waterline-import-wl1",
+      "workflow_type": "App\\Workflows\\Legacy\\Bare",
+      "business_key": null,
+      "status": "completed",
+      "status_bucket": "completed",
+      "is_terminal": true,
+      "closed_reason": "completed",
+      "task_queue": null,
+      "run_number": 1,
+      "run_count": 1,
+      "is_current_run": true,
+      "continued_from_run_id": null,
+      "resume_step_sequence": null,
+      "recovery_kind": null,
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "payload_codec": null,
+      "definition_routing": null,
+      "execution_timeout_seconds": null,
+      "run_timeout_seconds": null,
+      "execution_deadline_at": null,
+      "run_deadline_at": null,
+      "input": null,
+      "output": null,
+      "input_envelope": null,
+      "output_envelope": null,
+      "payload_previews": {
+        "input_omitted": false,
+        "output_omitted": false,
+        "max_encoded_bytes": 2097152
+      },
+      "started_at": null,
+      "closed_at": null,
+      "last_progress_at": null,
+      "wait_kind": null,
+      "wait_reason": null,
+      "memo": [],
+      "search_attributes": [],
+      "actions": {
+        "can_signal": false,
+        "can_query": false,
+        "can_update": false,
+        "can_cancel": false,
+        "can_terminate": false,
+        "can_repair": false,
+        "can_archive": false
+      },
+      "commands_scope": "selected_run",
+      "commands": [],
+      "updates_scope": "selected_run",
+      "updates": [],
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.x",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4501",
+            "legacy_workflow_id": "4501"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{bare.workflow}",
+            "run_id": "{bare.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": null,
+          "name": null,
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{bare.dedupe}"
+        }
+      },
+      "action_blocked_reason": "v1_projection_read_only",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "describe_run",
+        "workflow_id": "{bare.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": [
+            "run_id"
+          ],
+          "rejection_fields": [
+            "workflow_id",
+            "run_id",
+            "reason",
+            "message",
+            "retryable",
+            "error_id",
+            "exception"
+          ],
+          "rejection_reasons": [
+            "control_plane_internal_error"
+          ]
+        },
+        "run_id": "{bare.run}",
+        "workflow_type": "App\\Workflows\\Legacy\\Bare",
+        "namespace": "pr1-waterline-import-wl1",
+        "business_key": null,
+        "status": "completed",
+        "status_bucket": "completed",
+        "is_terminal": true,
+        "task_queue": null,
+        "run_number": 1,
+        "run_count": 1,
+        "is_current_run": true,
+        "compatibility": null,
+        "started_at": null,
+        "closed_at": null,
+        "last_progress_at": null,
+        "wait_kind": null,
+        "wait_reason": null
+      }
+    }
+  },
+  "read_bare_runs": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{bare.workflow}",
+      "run_count": 1,
+      "runs": [
+        {
+          "run_id": "{bare.run}",
+          "run_number": 1,
+          "workflow_type": "App\\Workflows\\Legacy\\Bare",
+          "business_key": null,
+          "status": "completed",
+          "status_bucket": "completed",
+          "is_terminal": true,
+          "is_current_run": true,
+          "task_queue": null,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": null,
+          "closed_at": null
+        }
+      ],
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "list_runs",
+        "workflow_id": "{bare.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": []
+        },
+        "run_count": 1
+      }
+    }
+  },
+  "read_bare_history": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{bare.workflow}",
+      "run_id": "{bare.run}",
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "events": [
+        {
+          "sequence": 1,
+          "event_type": "WorkflowStarted",
+          "timestamp": null,
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "origin": {
+                "engine_source": "v1",
+                "engine_version": "1.x",
+                "execution_engine": "finish-on-v1"
+              },
+              "identity": {
+                "waterline": {
+                  "source_id": "pr1-waterline-import",
+                  "qualified_workflow_id": "v1:4501",
+                  "legacy_workflow_id": "4501"
+                },
+                "standalone": {
+                  "namespace": "pr1-waterline-import-wl1",
+                  "workflow_id": "{bare.workflow}",
+                  "run_id": "{bare.run}"
+                },
+                "relationship": "deterministic_source_qualified_projection",
+                "collision_policy": "reject_without_overwrite"
+              },
+              "task_queue_context": {
+                "connection": null,
+                "name": null,
+                "execution_owner": "v1",
+                "standalone_dispatch": "disabled"
+              },
+              "unsupported_fields": [
+                {
+                  "field": "runtime.replay",
+                  "reason": "v1_history_not_replayable_as_v2",
+                  "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                },
+                {
+                  "field": "timers",
+                  "reason": "legacy_timer_state_not_exposed_by_waterline",
+                  "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                }
+              ]
+            },
+            "legacy_payloads": {
+              "arguments": {
+                "available": false,
+                "encoding": "php-serialize",
+                "value": null,
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "sequence": 2,
+          "event_type": "WorkflowCompleted",
+          "timestamp": null,
+          "principal": null,
+          "payload": {
+            "migration_projection": {
+              "source_status": "completed",
+              "execution_owner": "v1"
+            },
+            "legacy_payloads": {
+              "output": {
+                "available": false,
+                "encoding": "php-serialize",
+                "value": null,
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        }
+      ],
+      "next_page_token": null,
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.x",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4501",
+            "legacy_workflow_id": "4501"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{bare.workflow}",
+            "run_id": "{bare.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": null,
+          "name": null,
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{bare.dedupe}"
+        }
+      },
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "history",
+        "workflow_id": "{bare.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id",
+            "run_id"
+          ],
+          "success_fields": [
+            "next_page_token"
+          ],
+          "rejection_fields": [
+            "workflow_id",
+            "run_id",
+            "reason",
+            "message",
+            "retryable",
+            "error_id",
+            "exception"
+          ],
+          "rejection_reasons": [
+            "control_plane_internal_error"
+          ]
+        },
+        "run_id": "{bare.run}",
+        "compatibility": null,
+        "next_page_token": null
+      }
+    }
+  },
+  "read_bare_export": {
+    "status": 200,
+    "response": {
+      "schema": "durable-workflow.v2.history-export",
+      "schema_version": 2,
+      "exported_at": "{exported_at}",
+      "dedupe_key": "{bare.run}:2:{bare.imported_at}",
+      "history_complete": true,
+      "workflow": {
+        "instance_id": "{bare.workflow}",
+        "run_id": "{bare.run}",
+        "run_number": 1,
+        "is_current_run": true,
+        "current_run_id": "{bare.run}",
+        "current_run_source": "run_order_fallback",
+        "workflow_type": "App\\Workflows\\Legacy\\Bare",
+        "workflow_class": "App\\Workflows\\Legacy\\Bare",
+        "source_runtime": "standalone_server",
+        "source_process_class": "server_http_node",
+        "business_key": null,
+        "visibility_labels": [],
+        "memo": [],
+        "memo_payload": {
+          "codec": "avro",
+          "blob": "wwHioz3/VYAiNw4A"
+        },
+        "search_attributes": [],
+        "status": "completed",
+        "status_bucket": "completed",
+        "closed_reason": "completed",
+        "archived_at": null,
+        "archive_command_id": null,
+        "archive_reason": null,
+        "compatibility": null,
+        "connection": null,
+        "queue": null,
+        "last_history_sequence": 2,
+        "started_at": null,
+        "closed_at": null,
+        "last_progress_at": null
+      },
+      "payloads": {
+        "codec": "avro",
+        "arguments": {
+          "available": false,
+          "data": null
+        },
+        "output": {
+          "available": false,
+          "codec": null,
+          "data": null
+        }
+      },
+      "summary": {
+        "status": "completed",
+        "status_bucket": "completed",
+        "closed_reason": "completed",
+        "archived_at": null,
+        "archive_command_id": null,
+        "archive_reason": null,
+        "business_key": null,
+        "visibility_labels": [],
+        "search_attributes": [],
+        "is_current_run": true,
+        "started_at": null,
+        "closed_at": null,
+        "duration_ms": null,
+        "wait_kind": null,
+        "wait_reason": null,
+        "wait_started_at": null,
+        "wait_deadline_at": null,
+        "open_wait_id": null,
+        "resume_source_kind": null,
+        "resume_source_id": null,
+        "next_task_at": null,
+        "next_task_id": null,
+        "next_task_type": null,
+        "next_task_status": null,
+        "next_task_lease_expires_at": null,
+        "liveness_state": null,
+        "liveness_reason": null,
+        "repair_attention": false,
+        "task_problem": false,
+        "task_problem_badge": null,
+        "exception_count": 0,
+        "history_event_count": 2,
+        "history_size_bytes": 1856,
+        "history_fan_out": 0,
+        "continue_as_new_recommended": false,
+        "history_budget_pressure": "ok",
+        "sort_timestamp": "{bare.imported_at}",
+        "sort_key": null
+      },
+      "history_events": [
+        {
+          "id": "{bare.e1}",
+          "sequence": 1,
+          "type": "WorkflowStarted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": null,
+          "payload": {
+            "migration_projection": {
+              "origin": {
+                "engine_source": "v1",
+                "engine_version": "1.x",
+                "execution_engine": "finish-on-v1"
+              },
+              "identity": {
+                "waterline": {
+                  "source_id": "pr1-waterline-import",
+                  "qualified_workflow_id": "v1:4501",
+                  "legacy_workflow_id": "4501"
+                },
+                "standalone": {
+                  "namespace": "pr1-waterline-import-wl1",
+                  "workflow_id": "{bare.workflow}",
+                  "run_id": "{bare.run}"
+                },
+                "relationship": "deterministic_source_qualified_projection",
+                "collision_policy": "reject_without_overwrite"
+              },
+              "task_queue_context": {
+                "connection": null,
+                "name": null,
+                "execution_owner": "v1",
+                "standalone_dispatch": "disabled"
+              },
+              "unsupported_fields": [
+                {
+                  "field": "runtime.replay",
+                  "reason": "v1_history_not_replayable_as_v2",
+                  "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+                },
+                {
+                  "field": "timers",
+                  "reason": "legacy_timer_state_not_exposed_by_waterline",
+                  "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+                }
+              ]
+            },
+            "legacy_payloads": {
+              "arguments": {
+                "available": false,
+                "encoding": "php-serialize",
+                "value": null,
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        },
+        {
+          "id": "{bare.e2}",
+          "sequence": 2,
+          "type": "WorkflowCompleted",
+          "workflow_task_id": null,
+          "workflow_command_id": null,
+          "recorded_at": null,
+          "payload": {
+            "migration_projection": {
+              "source_status": "completed",
+              "execution_owner": "v1"
+            },
+            "legacy_payloads": {
+              "output": {
+                "available": false,
+                "encoding": "php-serialize",
+                "value": null,
+                "portable": false,
+                "unsupported_reason": "legacy_php_serialization_not_portable",
+                "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+              }
+            }
+          }
+        }
+      ],
+      "linked_intakes_scope": "selected_run",
+      "linked_intakes": [],
+      "commands": [],
+      "signals": [],
+      "updates": [],
+      "tasks": [],
+      "activities": [],
+      "timers": [],
+      "failures": [],
+      "links": {
+        "parents": [],
+        "children": []
+      },
+      "redaction": {
+        "applied": false,
+        "policy": null,
+        "paths": []
+      },
+      "codec_schemas": {
+        "avro": {
+          "encoding": "base64-avro-single-object",
+          "framing": "single_object",
+          "magic_hex": "c301",
+          "current_fingerprint": "e2a33dff55802237",
+          "writer_schemas": {
+            "e2a33dff55802237": {
+              "schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+              "fingerprint": "crc64-avro:e2a33dff55802237"
+            }
+          }
+        }
+      },
+      "payload_manifest": {
+        "version": 1,
+        "entries": [
+          {
+            "path": "workflow.memo_payload",
+            "codec": "avro",
+            "available": true,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": "single_object",
+            "avro_prefix_hex": "c301",
+            "writer_schema": "{\"type\":\"record\",\"name\":\"Value\",\"namespace\":\"durable_workflow.protocol\",\"fields\":[{\"name\":\"value\",\"type\":[\"null\",{\"type\":\"record\",\"name\":\"BooleanValue\",\"fields\":[{\"name\":\"boolean\",\"type\":\"boolean\"}]},{\"type\":\"record\",\"name\":\"LongValue\",\"fields\":[{\"name\":\"long\",\"type\":\"long\"}]},{\"type\":\"record\",\"name\":\"DoubleValue\",\"fields\":[{\"name\":\"double\",\"type\":\"double\"}]},{\"type\":\"record\",\"name\":\"BytesValue\",\"fields\":[{\"name\":\"bytes\",\"type\":\"bytes\"}]},{\"type\":\"record\",\"name\":\"StringValue\",\"fields\":[{\"name\":\"string\",\"type\":\"string\"}]},{\"type\":\"record\",\"name\":\"ArrayValue\",\"fields\":[{\"name\":\"items\",\"type\":{\"type\":\"array\",\"items\":\"Value\"}}]},{\"type\":\"record\",\"name\":\"MapValue\",\"fields\":[{\"name\":\"entries\",\"type\":{\"type\":\"map\",\"values\":\"Value\"}}]}]}]}",
+            "writer_schema_fingerprint": "crc64-avro:e2a33dff55802237",
+            "diagnostic": null
+          },
+          {
+            "path": "payloads.arguments.data",
+            "codec": "avro",
+            "available": false,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": null,
+            "avro_prefix_hex": null,
+            "writer_schema": null,
+            "writer_schema_fingerprint": null,
+            "diagnostic": "payload_unavailable"
+          },
+          {
+            "path": "payloads.output.data",
+            "codec": "avro",
+            "available": false,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": null,
+            "avro_prefix_hex": null,
+            "writer_schema": null,
+            "writer_schema_fingerprint": null,
+            "diagnostic": "payload_unavailable"
+          },
+          {
+            "path": "history_events.1.payload.output",
+            "codec": "avro",
+            "available": false,
+            "redacted": false,
+            "encoding": "base64-avro-single-object",
+            "avro_framing": null,
+            "avro_prefix_hex": null,
+            "writer_schema": null,
+            "writer_schema_fingerprint": null,
+            "diagnostic": "payload_unavailable"
+          }
+        ]
+      },
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.x",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4501",
+            "legacy_workflow_id": "4501"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{bare.workflow}",
+            "run_id": "{bare.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": null,
+          "name": null,
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{bare.dedupe}"
+        }
+      },
+      "integrity": {
+        "canonicalization": "json-recursive-ksort-v1",
+        "checksum_algorithm": "sha256",
+        "checksum": "{bare.export_checksum}",
+        "signature_algorithm": null,
+        "signature": null,
+        "key_id": null
+      },
+      "integrity_verified": true
+    }
+  },
+  "read_list": {
+    "status": 200,
+    "response": {
+      "workflows": [
+        {
+          "workflow_id": "{bare.workflow}",
+          "run_id": "{bare.run}",
+          "workflow_type": "App\\Workflows\\Legacy\\Bare",
+          "business_key": null,
+          "status": "completed",
+          "status_bucket": "completed",
+          "task_queue": null,
+          "is_terminal": true,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": null,
+          "closed_at": null,
+          "search_attributes": []
+        },
+        {
+          "workflow_id": "{offsets.workflow}",
+          "run_id": "{offsets.run}",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "completed",
+          "status_bucket": "completed",
+          "task_queue": "legacy-orders",
+          "is_terminal": true,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": "2026-09-30T10:00:00.000000Z",
+          "closed_at": "2026-09-30T10:00:00.000000Z",
+          "search_attributes": []
+        },
+        {
+          "workflow_id": "{running.workflow}",
+          "run_id": "{running.run}",
+          "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+          "business_key": null,
+          "status": "running",
+          "status_bucket": "running",
+          "task_queue": "legacy-billing",
+          "is_terminal": false,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": "2026-09-30T09:00:00.000000Z",
+          "closed_at": null,
+          "search_attributes": []
+        },
+        {
+          "workflow_id": "{completed.workflow}",
+          "run_id": "{completed.run}",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "completed",
+          "status_bucket": "completed",
+          "task_queue": "legacy-orders",
+          "is_terminal": true,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": "2026-09-30T08:00:00.000000Z",
+          "closed_at": "2026-09-30T08:00:06.000000Z",
+          "search_attributes": []
+        },
+        {
+          "workflow_id": "{status-continued.workflow}",
+          "run_id": "{status-continued.run}",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "completed",
+          "status_bucket": "completed",
+          "task_queue": "legacy-orders",
+          "is_terminal": true,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": "2026-09-30T07:06:00.000000Z",
+          "closed_at": "2026-09-30T07:06:30.000000Z",
+          "search_attributes": []
+        },
+        {
+          "workflow_id": "{status-terminated.workflow}",
+          "run_id": "{status-terminated.run}",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "terminated",
+          "status_bucket": "failed",
+          "task_queue": "legacy-orders",
+          "is_terminal": true,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": "2026-09-30T07:05:00.000000Z",
+          "closed_at": "2026-09-30T07:05:30.000000Z",
+          "search_attributes": []
+        },
+        {
+          "workflow_id": "{status-cancelled.workflow}",
+          "run_id": "{status-cancelled.run}",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "cancelled",
+          "status_bucket": "failed",
+          "task_queue": "legacy-orders",
+          "is_terminal": true,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": "2026-09-30T07:04:00.000000Z",
+          "closed_at": "2026-09-30T07:04:30.000000Z",
+          "search_attributes": []
+        },
+        {
+          "workflow_id": "{status-failed.workflow}",
+          "run_id": "{status-failed.run}",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "failed",
+          "status_bucket": "failed",
+          "task_queue": "legacy-orders",
+          "is_terminal": true,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": "2026-09-30T07:03:00.000000Z",
+          "closed_at": "2026-09-30T07:03:30.000000Z",
+          "search_attributes": []
+        },
+        {
+          "workflow_id": "{status-waiting.workflow}",
+          "run_id": "{status-waiting.run}",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "waiting",
+          "status_bucket": "running",
+          "task_queue": "legacy-orders",
+          "is_terminal": false,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": "2026-09-30T07:02:00.000000Z",
+          "closed_at": null,
+          "search_attributes": []
+        },
+        {
+          "workflow_id": "{status-pending.workflow}",
+          "run_id": "{status-pending.run}",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "pending",
+          "status_bucket": "running",
+          "task_queue": "legacy-orders",
+          "is_terminal": false,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": "2026-09-30T07:01:00.000000Z",
+          "closed_at": null,
+          "search_attributes": []
+        },
+        {
+          "workflow_id": "{status-created.workflow}",
+          "run_id": "{status-created.run}",
+          "workflow_type": "App\\Workflows\\Legacy\\OrderFulfillment",
+          "business_key": null,
+          "status": "pending",
+          "status_bucket": "running",
+          "task_queue": "legacy-orders",
+          "is_terminal": false,
+          "compatibility": null,
+          "compatibility_status": "compatible",
+          "compatibility_supported_in_fleet": true,
+          "compatibility_fleet_reason": null,
+          "started_at": "2026-09-30T07:00:00.000000Z",
+          "closed_at": null,
+          "search_attributes": []
+        }
+      ],
+      "workflow_count": 11,
+      "next_page_token": null,
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "list",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": []
+        },
+        "workflow_count": 11,
+        "next_page_token": null
+      }
+    }
+  },
+  "read_list_alt": {
+    "status": 200,
+    "response": {
+      "workflows": [],
+      "workflow_count": 0,
+      "next_page_token": null,
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "list",
+        "workflow_id": null,
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [],
+          "success_fields": []
+        },
+        "workflow_count": 0,
+        "next_page_token": null
+      }
+    }
+  },
+  "refuse_running": {
+    "signal": {
+      "status": 409,
+      "response": {
+        "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{running.workflow}",
+        "run_id": "{running.run}",
+        "operation": "signal",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "signal",
+          "workflow_id": "{running.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id",
+              "operation_name",
+              "operation_name_field"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "signal_name",
+              "command_status",
+              "command_source",
+              "target_scope",
+              "outcome",
+              "reason",
+              "rejection_reason",
+              "rejection_category",
+              "message",
+              "command_contract_source",
+              "command_contract_backfill_needed",
+              "command_contract_backfill_available",
+              "declared_signals",
+              "signal_admission",
+              "retryable",
+              "error_id"
+            ],
+            "rejection_reasons": [
+              "instance_not_found",
+              "historical_run_command_rejected",
+              "unknown_signal",
+              "invalid_signal_arguments",
+              "run_not_active",
+              "instance_not_started",
+              "selected_run_not_current",
+              "configured_workflow_type_invalid",
+              "v1_projection_read_only",
+              "backend_lock_pressure",
+              "control_plane_internal_error"
+            ]
+          },
+          "operation_name": "approve",
+          "operation_name_field": "signal_name",
+          "run_id": "{running.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "run_signal": {
+      "status": 409,
+      "response": {
+        "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{running.workflow}",
+        "run_id": "{running.run}",
+        "operation": "signal",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "signal",
+          "workflow_id": "{running.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id",
+              "operation_name",
+              "operation_name_field"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "signal_name",
+              "command_status",
+              "command_source",
+              "target_scope",
+              "outcome",
+              "reason",
+              "rejection_reason",
+              "rejection_category",
+              "message",
+              "command_contract_source",
+              "command_contract_backfill_needed",
+              "command_contract_backfill_available",
+              "declared_signals",
+              "signal_admission",
+              "retryable",
+              "error_id"
+            ],
+            "rejection_reasons": [
+              "instance_not_found",
+              "historical_run_command_rejected",
+              "unknown_signal",
+              "invalid_signal_arguments",
+              "run_not_active",
+              "instance_not_started",
+              "selected_run_not_current",
+              "configured_workflow_type_invalid",
+              "v1_projection_read_only",
+              "backend_lock_pressure",
+              "control_plane_internal_error"
+            ]
+          },
+          "operation_name": "approve",
+          "operation_name_field": "signal_name",
+          "run_id": "{running.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "query": {
+      "status": 409,
+      "response": {
+        "message": "Operation [query] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{running.workflow}",
+        "run_id": "{running.run}",
+        "operation": "query",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "query",
+          "workflow_id": "{running.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id",
+              "operation_name",
+              "operation_name_field"
+            ],
+            "success_fields": [
+              "result",
+              "result_envelope"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "query_name",
+              "target_scope",
+              "result",
+              "reason",
+              "message",
+              "run_status",
+              "is_terminal",
+              "blocked_reason",
+              "validation_errors"
+            ],
+            "rejection_reasons": [
+              "instance_not_found",
+              "historical_run_command_rejected",
+              "run_not_active",
+              "query_not_found",
+              "rejected_unknown_query",
+              "invalid_query_arguments",
+              "workflow_definition_unavailable",
+              "query_rejected",
+              "query_worker_unavailable",
+              "query_worker_incompatible",
+              "query_task_queue_full",
+              "query_task_queue_unavailable",
+              "query_task_not_claimed",
+              "query_worker_execution_timeout",
+              "query_worker_timeout",
+              "v1_projection_read_only"
+            ]
+          },
+          "operation_name": "status",
+          "operation_name_field": "query_name",
+          "run_id": "{running.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [query] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "update": {
+      "status": 409,
+      "response": {
+        "message": "Operation [update] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{running.workflow}",
+        "run_id": "{running.run}",
+        "operation": "update",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "update",
+          "workflow_id": "{running.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id",
+              "operation_name",
+              "operation_name_field"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "update_id",
+              "update_name",
+              "update_status",
+              "outcome",
+              "reason",
+              "rejection_reason",
+              "validation_errors",
+              "retryable",
+              "message",
+              "remediation"
+            ],
+            "rejection_reasons": [
+              "update_validator_rejected",
+              "update_validator_contract_missing",
+              "update_validation_request_id_required",
+              "update_validation_idempotency_conflict",
+              "update_validation_capability_unsupported",
+              "update_validator_worker_unavailable",
+              "update_validator_worker_incompatible",
+              "update_validator_worker_lost",
+              "update_validation_task_not_claimed",
+              "update_validation_execution_timeout",
+              "duplicate_update_validation_completion",
+              "stale_update_validation_completion",
+              "invalid_update_arguments",
+              "v1_projection_read_only"
+            ]
+          },
+          "operation_name": "rename",
+          "operation_name_field": "update_name",
+          "run_id": "{running.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [update] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "cancel": {
+      "status": 409,
+      "response": {
+        "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{running.workflow}",
+        "run_id": "{running.run}",
+        "operation": "cancel",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "cancel",
+          "workflow_id": "{running.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "reason",
+              "message",
+              "remediation"
+            ],
+            "rejection_reasons": [
+              "v1_projection_read_only"
+            ]
+          },
+          "run_id": "{running.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "run_cancel": {
+      "status": 409,
+      "response": {
+        "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{running.workflow}",
+        "run_id": "{running.run}",
+        "operation": "cancel",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "cancel",
+          "workflow_id": "{running.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "reason",
+              "message",
+              "remediation"
+            ],
+            "rejection_reasons": [
+              "v1_projection_read_only"
+            ]
+          },
+          "run_id": "{running.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "terminate": {
+      "status": 409,
+      "response": {
+        "message": "Operation [terminate] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{running.workflow}",
+        "run_id": "{running.run}",
+        "operation": "terminate",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "terminate",
+          "workflow_id": "{running.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "reason",
+              "message",
+              "remediation"
+            ],
+            "rejection_reasons": [
+              "v1_projection_read_only"
+            ]
+          },
+          "run_id": "{running.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [terminate] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "repair": {
+      "status": 409,
+      "response": {
+        "message": "Operation [repair] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{running.workflow}",
+        "run_id": "{running.run}",
+        "operation": "repair",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "repair",
+          "workflow_id": "{running.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "reason",
+              "message",
+              "remediation"
+            ],
+            "rejection_reasons": [
+              "v1_projection_read_only"
+            ]
+          },
+          "run_id": "{running.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [repair] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "archive": {
+      "status": 409,
+      "response": {
+        "message": "Operation [archive] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{running.workflow}",
+        "run_id": "{running.run}",
+        "operation": "archive",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "archive",
+          "workflow_id": "{running.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "reason",
+              "message",
+              "remediation"
+            ],
+            "rejection_reasons": [
+              "v1_projection_read_only"
+            ]
+          },
+          "run_id": "{running.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [archive] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "redrive": {
+      "status": 409,
+      "response": {
+        "message": "Operation [redrive] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{running.workflow}",
+        "run_id": "{running.run}",
+        "operation": "redrive",
+        "execution_owner": "v1"
+      }
+    },
+    "request_cancellation": {
+      "status": 409,
+      "response": {
+        "reason": "legacy_v1_operation_not_supported",
+        "message": "Imported legacy workflows do not support cooperative cancellation."
+      }
+    }
+  },
+  "refuse_completed": {
+    "signal": {
+      "status": 409,
+      "response": {
+        "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{completed.workflow}",
+        "run_id": "{completed.run}",
+        "operation": "signal",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "signal",
+          "workflow_id": "{completed.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id",
+              "operation_name",
+              "operation_name_field"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "signal_name",
+              "command_status",
+              "command_source",
+              "target_scope",
+              "outcome",
+              "reason",
+              "rejection_reason",
+              "rejection_category",
+              "message",
+              "command_contract_source",
+              "command_contract_backfill_needed",
+              "command_contract_backfill_available",
+              "declared_signals",
+              "signal_admission",
+              "retryable",
+              "error_id"
+            ],
+            "rejection_reasons": [
+              "instance_not_found",
+              "historical_run_command_rejected",
+              "unknown_signal",
+              "invalid_signal_arguments",
+              "run_not_active",
+              "instance_not_started",
+              "selected_run_not_current",
+              "configured_workflow_type_invalid",
+              "v1_projection_read_only",
+              "backend_lock_pressure",
+              "control_plane_internal_error"
+            ]
+          },
+          "operation_name": "approve",
+          "operation_name_field": "signal_name",
+          "run_id": "{completed.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "run_signal": {
+      "status": 409,
+      "response": {
+        "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{completed.workflow}",
+        "run_id": "{completed.run}",
+        "operation": "signal",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "signal",
+          "workflow_id": "{completed.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id",
+              "operation_name",
+              "operation_name_field"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "signal_name",
+              "command_status",
+              "command_source",
+              "target_scope",
+              "outcome",
+              "reason",
+              "rejection_reason",
+              "rejection_category",
+              "message",
+              "command_contract_source",
+              "command_contract_backfill_needed",
+              "command_contract_backfill_available",
+              "declared_signals",
+              "signal_admission",
+              "retryable",
+              "error_id"
+            ],
+            "rejection_reasons": [
+              "instance_not_found",
+              "historical_run_command_rejected",
+              "unknown_signal",
+              "invalid_signal_arguments",
+              "run_not_active",
+              "instance_not_started",
+              "selected_run_not_current",
+              "configured_workflow_type_invalid",
+              "v1_projection_read_only",
+              "backend_lock_pressure",
+              "control_plane_internal_error"
+            ]
+          },
+          "operation_name": "approve",
+          "operation_name_field": "signal_name",
+          "run_id": "{completed.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [signal] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "query": {
+      "status": 409,
+      "response": {
+        "message": "Operation [query] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{completed.workflow}",
+        "run_id": "{completed.run}",
+        "operation": "query",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "query",
+          "workflow_id": "{completed.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id",
+              "operation_name",
+              "operation_name_field"
+            ],
+            "success_fields": [
+              "result",
+              "result_envelope"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "query_name",
+              "target_scope",
+              "result",
+              "reason",
+              "message",
+              "run_status",
+              "is_terminal",
+              "blocked_reason",
+              "validation_errors"
+            ],
+            "rejection_reasons": [
+              "instance_not_found",
+              "historical_run_command_rejected",
+              "run_not_active",
+              "query_not_found",
+              "rejected_unknown_query",
+              "invalid_query_arguments",
+              "workflow_definition_unavailable",
+              "query_rejected",
+              "query_worker_unavailable",
+              "query_worker_incompatible",
+              "query_task_queue_full",
+              "query_task_queue_unavailable",
+              "query_task_not_claimed",
+              "query_worker_execution_timeout",
+              "query_worker_timeout",
+              "v1_projection_read_only"
+            ]
+          },
+          "operation_name": "status",
+          "operation_name_field": "query_name",
+          "run_id": "{completed.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [query] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "update": {
+      "status": 409,
+      "response": {
+        "message": "Operation [update] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{completed.workflow}",
+        "run_id": "{completed.run}",
+        "operation": "update",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "update",
+          "workflow_id": "{completed.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id",
+              "operation_name",
+              "operation_name_field"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "update_id",
+              "update_name",
+              "update_status",
+              "outcome",
+              "reason",
+              "rejection_reason",
+              "validation_errors",
+              "retryable",
+              "message",
+              "remediation"
+            ],
+            "rejection_reasons": [
+              "update_validator_rejected",
+              "update_validator_contract_missing",
+              "update_validation_request_id_required",
+              "update_validation_idempotency_conflict",
+              "update_validation_capability_unsupported",
+              "update_validator_worker_unavailable",
+              "update_validator_worker_incompatible",
+              "update_validator_worker_lost",
+              "update_validation_task_not_claimed",
+              "update_validation_execution_timeout",
+              "duplicate_update_validation_completion",
+              "stale_update_validation_completion",
+              "invalid_update_arguments",
+              "v1_projection_read_only"
+            ]
+          },
+          "operation_name": "rename",
+          "operation_name_field": "update_name",
+          "run_id": "{completed.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [update] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "cancel": {
+      "status": 409,
+      "response": {
+        "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{completed.workflow}",
+        "run_id": "{completed.run}",
+        "operation": "cancel",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "cancel",
+          "workflow_id": "{completed.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "reason",
+              "message",
+              "remediation"
+            ],
+            "rejection_reasons": [
+              "v1_projection_read_only"
+            ]
+          },
+          "run_id": "{completed.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "run_cancel": {
+      "status": 409,
+      "response": {
+        "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{completed.workflow}",
+        "run_id": "{completed.run}",
+        "operation": "cancel",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "cancel",
+          "workflow_id": "{completed.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "reason",
+              "message",
+              "remediation"
+            ],
+            "rejection_reasons": [
+              "v1_projection_read_only"
+            ]
+          },
+          "run_id": "{completed.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [cancel] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "terminate": {
+      "status": 409,
+      "response": {
+        "message": "Operation [terminate] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{completed.workflow}",
+        "run_id": "{completed.run}",
+        "operation": "terminate",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "terminate",
+          "workflow_id": "{completed.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "reason",
+              "message",
+              "remediation"
+            ],
+            "rejection_reasons": [
+              "v1_projection_read_only"
+            ]
+          },
+          "run_id": "{completed.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [terminate] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "repair": {
+      "status": 409,
+      "response": {
+        "message": "Operation [repair] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{completed.workflow}",
+        "run_id": "{completed.run}",
+        "operation": "repair",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "repair",
+          "workflow_id": "{completed.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "reason",
+              "message",
+              "remediation"
+            ],
+            "rejection_reasons": [
+              "v1_projection_read_only"
+            ]
+          },
+          "run_id": "{completed.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [repair] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "archive": {
+      "status": 409,
+      "response": {
+        "message": "Operation [archive] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{completed.workflow}",
+        "run_id": "{completed.run}",
+        "operation": "archive",
+        "execution_owner": "v1",
+        "control_plane": {
+          "schema": "durable-workflow.v2.control-plane-response",
+          "version": 1,
+          "operation": "archive",
+          "workflow_id": "{completed.workflow}",
+          "contract": {
+            "schema": "durable-workflow.v2.control-plane-response.contract",
+            "version": 1,
+            "legacy_field_policy": "reject_non_canonical",
+            "legacy_fields": {
+              "query": "query_name",
+              "signal": "signal_name",
+              "update": "update_name",
+              "wait_policy": "wait_for"
+            },
+            "required_fields": [
+              "workflow_id"
+            ],
+            "success_fields": [
+              "outcome"
+            ],
+            "rejection_fields": [
+              "workflow_id",
+              "run_id",
+              "reason",
+              "message",
+              "remediation"
+            ],
+            "rejection_reasons": [
+              "v1_projection_read_only"
+            ]
+          },
+          "run_id": "{completed.run}",
+          "reason": "v1_projection_read_only",
+          "message": "Operation [archive] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+          "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+          "execution_owner": "v1"
+        }
+      }
+    },
+    "redrive": {
+      "status": 409,
+      "response": {
+        "message": "Operation [redrive] is unavailable because this execution is a read-only projection owned by the source v1 runtime.",
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": "{completed.workflow}",
+        "run_id": "{completed.run}",
+        "operation": "redrive",
+        "execution_owner": "v1"
+      }
+    },
+    "request_cancellation": {
+      "status": 409,
+      "response": {
+        "reason": "legacy_v1_operation_not_supported",
+        "message": "Imported legacy workflows do not support cooperative cancellation."
+      }
+    }
+  },
+  "refused_running_describe": {
+    "status": 200,
+    "response": {
+      "workflow_id": "{running.workflow}",
+      "run_id": "{running.run}",
+      "namespace": "pr1-waterline-import-wl1",
+      "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+      "business_key": null,
+      "status": "running",
+      "status_bucket": "running",
+      "is_terminal": false,
+      "closed_reason": null,
+      "task_queue": "legacy-billing",
+      "run_number": 1,
+      "run_count": 1,
+      "is_current_run": true,
+      "continued_from_run_id": null,
+      "resume_step_sequence": null,
+      "recovery_kind": null,
+      "compatibility": null,
+      "compatibility_status": "compatible",
+      "compatibility_supported_in_fleet": true,
+      "compatibility_fleet_reason": null,
+      "payload_codec": null,
+      "definition_routing": null,
+      "execution_timeout_seconds": null,
+      "run_timeout_seconds": null,
+      "execution_deadline_at": null,
+      "run_deadline_at": null,
+      "input": null,
+      "output": null,
+      "input_envelope": null,
+      "output_envelope": null,
+      "payload_previews": {
+        "input_omitted": false,
+        "output_omitted": false,
+        "max_encoded_bytes": 2097152
+      },
+      "started_at": "2026-09-30T09:00:00.000000Z",
+      "closed_at": null,
+      "last_progress_at": "2026-09-30T09:00:00.000000Z",
+      "wait_kind": null,
+      "wait_reason": null,
+      "memo": [],
+      "search_attributes": [],
+      "actions": {
+        "can_signal": false,
+        "can_query": false,
+        "can_update": false,
+        "can_cancel": false,
+        "can_terminate": false,
+        "can_repair": false,
+        "can_archive": false
+      },
+      "commands_scope": "selected_run",
+      "commands": [],
+      "updates_scope": "selected_run",
+      "updates": [],
+      "migration_projection": {
+        "origin": {
+          "engine_source": "v1",
+          "engine_version": "1.x",
+          "execution_engine": "finish-on-v1"
+        },
+        "identity": {
+          "waterline": {
+            "source_id": "pr1-waterline-import",
+            "qualified_workflow_id": "v1:4201",
+            "legacy_workflow_id": "4201"
+          },
+          "standalone": {
+            "namespace": "pr1-waterline-import-wl1",
+            "workflow_id": "{running.workflow}",
+            "run_id": "{running.run}"
+          },
+          "relationship": "deterministic_source_qualified_projection",
+          "collision_policy": "reject_without_overwrite"
+        },
+        "task_queue_context": {
+          "connection": "database",
+          "name": "legacy-billing",
+          "execution_owner": "v1",
+          "standalone_dispatch": "disabled"
+        },
+        "unsupported_fields": [
+          {
+            "field": "runtime.replay",
+            "reason": "v1_history_not_replayable_as_v2",
+            "remediation": "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."
+          },
+          {
+            "field": "timers",
+            "reason": "legacy_timer_state_not_exposed_by_waterline",
+            "remediation": "Inspect timers in the source application and allow open executions to finish on v1."
+          },
+          {
+            "field": "payloads.arguments",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "payloads.activity_results",
+            "reason": "legacy_php_serialization_not_portable",
+            "remediation": "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required."
+          },
+          {
+            "field": "runtime.execution",
+            "reason": "finish_on_v1_execution_not_transferable",
+            "remediation": "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."
+          }
+        ],
+        "projection": {
+          "schema": "durable-workflow.v2.waterline-v1-projection.contract",
+          "version": 1,
+          "read_only": true,
+          "execution_owner": "v1",
+          "imported_at": "{imported_at}",
+          "dedupe_key": "{running.dedupe}"
+        }
+      },
+      "action_blocked_reason": "v1_projection_read_only",
+      "control_plane": {
+        "schema": "durable-workflow.v2.control-plane-response",
+        "version": 1,
+        "operation": "describe",
+        "workflow_id": "{running.workflow}",
+        "contract": {
+          "schema": "durable-workflow.v2.control-plane-response.contract",
+          "version": 1,
+          "legacy_field_policy": "reject_non_canonical",
+          "legacy_fields": {
+            "query": "query_name",
+            "signal": "signal_name",
+            "update": "update_name",
+            "wait_policy": "wait_for"
+          },
+          "required_fields": [
+            "workflow_id"
+          ],
+          "success_fields": []
+        },
+        "run_id": "{running.run}",
+        "workflow_type": "App\\Workflows\\Legacy\\Subscription",
+        "namespace": "pr1-waterline-import-wl1",
+        "business_key": null,
+        "status": "running",
+        "status_bucket": "running",
+        "is_terminal": false,
+        "task_queue": "legacy-billing",
+        "run_number": 1,
+        "run_count": 1,
+        "is_current_run": true,
+        "compatibility": null,
+        "started_at": "2026-09-30T09:00:00.000000Z",
+        "closed_at": null,
+        "last_progress_at": "2026-09-30T09:00:00.000000Z",
+        "wait_kind": null,
+        "wait_reason": null
+      }
+    }
+  }
+}
diff --git a/tests/Unit/ServerParityWaterlineImportContractTest.mjs b/tests/Unit/ServerParityWaterlineImportContractTest.mjs
new file mode 100644
index 000000000..6a5786e75
--- /dev/null
+++ b/tests/Unit/ServerParityWaterlineImportContractTest.mjs
@@ -0,0 +1,100 @@
+import assert from 'node:assert/strict';
+import {readFileSync} from 'node:fs';
+import test from 'node:test';
+import {checkWaterlineImport} from '../../scripts/conformance/server-parity/waterline-import-contract.mjs';
+
+const fixture = JSON.parse(readFileSync(new URL('../Fixtures/ServerParity/waterline-import.json', import.meta.url)));
+// The observation published Server 2.11.1 returned for this fixture.
+const recorded = JSON.parse(readFileSync(
+  new URL('../Fixtures/ServerParityExpected/waterline-import-observation.json', import.meta.url)));
+const id = 'pr1-waterline-import';
+const observation = (change = () => {}) => {
+  const state = structuredClone(recorded);
+  change(state);
+  return {mode: 'http', waterline_import: state};
+};
+const check = state => checkWaterlineImport(fixture, state, id);
+
+test('the published 2.11.1 recording satisfies the contract', () => {
+  assert.deepStrictEqual(check(observation()), {scope: 'waterline_import'});
+});
+
+test('embedded applications are explicitly inapplicable', () => {
+  assert.deepStrictEqual(check({mode: 'embedded', waterline_import:
+    {applicable: false, reason: 'embedded_has_no_http_waterline_import'}}), {scope: 'waterline_import'});
+  assert.throws(() => check({mode: 'embedded', waterline_import: {applicable: true}}), /embedded waterline import/);
+});
+
+test('the recording covers every refusal and read', () => {
+  const expected = fixture.waterline_import.expected;
+  for (const label of ['running', 'completed']) {
+    for (const [operation, answer] of Object.entries(expected[`refuse_${label}`])) {
+      assert.equal(answer.status, 409, `${label} ${operation}`);
+    }
+  }
+  assert.equal(expected.project.status, 201);
+  assert.equal(expected.project.response.status, 'projected');
+  assert.equal(expected.native_collision.response.reason, 'native_v2_identity_collision');
+  assert.equal(expected.read_project_describe.response.action_blocked_reason, 'v1_projection_read_only');
+  assert.ok(expected.read_project_history.response.migration_projection, 'history carries the projection metadata');
+  assert.ok(expected.read_project_export.response.migration_projection, 'the export carries the projection metadata');
+  for (const name of ['project', 'running', 'failed', 'offsets', 'bare']) {
+    assert.equal(expected[`read_${name}_export`].response.integrity_verified, true, `${name} export checksum covers its bundle`);
+  }
+});
+
+for (const [label, change, message] of [
+  // Native answered 501 for the import route before this fixture.
+  ['an unimplemented route', state => {
+    state.project = {status: 501, response: {reason: 'rust_capability_not_implemented'}};
+  }, /waterline import project/],
+  ['a dry run that writes the projection', state => {
+    state.dry_run_describe = structuredClone(state.read_project_describe);
+  }, /waterline import dry_run_describe/],
+  ['a repeat projected again', state => {
+    state.repeat = structuredClone(state.project);
+  }, /waterline import repeat/],
+  ['a changed source accepted as a repeat', state => {
+    state.changed = structuredClone(state.repeat);
+  }, /waterline import changed/],
+  ['a projection taken over by another namespace', state => {
+    state.other_namespace = structuredClone(state.project);
+  }, /waterline import other_namespace/],
+  ['a native identity overwritten', state => {
+    state.native_collision.status = 201;
+  }, /waterline import native_collision/],
+  ['only the first of several normalization errors', state => {
+    state.reject_all.response.errors = state.reject_all.response.errors.slice(0, 1);
+  }, /waterline import reject_all/],
+  ['a describe that offers actions', state => {
+    state.read_project_describe.response.actions.can_signal = true;
+  }, /waterline import read_project_describe/],
+  ['a describe without projection metadata', state => {
+    delete state.read_running_describe.response.migration_projection;
+  }, /waterline import read_running_describe/],
+  ['a history without projection metadata', state => {
+    delete state.read_project_history.response.migration_projection;
+  }, /waterline import read_project_history/],
+  ['an export whose checksum was not recomputed', state => {
+    state.read_project_export.response.integrity_verified = false;
+  }, /waterline import read_project_export/],
+  ['a signal admitted on a running projection', state => {
+    state.refuse_running.signal = {status: 202, response: {outcome: 'signal_received'}};
+  }, /waterline import refuse_running/],
+  ['a cooperative cancellation refused with the operation reason', state => {
+    state.refuse_completed.request_cancellation.response.reason = 'v1_projection_read_only';
+  }, /waterline import refuse_completed/],
+  ['an event order by hashed id', state => {
+    state.read_project_history.response.events.reverse();
+  }, /waterline import read_project_history/],
+  ['a missing step', state => {
+    delete state.read_list_alt;
+  }, /waterline import read_list_alt/],
+  ['an extra step', state => {
+    state.unexpected = {status: 200};
+  }, /waterline import steps/],
+]) {
+  test(`the contract refuses ${label}`, () => {
+    assert.throws(() => check(observation(change)), message);
+  });
+}

From 7f3793d15fa92265ecdc6b158c2a0c2b49334b37 Mon Sep 17 00:00:00 2001
From: Richard McDaniel <1130888+rmcdaniel@users.noreply.github.com>
Date: Sun, 25 Oct 2026 02:20:32 +0000
Subject: [PATCH 2/9] Rust #325: project Waterline v1 workflows like Server
 2.11.1

Native now serves POST /api/workflows/import/waterline-v1 as published
Server 2.11.1 does (LegacyV1ProjectionController and LegacyV1Projection),
and reads and refuses projected runs as PHP does.

Import:

- Laravel validation of source_id, workflow and dry_run, then each
  normalization refusal in PHP's order, with the first error's reason,
  message and remediation at the top of the report.
- The deterministic identity (mappedIdentity), the opaque payloads, the
  unsupported fields, and events ordered by boundary, whole-second time
  (untimed first) and source order. The dedupe key is SHA-256 over PHP's
  canonical JSON, and history_size_bytes is PHP's json_encode length of
  each event. A unit test pins both against PHP's own output.
- already_projected, namespace collision, storage inconsistency, changed
  source and native identity collision, decided from the run and instance
  holding the identity in any namespace (ids are global).
- One transaction writes the instance, run, history and summary. Ordinary
  date columns keep the source's wall-clock time as Eloquent stores it;
  history times go through the UTC cast.

Reads and refusals:

- Describe and run describe report the projection as formatRun does
  without a control-plane description: the stored codec, no routing,
  toJSON progress time, every action off, action_blocked_reason and
  migration_projection. A failed projection carries the terminal failure
  PHP derives from its activity failure events.
- History carries migration_projection. The runs list leaves the memo out.
  The workflow list orders a projection by its summary sort time and
  accepts runs without a start time or queue.
- The history export carries migration_projection inside its integrity
  block.
- Signal, query, update, cancel, terminate, repair and archive refuse a
  projected current run with v1_projection_read_only before reading their
  bodies; a query once its input passes validation; redrive on its source
  run. Cooperative cancellation refuses with
  legacy_v1_operation_not_supported.

Three changes reach ordinary runs:

- The export checksum and signature are computed over PHP's canonical
  JSON. Non-ASCII text is now escaped as PHP escapes it, so PHP's importer
  verifies a native export.
- List times use PHP's toJSON with six fractional digits.
- A history event without a recorded time reads as null.

Qualified locally: the waterline-import fixture passes against native on
SQLite, PostgreSQL 17, MySQL 8.0 and MariaDB 10.11; every shared fixture
passes against native on SQLite; and the SQLite all-targets suite passes
(269 unit, 454 execution).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 rust/src/runtime/continuations.rs    |  11 +-
 rust/src/runtime/control_plane.rs    |  18 +
 rust/src/runtime/cooperative.rs      |   6 +
 rust/src/runtime/execution.rs        |   4 +
 rust/src/runtime/history_export.rs   |  42 +-
 rust/src/runtime/http.rs             |  14 +-
 rust/src/runtime/mod.rs              |   1 +
 rust/src/runtime/run_describe.rs     |  13 +-
 rust/src/runtime/store.rs            |  46 +-
 rust/src/runtime/visibility.rs       |  11 +-
 rust/src/runtime/waterline_import.rs | 983 +++++++++++++++++++++++++++
 11 files changed, 1130 insertions(+), 19 deletions(-)
 create mode 100644 rust/src/runtime/waterline_import.rs

diff --git a/rust/src/runtime/continuations.rs b/rust/src/runtime/continuations.rs
index 7a5d4d62c..43e297490 100644
--- a/rust/src/runtime/continuations.rs
+++ b/rust/src/runtime/continuations.rs
@@ -45,7 +45,7 @@ where
     /// `formatRunListEntry` renders it. The current run is the highest
     /// numbered one.
     pub(super) async fn list_runs(&self, workflow: &str) -> Result<Value> {
-        let rows=Self::query("SELECT r.id,r.workflow_type,r.business_key,r.status,r.run_number,r.queue,r.compatibility,r.started_at,r.closed_at FROM workflow_runs r JOIN workflow_instances i ON i.id=r.workflow_instance_id WHERE i.id=$1 AND i.namespace=$2 AND r.namespace=$3 ORDER BY r.run_number LIMIT 1025")
+        let rows=Self::query("SELECT r.id,r.workflow_type,r.business_key,r.status,r.run_number,r.queue,r.compatibility,r.started_at,r.closed_at,r.import_source FROM workflow_runs r JOIN workflow_instances i ON i.id=r.workflow_instance_id WHERE i.id=$1 AND i.namespace=$2 AND r.namespace=$3 ORDER BY r.run_number LIMIT 1025")
             .bind(workflow).bind(self.namespace.as_ref()).bind(self.namespace.as_ref()).fetch_all(&self.pool).await?;
         if rows.is_empty() {
             return Err(refuse(StatusCode::NOT_FOUND, "instance_not_found"));
@@ -67,7 +67,7 @@ where
             let required = compatibility.as_deref().map(str::trim).filter(|value| !value.is_empty());
             let (supported, reason) = super::run_diagnostics::fleet_supports(&fleet, required, queue.as_deref());
             let memo = self.run_memo(&run).await?;
-            runs.push(json!({"run_id":run,"run_number":DB::number(&row,"run_number")?,
+            let mut entry = json!({"run_id":run,"run_number":DB::number(&row,"run_number")?,
                 "workflow_type":DB::string(&row,"workflow_type")?,"business_key":DB::optional_string(&row,"business_key")?,
                 "status":status,"status_bucket":super::visibility::status_bucket(&status)?,
                 "is_terminal":matches!(status.as_str(), "completed" | "failed" | "cancelled" | "terminated"),
@@ -75,7 +75,12 @@ where
                 "compatibility_status":if supported { "compatible" } else { "no_compatible_worker" },
                 "compatibility_supported_in_fleet":supported,"compatibility_fleet_reason":reason,
                 "started_at":super::task_queues::json_time(DB::optional_instant(&row,"started_at")?),
-                "closed_at":super::task_queues::json_time(DB::optional_instant(&row,"closed_at")?),"memo":memo}));
+                "closed_at":super::task_queues::json_time(DB::optional_instant(&row,"closed_at")?),"memo":memo});
+            // `formatRunListEntry` leaves a Waterline v1 projection's memo out.
+            if DB::optional_string(&row, "import_source")?.as_deref() == Some(super::waterline_import::IMPORT_SOURCE) {
+                entry.as_object_mut().expect("run entry").remove("memo");
+            }
+            runs.push(entry);
         }
         Ok(json!({"workflow_id":workflow,"run_count":runs.len(),"runs":runs}))
     }
diff --git a/rust/src/runtime/control_plane.rs b/rust/src/runtime/control_plane.rs
index 8467f7058..e0b512860 100644
--- a/rust/src/runtime/control_plane.rs
+++ b/rust/src/runtime/control_plane.rs
@@ -21,6 +21,7 @@ pub(super) enum Operation<'a> {
     Signal(&'a str),
     Query(&'a str),
     ImportEmbeddedV2,
+    ImportWaterlineV1,
 }
 
 impl Operation<'_> {
@@ -139,6 +140,7 @@ impl Operation<'_> {
             ),
             // PHP defines no contract for the import, so its defaults apply.
             Self::ImportEmbeddedV2 => ("import_embedded_v2", &[], &[]),
+            Self::ImportWaterlineV1 => ("import_waterline_v1", &[], &["status", "identity"]),
         };
         let mut metadata = json!({"schema":"durable-workflow.v2.control-plane-response", "version":1,
             "operation":operation, "workflow_id":body.get("workflow_id"),
@@ -194,6 +196,14 @@ impl Operation<'_> {
                     }
                 }
             }
+            // Its contract's success and rejection fields.
+            Self::ImportWaterlineV1 => {
+                for field in ["status", "identity"] {
+                    if let Some(value) = body.get(field) {
+                        metadata[field] = value.clone();
+                    }
+                }
+            }
             _ => {}
         }
         // ControlPlaneResponseContract::PROJECTED_FIELDS: each present field.
@@ -271,6 +281,13 @@ impl Operation<'_> {
                 "control_plane_internal_error",
             ),
             Self::Redrive => ("workflow_id continued_from_run_id run_id reason message", ""),
+            Self::ImportWaterlineV1 => (
+                "status reason message remediation identity",
+                "invalid_source_id unqualified_v1_identity v1_identity_mismatch unsupported_source_engine \
+                 missing_v1_workflow_class unsupported_v1_status v1_projection_changed \
+                 v1_projection_namespace_collision v1_projection_storage_inconsistent \
+                 native_v2_identity_collision target_write_failed",
+            ),
             Self::Cancel | Self::Terminate | Self::Archive | Self::Repair => {
                 ("workflow_id run_id reason message remediation", "v1_projection_read_only")
             }
@@ -319,6 +336,7 @@ pub(super) async fn admission_response(request: Request, mut body: Value) -> Val
     let segments: Vec<_> = path.trim_start_matches('/').split('/').collect();
     let operation = match (request.method().as_str(), segments.as_slice()) {
         ("POST", ["api", "workflows", "import", "embedded-v2"]) => Operation::ImportEmbeddedV2,
+        ("POST", ["api", "workflows", "import", "waterline-v1"]) => Operation::ImportWaterlineV1,
         ("POST", ["api", "workflows"]) => Operation::Start,
         ("POST", ["api", "workflows", _, "signal", name])
         | ("POST", ["api", "workflows", _, "runs", _, "signal", name]) => Operation::Signal(name),
diff --git a/rust/src/runtime/cooperative.rs b/rust/src/runtime/cooperative.rs
index df633552d..de2ee9e00 100644
--- a/rust/src/runtime/cooperative.rs
+++ b/rust/src/runtime/cooperative.rs
@@ -816,6 +816,12 @@ where
         if run_id != current {
             return Err(refuse(StatusCode::CONFLICT, "selected_run_not_current"));
         }
+        // A Waterline v1 projection is read-only; its v1 runtime owns execution.
+        if DB::optional_string(&run, "import_source")?.as_deref() == Some(super::waterline_import::IMPORT_SOURCE) {
+            return Err(super::RuntimeError::Protocol { status: StatusCode::CONFLICT, response: json!({
+                "reason": "legacy_v1_operation_not_supported",
+                "message": "Imported legacy workflows do not support cooperative cancellation."}) });
+        }
         let run_status = DB::string(&run, "status")?;
         let response = |duplicate: bool, pending: Value| {
             json!({"workflow_id":workflow_id,"run_id":run_id,
diff --git a/rust/src/runtime/execution.rs b/rust/src/runtime/execution.rs
index 392777ec4..f6407718a 100644
--- a/rust/src/runtime/execution.rs
+++ b/rust/src/runtime/execution.rs
@@ -1403,6 +1403,10 @@ impl Runtime {
     delegate!(renew_activity_lease(task_id: &str, body: Value) -> Result<Value>);
     delegate!(import_existing_run(run_id: &str) -> Result<Option<super::workflow_import::ExistingRun>>);
     delegate!(import_write(plan: &super::workflow_import::Plan) -> std::result::Result<super::workflow_import::Rows, String>);
+    delegate!(waterline_existing(workflow_id: &str, run_id: &str) -> Result<super::waterline_import::Existing>);
+    delegate!(projected_current_run(workflow_id: &str) -> Result<Option<String>>);
+    delegate!(projected_run(workflow_id: &str, run_id: &str) -> Result<Option<String>>);
+    delegate!(waterline_write(projection: &super::waterline_import::Normalized, imported_at: chrono::DateTime<chrono::Utc>) -> std::result::Result<(), bool>);
     /// The namespace this runtime's store serves.
     pub(crate) fn namespace_name(&self) -> String {
         match &*self.storage {
diff --git a/rust/src/runtime/history_export.rs b/rust/src/runtime/history_export.rs
index 7cccf3989..02422dcf4 100644
--- a/rust/src/runtime/history_export.rs
+++ b/rust/src/runtime/history_export.rs
@@ -64,6 +64,7 @@ pub(super) const RUN: &[(&str, Column)] = &[
     ("queue", Text), ("last_history_sequence", Int), ("started_at", Time), ("closed_at", Time), ("archived_at", Time),
     ("archive_command_id", Text), ("archive_reason", Text), ("last_progress_at", Time), ("updated_at", Time),
     ("current_run_id", Text), ("instance_business_key", Text), ("instance_visibility_labels", Json), ("continuations", Int),
+    ("import_source", Text), ("imported_at", Time), ("import_dedupe_key", Text),
 ];
 pub(super) const RUN_SQL: &str = "SELECT r.*,i.current_run_id,i.business_key AS instance_business_key,i.visibility_labels AS instance_visibility_labels,(SELECT COUNT(*) FROM workflow_links l WHERE l.child_workflow_instance_id=r.workflow_instance_id AND l.link_type='continue_as_new') AS continuations FROM workflow_runs r JOIN workflow_instances i ON i.id=r.workflow_instance_id WHERE i.id=$1 AND r.id=$2 AND r.namespace=$3";
 pub(super) const SUMMARY: &[(&str, Column)] = &[
@@ -602,10 +603,11 @@ fn codec_schemas() -> Value {
 }
 
 /// `withIntegrity`: SHA-256, and HMAC-SHA-256 when a key is configured, over
-/// the bundle's canonical JSON. Native objects keep their keys sorted, so
-/// compact serialization is the recursive-ksort canonical form.
+/// the bundle's canonical JSON as PHP encodes it: maps key-sorted, lists in
+/// order, slashes unescaped, zero fractions kept, and non-ASCII text escaped,
+/// so PHP's importer verifies a native export.
 fn integrity(bundle: &Value, signing: Option<&Signing>) -> Value {
-    let canonical = serde_json::to_string(bundle).expect("JSON values serialize");
+    let canonical = canonical_json(bundle);
     let checksum = hex(&Sha256::digest(canonical.as_bytes()));
     let signature = signing.map(|signing| {
         let mut mac = Hmac::<Sha256>::new_from_slice(signing.key.as_bytes()).expect("HMAC takes any key length");
@@ -617,6 +619,26 @@ fn integrity(bundle: &Value, signing: Option<&Signing>) -> Value {
         "key_id": signing.and_then(|signing| signing.key_id.clone())})
 }
 
+/// `BundleIntegrityVerifier::canonicalJson` of a bundle.
+pub(super) fn canonical_json(bundle: &Value) -> String {
+    let text = serde_json::to_vec(bundle).expect("JSON values serialize");
+    super::php_value::decode(&text).expect("serialized JSON decodes").canonical().encode(super::php_value::CANONICAL)
+}
+
+/// `LegacyV1Projection::metadataForRun` from the export's own rows.
+fn projection_metadata(rows: &Rows) -> Value {
+    let migration = rows.events.first().map(|event| event["payload"]["migration_projection"].clone()).unwrap_or(Value::Null);
+    json!({
+        "origin": migration["origin"],
+        "identity": migration["identity"],
+        "task_queue_context": migration["task_queue_context"],
+        "unsupported_fields": migration["unsupported_fields"].as_array().cloned().unwrap_or_default(),
+        "projection": {"schema": super::waterline_import::SCHEMA, "version": super::waterline_import::VERSION,
+            "read_only": true, "execution_owner": "v1", "imported_at": rows.run["imported_at"],
+            "dedupe_key": rows.run["import_dedupe_key"]},
+    })
+}
+
 /// `HistoryExport::forRun`.
 pub(super) fn bundle(rows: &Rows, exported_at: &str, signing: Option<&Signing>) -> Value {
     let run = &rows.run;
@@ -652,6 +674,11 @@ pub(super) fn bundle(rows: &Rows, exported_at: &str, signing: Option<&Signing>)
         "codec_schemas": codec_schemas(),
     });
     bundle["payload_manifest"] = manifest(&bundle);
+    // `decorateHistoryExport`: a Waterline v1 projection carries its
+    // provenance, and the integrity block covers it.
+    if run["import_source"] == super::waterline_import::IMPORT_SOURCE {
+        bundle["migration_projection"] = projection_metadata(rows);
+    }
     bundle["integrity"] = integrity(&bundle, signing);
     bundle
 }
@@ -684,11 +711,18 @@ mod tests {
         let signed = bundle(&rows, "now", Some(&signing));
         let mut unsigned = signed.clone();
         unsigned.as_object_mut().unwrap().remove("integrity");
-        let canonical = serde_json::to_string(&unsigned).unwrap();
+        let canonical = canonical_json(&unsigned);
         assert_eq!(signed["integrity"]["checksum"], hex(&Sha256::digest(canonical.as_bytes())));
         assert_eq!(signed["integrity"]["signature_algorithm"], "hmac-sha256");
         assert_eq!(signed["integrity"]["key_id"], "v1");
         assert_eq!(signed["dedupe_key"], "r:2:t");
         assert_eq!(signed["history_complete"], true);
     }
+
+    #[test]
+    fn canonical_json_matches_php() {
+        // PHP printed {"a":[2,1],"b":1.0,"k":"\u03bb/x"} for this value with
+        // JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION after ksort.
+        assert_eq!(canonical_json(&json!({"k": "λ/x", "b": 1.0, "a": [2, 1]})), r#"{"a":[2,1],"b":1.0,"k":"\u03bb/x"}"#);
+    }
 }
diff --git a/rust/src/runtime/http.rs b/rust/src/runtime/http.rs
index 92d7a1c9d..a4128e401 100644
--- a/rust/src/runtime/http.rs
+++ b/rust/src/runtime/http.rs
@@ -68,6 +68,7 @@ pub fn router(runtime: Runtime) -> Router {
         )
         .route("/api/workflows", get(list_workflows).post(start))
         .route("/api/workflows/import/embedded-v2", post(import_embedded_v2))
+        .route("/api/workflows/import/waterline-v1", post(import_waterline_v1))
         .route("/api/activities", get(list_activities).post(start_activity))
         .route("/api/activities/{activity_id}", get(show_activity))
         .route(
@@ -295,6 +296,7 @@ pub fn router(runtime: Runtime) -> Router {
         .route("/api/worker/query-tasks/{task_id}/fail", post(fail_query))
         .fallback(route_fallback)
         .method_not_allowed_fallback(route_fallback)
+        .layer(middleware::from_fn(super::waterline_import::read_only_guard))
         .layer(middleware::from_fn(empty_list_body))
         // `payload_limits` reads and bounds every body first.
         .layer(DefaultBodyLimit::disable())
@@ -683,7 +685,8 @@ fn exact_namespace_route(path: &str) -> Option<Allowed> {
         // The metrics describe the namespace's own state, read by GET or POST.
         "/api/system/metrics" => READ_WRITE,
         // An import writes into the requested namespace.
-        "/api/external-payloads/v1" | "/api/storage/test" | "/api/workflows/import/embedded-v2" => WRITE,
+        "/api/external-payloads/v1" | "/api/storage/test" | "/api/workflows/import/embedded-v2"
+        | "/api/workflows/import/waterline-v1" => WRITE,
         "/api/task-queues"
         | "/api/deployments"
         | "/api/workers"
@@ -1045,6 +1048,15 @@ async fn import_embedded_v2(
     Ok((status, Json(answer)))
 }
 
+/// `POST /api/workflows/import/waterline-v1`.
+async fn import_waterline_v1(
+    Extension(runtime): Extension<Runtime>,
+    body: axum::body::Bytes,
+) -> Result<(StatusCode, Json<Value>)> {
+    let (status, answer) = runtime.import_waterline_v1(&body).await?;
+    Ok((status, Json(answer)))
+}
+
 /// `POST /api/activities`: a standalone activity in its own host run.
 async fn start_activity(
     Extension(runtime): Extension<Runtime>,
diff --git a/rust/src/runtime/mod.rs b/rust/src/runtime/mod.rs
index 22bfa0c56..2ded561b5 100644
--- a/rust/src/runtime/mod.rs
+++ b/rust/src/runtime/mod.rs
@@ -107,6 +107,7 @@ mod task_queue_build_ids;
 mod task_queues;
 mod query_route;
 mod run_describe;
+mod waterline_import;
 mod workflow_import;
 mod workflow_streams;
 mod schedule_list;
diff --git a/rust/src/runtime/run_describe.rs b/rust/src/runtime/run_describe.rs
index c71376459..2df15006a 100644
--- a/rust/src/runtime/run_describe.rs
+++ b/rust/src/runtime/run_describe.rs
@@ -282,9 +282,16 @@ where
         }
         fields.extend(compatibility);
         // `ServerWorkflowControlPlane::withDefinitionRouting`.
-        let mut tx = self.begin_read().await?;
-        let routing = self.definition_inspect(&mut tx, run, None).await?;
-        tx.commit().await?;
+        // A Waterline v1 projection has no standalone routing, and may have
+        // no task queue at all.
+        let routing = if DB::optional_string(run, "import_source")?.as_deref() == Some(super::waterline_import::IMPORT_SOURCE) {
+            Value::Null
+        } else {
+            let mut tx = self.begin_read().await?;
+            let routing = self.definition_inspect(&mut tx, run, None).await?;
+            tx.commit().await?;
+            routing
+        };
         fields.insert("definition_routing".into(), routing);
         fields.insert("payload_previews".into(), json!({"input_omitted":input_omitted,"output_omitted":output_omitted,
             "max_encoded_bytes":max_payload_bytes()}));
diff --git a/rust/src/runtime/store.rs b/rust/src/runtime/store.rs
index 9f969a321..d661e6d05 100644
--- a/rust/src/runtime/store.rs
+++ b/rust/src/runtime/store.rs
@@ -626,7 +626,7 @@ where
         let output_envelope = output.as_deref().map(wire);
         let mut described =
             json!({"workflow_id": workflow_id, "run_id": DB::string(&row,"id")?, "workflow_type": DB::string(&row,"workflow_type")?,
-            "namespace": self.namespace.as_ref(), "task_queue": DB::string(&row,"queue")?, "status": status,
+            "namespace": self.namespace.as_ref(), "task_queue": DB::optional_string(&row,"queue")?, "status": status,
             "commands_scope":"selected_run","commands":commands,
             "status_bucket": super::visibility::status_bucket(&status)?,
             "is_current_run": current,
@@ -637,7 +637,7 @@ where
             "input_envelope": input_envelope, "output_envelope": output_envelope,
             // `toJSON()` for start and close; the run description's
             // `toIso8601String()` for deadlines.
-            "started_at": super::task_queues::json_time(Some(DB::instant(&row,"started_at")?)),
+            "started_at": super::task_queues::json_time(DB::optional_instant(&row,"started_at")?),
             "closed_at": super::task_queues::json_time(DB::optional_instant(&row,"closed_at")?),
             "execution_timeout_seconds": DB::optional_number(&row,"execution_timeout_seconds")?,
             "run_timeout_seconds": DB::optional_number(&row,"run_timeout_seconds")?,
@@ -649,6 +649,38 @@ where
                 .await?;
             described.as_object_mut().expect("description object").extend(fields);
         }
+        // `formatRun` for a Waterline v1 projection: no control-plane
+        // description, every action off, the stored codec and progress time,
+        // and the projection's metadata.
+        if DB::optional_string(&row, "import_source")?.as_deref() == Some(super::waterline_import::IMPORT_SOURCE) {
+            let metadata = self.projection_metadata(&DB::string(&row, "id")?, DB::optional_instant(&row, "imported_at")?,
+                DB::optional_string(&row, "import_dedupe_key")?).await?;
+            let failure = if stale_after.is_some() && described["status"] == "failed" {
+                self.projected_failure(&DB::string(&row, "id")?).await?
+            } else {
+                Value::Null
+            };
+            let fields = described.as_object_mut().expect("description object");
+            fields.insert("payload_codec".into(), json!(DB::optional_string(&row, "payload_codec")?));
+            if stale_after.is_some() {
+                fields.insert("definition_routing".into(), Value::Null);
+                fields.insert("last_progress_at".into(), super::task_queues::json_time(DB::optional_instant(&row, "last_progress_at")?));
+                if let Some(Value::Object(actions)) = fields.get_mut("actions") {
+                    actions.values_mut().for_each(|value| *value = json!(false));
+                }
+                fields.insert("migration_projection".into(), metadata);
+                fields.insert("action_blocked_reason".into(), json!("v1_projection_read_only"));
+                // `terminalFailurePayload`: a projection keeps no failure
+                // snapshots, so a failed one reports its projected activity
+                // failures only.
+                if !failure.is_null() {
+                    fields.insert("error".into(), failure["message"].clone());
+                    fields.insert("exception".into(), failure["exception"].clone());
+                    fields.insert("failures".into(), json!([]));
+                    fields.insert("failure".into(), failure);
+                }
+            }
+        }
         Ok(described)
     }
 
@@ -660,7 +692,7 @@ where
         page_size: i64,
     ) -> Result<Value> {
         self.describe(workflow_id, Some(run_id)).await?;
-        let run = Self::query("SELECT compatibility,queue FROM workflow_runs WHERE id=$1")
+        let run = Self::query("SELECT compatibility,queue,import_source,imported_at,import_dedupe_key FROM workflow_runs WHERE id=$1")
             .bind(run_id)
             .fetch_one(&self.pool)
             .await?;
@@ -679,6 +711,11 @@ where
         // describe does.
         let mut body = json!({"workflow_id": workflow_id, "run_id": run_id, "events": public_events, "next_page_token": next});
         body.as_object_mut().expect("history object").extend(compatibility);
+        // `LegacyV1Projection::metadataForRun` on a projected run.
+        if DB::optional_string(&run, "import_source")?.as_deref() == Some(super::waterline_import::IMPORT_SOURCE) {
+            body["migration_projection"] = self.projection_metadata(run_id, DB::optional_instant(&run, "imported_at")?,
+                DB::optional_string(&run, "import_dedupe_key")?).await?;
+        }
         Ok(body)
     }
 
@@ -3633,7 +3670,8 @@ where
         Ok(
             json!({"id": DB::string(&row,"id")?, "sequence": DB::number(&row,"sequence")?, "event_type": DB::string(&row,"event_type")?,
         "payload": payload,
-        "recorded_at": DB::instant(&row,"recorded_at")?.to_rfc3339_opts(chrono::SecondsFormat::Micros, true),
+        // A Waterline v1 projection may hold untimed events; PHP reads them as null.
+        "recorded_at": DB::optional_instant(&row,"recorded_at")?.map(|at| at.to_rfc3339_opts(chrono::SecondsFormat::Micros, true)),
         "workflow_task_id": DB::optional_string(&row,"workflow_task_id")?, "workflow_command_id": DB::optional_string(&row,"workflow_command_id")?}),
         )
     }
diff --git a/rust/src/runtime/visibility.rs b/rust/src/runtime/visibility.rs
index a9346da7c..97341d4d3 100644
--- a/rust/src/runtime/visibility.rs
+++ b/rust/src/runtime/visibility.rs
@@ -125,15 +125,18 @@ fn validation(field: &'static str, message: &'static str) -> RuntimeError {
     }
 }
 
-pub(super) const VISIBILITY_PAGE: &str = "SELECT r.id,r.workflow_instance_id,r.workflow_type,r.queue,r.status,r.compatibility,r.started_at,r.closed_at,COALESCE(r.business_key,i.business_key) AS business_key FROM workflow_runs r JOIN workflow_instances i ON i.id=r.workflow_instance_id WHERE r.namespace=$1 AND i.namespace=$2 AND ($3 IS NULL OR r.workflow_type=$4) AND ($5 IS NULL OR CASE WHEN r.status IN ('pending','running','waiting') THEN 'running' WHEN r.status='completed' THEN 'completed' ELSE 'failed' END=$6 OR r.status=$7) AND ($8 IS NULL OR r.workflow_instance_id LIKE $9 OR COALESCE(r.business_key,i.business_key) LIKE $10) ORDER BY r.started_at DESC,r.id DESC LIMIT $11 OFFSET $12";
+pub(super) const VISIBILITY_PAGE: &str = "SELECT r.id,r.workflow_instance_id,r.workflow_type,r.queue,r.status,r.compatibility,r.started_at,r.closed_at,COALESCE(r.business_key,i.business_key) AS business_key FROM workflow_runs r JOIN workflow_instances i ON i.id=r.workflow_instance_id LEFT JOIN workflow_run_summaries s ON s.id=r.id AND r.import_source='waterline_v1_projection' WHERE r.namespace=$1 AND i.namespace=$2 AND ($3 IS NULL OR r.workflow_type=$4) AND ($5 IS NULL OR CASE WHEN r.status IN ('pending','running','waiting') THEN 'running' WHEN r.status='completed' THEN 'completed' ELSE 'failed' END=$6 OR r.status=$7) AND ($8 IS NULL OR r.workflow_instance_id LIKE $9 OR COALESCE(r.business_key,i.business_key) LIKE $10) ORDER BY COALESCE(s.sort_timestamp,r.started_at) DESC,r.id DESC LIMIT $11 OFFSET $12";
 
 // Preserve decimal micro/nanosecond ordering across PHP SQL UTC and earlier
 // native RFC3339 UTC strings without SQLite floating-point date conversion.
+// A Waterline v1 projection sorts by its summary's sort time, as PHP's
+// summary-ordered list places it; other runs keep their start time.
 pub(super) const SQLITE_VISIBILITY_PAGE: &str = r#"
 WITH runs AS (
     SELECT r.id,r.workflow_instance_id,r.workflow_type,r.queue,r.status,r.compatibility,r.started_at,r.closed_at,COALESCE(r.business_key,i.business_key) AS business_key,
-        replace(replace(replace(r.started_at,'T',' '),'Z',''),'+00:00','') AS _dw_started_utc
+        replace(replace(replace(COALESCE(s.sort_timestamp,r.started_at),'T',' '),'Z',''),'+00:00','') AS _dw_started_utc
     FROM workflow_runs r JOIN workflow_instances i ON i.id=r.workflow_instance_id
+    LEFT JOIN workflow_run_summaries s ON s.id=r.id AND r.import_source='waterline_v1_projection'
     WHERE r.namespace=$1 AND i.namespace=$2 AND ($3 IS NULL OR r.workflow_type=$4)
         AND ($5 IS NULL OR CASE WHEN r.status IN ('pending','running','waiting') THEN 'running' WHEN r.status='completed' THEN 'completed' ELSE 'failed' END=$6 OR r.status=$7)
         AND ($8 IS NULL OR r.workflow_instance_id LIKE $9 OR COALESCE(r.business_key,i.business_key) LIKE $10)
@@ -275,10 +278,10 @@ where
             };
             workflows.push(json!({"workflow_id":DB::string(row,"workflow_instance_id")?, "run_id":run_id,
                 "workflow_type":DB::string(row,"workflow_type")?, "business_key":DB::optional_string(row,"business_key")?,
-                "status":status, "status_bucket":bucket, "task_queue":DB::string(row,"queue")?,
+                "status":status, "status_bucket":bucket, "task_queue":DB::optional_string(row,"queue")?,
                 "is_terminal":bucket!="running", "compatibility":null, "compatibility_status":"compatible",
                 "compatibility_supported_in_fleet":true, "compatibility_fleet_reason":null,
-                "started_at":DB::instant(row,"started_at")?, "closed_at":DB::optional_instant(row,"closed_at")?,
+                "started_at":super::task_queues::json_time(DB::optional_instant(row,"started_at")?), "closed_at":super::task_queues::json_time(DB::optional_instant(row,"closed_at")?),
                 "search_attributes":search_attributes}));
         }
         let next =
diff --git a/rust/src/runtime/waterline_import.rs b/rust/src/runtime/waterline_import.rs
new file mode 100644
index 000000000..e42b1920a
--- /dev/null
+++ b/rust/src/runtime/waterline_import.rs
@@ -0,0 +1,983 @@
+//! `LegacyV1ProjectionController` and `LegacyV1Projection`, as published
+//! Server 2.11.1 serves them: a Waterline v1 flow detail projected into one
+//! read-only standalone run. The identity is a deterministic hash of the
+//! source id and the qualified v1 id; the report, events, dedupe key and
+//! summary follow PHP's construction, including Eloquent storing ordinary
+//! date columns as the source's wall-clock time and history times as UTC.
+use super::execution::Runtime;
+use super::php_value::{Flags, Key, Php, PhpArray};
+use super::store::now;
+use super::workflow_import::{Stamp, parse_time};
+use super::Result;
+use axum::http::StatusCode;
+use chrono::{DateTime, Utc};
+use serde_json::{Value, json};
+use sha2::{Digest, Sha256};
+
+pub(super) const IMPORT_SOURCE: &str = "waterline_v1_projection";
+pub(super) const ENGINE_SOURCE: &str = "v1_projection";
+pub(super) const SCHEMA: &str = "durable-workflow.v2.waterline-v1-projection.contract";
+const REPORT_SCHEMA: &str = "durable-workflow.v2.waterline-v1-projection.report";
+pub(super) const VERSION: i64 = 1;
+const OPAQUE_REASON: &str = "legacy_php_serialization_not_portable";
+const OPAQUE_REMEDIATION: &str =
+    "Treat the preserved value as opaque; export decoded JSON from the source application if portable payload access is required.";
+
+/// A PHP array literal with string keys, in order.
+fn object(entries: Vec<(&str, Php)>) -> Php {
+    Php::Array(PhpArray(entries.into_iter().map(|(key, value)| (Key::of(key), value)).collect()))
+}
+
+fn list(items: Vec<Php>) -> Php {
+    Php::Array(PhpArray(items.into_iter().enumerate().map(|(index, value)| (Key::Int(index as i64), value)).collect()))
+}
+
+fn text(value: impl Into<String>) -> Php {
+    Php::Str(value.into())
+}
+
+fn optional(value: Option<String>) -> Php {
+    value.map_or(Php::Null, Php::Str)
+}
+
+/// PHP's `trim()` with its default characters.
+fn php_trim(value: &str) -> &str {
+    value.trim_matches([' ', '\t', '\n', '\r', '\0', '\x0b'])
+}
+
+/// `LegacyV1Projection::string`: a string that is not blank, trimmed.
+fn string(value: Option<&Php>) -> Option<String> {
+    match value {
+        Some(Php::Str(text)) if !php_trim(text).is_empty() => Some(php_trim(text).to_owned()),
+        _ => None,
+    }
+}
+
+/// PHP's `$array[$key] ?? $default`: null and absent both fall through.
+fn coalesce<'a>(array: &'a PhpArray, keys: &[&str]) -> Option<&'a Php> {
+    keys.iter().find_map(|key| array.get(key).filter(|value| !matches!(value, Php::Null)))
+}
+
+/// PHP's `(string)` of a float: `precision` 14, as `%.14G` prints it.
+fn float_string(value: f64) -> String {
+    if value.is_nan() {
+        return "NAN".into();
+    }
+    if value.is_infinite() {
+        return if value > 0.0 { "INF".into() } else { "-INF".into() };
+    }
+    if value == 0.0 {
+        return if value.is_sign_negative() { "-0".into() } else { "0".into() };
+    }
+    let scientific = format!("{value:.13e}");
+    let (mantissa, exponent) = scientific.split_once('e').expect("scientific notation");
+    let exponent: i32 = exponent.parse().expect("exponent");
+    let (sign, digits) = mantissa.strip_prefix('-').map_or(("", mantissa), |digits| ("-", digits));
+    let digits: String = digits.chars().filter(char::is_ascii_digit).collect();
+    let digits = digits.trim_end_matches('0');
+    let digits = if digits.is_empty() { "0" } else { digits };
+    if exponent < -4 || exponent >= 14 {
+        let fraction = if digits.len() > 1 { &digits[1..] } else { "0" };
+        return format!("{sign}{}.{fraction}E{}{}", &digits[..1], if exponent < 0 { '-' } else { '+' }, exponent.abs());
+    }
+    if exponent < 0 {
+        return format!("{sign}0.{}{digits}", "0".repeat((-exponent - 1) as usize));
+    }
+    let point = exponent as usize + 1;
+    if digits.len() <= point {
+        format!("{sign}{digits}{}", "0".repeat(point - digits.len()))
+    } else {
+        format!("{sign}{}.{}", &digits[..point], &digits[point..])
+    }
+}
+
+/// `is_scalar($value) ? (string) $value : null`.
+fn scalar_string(value: Option<&Php>) -> Option<String> {
+    match value? {
+        Php::Str(text) => Some(text.clone()),
+        Php::Int(number) => Some(number.to_string()),
+        Php::Float(number) => Some(float_string(*number)),
+        Php::Bool(true) => Some("1".into()),
+        Php::Bool(false) => Some(String::new()),
+        _ => None,
+    }
+}
+
+/// `LegacyV1Projection::timestamp`: a non-blank string Carbon can parse.
+fn timestamp(value: Option<&Php>) -> Option<Stamp> {
+    match value {
+        Some(Php::Str(text)) if !php_trim(text).is_empty() => parse_time(text).ok(),
+        _ => None,
+    }
+}
+
+/// Carbon's `toJSON()`: the UTC instant with microseconds.
+fn json_time(stamp: Option<Stamp>) -> Option<String> {
+    stamp.map(|stamp| stamp.utc.format("%Y-%m-%dT%H:%M:%S%.6fZ").to_string())
+}
+
+fn sha256(text: &str) -> String {
+    super::bundle_verifier::hex(&Sha256::digest(text.as_bytes()))
+}
+
+/// `rows`: the array members of a list, reindexed.
+fn rows(value: Option<&Php>) -> Vec<PhpArray> {
+    match value {
+        Some(Php::Array(array)) => array.values().filter_map(|value| value.array().cloned()).collect(),
+        _ => Vec::new(),
+    }
+}
+
+fn error(reason: &str, message: &str, remediation: &str) -> Php {
+    object(vec![("reason", text(reason)), ("message", text(message)), ("remediation", text(remediation))])
+}
+
+fn unsupported(field: &str, reason: &str, remediation: &str) -> Php {
+    object(vec![("field", text(field)), ("reason", text(reason)), ("remediation", text(remediation))])
+}
+
+/// `opaquePayload`.
+fn opaque(value: Option<&Php>) -> Php {
+    let value = value.filter(|value| !matches!(value, Php::Null));
+    object(vec![
+        ("available", Php::Bool(value.is_some())),
+        ("encoding", text("php-serialize")),
+        ("value", optional(scalar_string(value))),
+        ("portable", Php::Bool(false)),
+        ("unsupported_reason", text(OPAQUE_REASON)),
+        ("remediation", text(OPAQUE_REMEDIATION)),
+    ])
+}
+
+/// `mapStatus`.
+fn map_status(status: &str) -> Option<&'static str> {
+    Some(match status {
+        "created" | "pending" => "pending",
+        "running" => "running",
+        "waiting" => "waiting",
+        "completed" | "continued" => "completed",
+        "failed" => "failed",
+        "cancelled" => "cancelled",
+        "terminated" => "terminated",
+        _ => return None,
+    })
+}
+
+/// `statusBucket`.
+fn status_bucket(status: &str) -> &'static str {
+    match status {
+        "completed" => "completed",
+        "failed" | "cancelled" | "terminated" => "failed",
+        _ => "running",
+    }
+}
+
+/// `mappedIdentity`. The source id passed its URL-safe pattern, so Laravel's
+/// `Str::lower`, `replaceMatches`, `trim('-')` and `limit(32, '')` act on
+/// ASCII only.
+pub(super) fn mapped_identity(source_id: &str, qualified_id: &str) -> (String, String, String) {
+    let key = format!("{}\0{}", php_trim(source_id), php_trim(qualified_id));
+    let lowered = source_id.to_lowercase();
+    let mut slug = String::new();
+    let mut replaced = false;
+    for character in lowered.chars() {
+        if character.is_ascii_lowercase() || character.is_ascii_digit() || matches!(character, '.' | '_' | '-') {
+            slug.push(character);
+            replaced = false;
+        } else if !replaced {
+            slug.push('-');
+            replaced = true;
+        }
+    }
+    let mut slug: String = slug.trim_matches('-').chars().take(32).collect::<String>().trim_end().to_owned();
+    if slug.is_empty() {
+        slug = "source".into();
+    }
+    (
+        format!("v1:{slug}:{}", &sha256(&format!("workflow\0{key}"))[..24]),
+        sha256(&format!("run\0{key}"))[..26].to_owned(),
+        sha256(&format!("import\0{key}")),
+    )
+}
+
+/// One projected history event before it is stored.
+pub(crate) struct Event {
+    pub(super) id: String,
+    pub(super) sequence: i64,
+    pub(super) event_type: &'static str,
+    pub(super) recorded_at: Option<Stamp>,
+    pub(super) payload: Php,
+}
+
+/// A valid source, normalized as `LegacyV1Projection::normalize` does.
+pub(crate) struct Normalized {
+    pub(super) namespace: String,
+    pub(super) workflow_id: String,
+    pub(super) run_id: String,
+    pub(super) import_id: String,
+    pub(super) dedupe_key: String,
+    pub(super) class: String,
+    pub(super) connection: Option<String>,
+    pub(super) queue: Option<String>,
+    pub(super) status: &'static str,
+    pub(super) closed_reason: Option<String>,
+    pub(super) started_at: Option<Stamp>,
+    pub(super) last_progress_at: Option<Stamp>,
+    pub(super) closed_at: Option<Stamp>,
+    pub(super) exception_count: i64,
+    pub(super) events: Vec<Event>,
+    pub(super) history_size_bytes: i64,
+    identity: Php,
+    unsupported: Php,
+}
+
+pub(crate) enum Outcome {
+    Invalid { errors: Vec<Php> },
+    Valid(Box<Normalized>),
+}
+
+/// `LegacyV1Projection::normalize`.
+pub(crate) fn normalize(source_id: &str, source: &PhpArray, namespace: Option<&str>) -> Outcome {
+    let source_id = php_trim(source_id).to_owned();
+    let namespace = namespace.map(php_trim).filter(|namespace| !namespace.is_empty()).unwrap_or("default").to_owned();
+    let qualified = string(coalesce(source, &["operator_id", "id"]));
+    let legacy = scalar_string(source.get("legacy_id"));
+    let class = string(source.get("class"));
+    let source_status = string(source.get("status")).unwrap_or_default().to_lowercase();
+    let status = map_status(&source_status);
+    let mut errors = Vec::new();
+    let source_id_valid = (1..=64).contains(&source_id.len())
+        && source_id.bytes().all(|byte| byte.is_ascii_alphanumeric() || b"._:-".contains(&byte));
+    if !source_id_valid {
+        errors.push(error("invalid_source_id", "source_id must be 1-64 stable URL-safe characters.",
+            "Use a deployment-stable identifier such as legacy-prod-us-east."));
+    }
+    let qualified_valid = qualified.as_deref()
+        .and_then(|qualified| qualified.strip_prefix("v1:"))
+        .is_some_and(|rest| !rest.is_empty() && !rest.contains('\n'));
+    if !qualified_valid {
+        errors.push(error("unqualified_v1_identity", "The Waterline workflow must carry operator_id or id in v1:<workflow-id> form.",
+            "Export the detail from the Waterline hybrid migration API."));
+    }
+    if let (Some(legacy), Some(qualified)) = (&legacy, &qualified)
+        && *qualified != format!("v1:{legacy}")
+    {
+        errors.push(error("v1_identity_mismatch", "legacy_id does not match the qualified Waterline identity.",
+            "Re-export the workflow detail without editing its identity fields."));
+    }
+    if !matches!(source.get("engine_source"), Some(Php::Str(engine)) if engine == "v1") {
+        errors.push(error("unsupported_source_engine", "Only Waterline engine_source=v1 projections are accepted.",
+            "Use embedded-v2 import for v2-origin history bundles."));
+    }
+    if class.is_none() {
+        errors.push(error("missing_v1_workflow_class", "The Waterline projection does not identify the workflow class.",
+            "Export the complete v1 workflow detail response."));
+    }
+    if status.is_none() {
+        errors.push(error("unsupported_v1_status", "The v1 workflow status cannot be represented by the standalone v2 visibility model.",
+            "Complete or normalize the workflow on v1, then export it again."));
+    }
+    let (Some(qualified), Some(class), Some(status), true) = (qualified, class, status, errors.is_empty()) else {
+        return Outcome::Invalid { errors };
+    };
+
+    let (workflow_id, run_id, import_id) = mapped_identity(&source_id, &qualified);
+    let connection = string(source.get("connection"));
+    let queue = string(source.get("queue"));
+    let logs = rows(source.get("logs"));
+    let signals = rows(source.get("signals"));
+    let exceptions = rows(source.get("exceptions"));
+    let unsupported = unsupported_fields(source, &logs, &signals, &exceptions, &source_status);
+    let legacy_workflow_id = legacy.clone().unwrap_or_else(|| qualified[3..].to_owned());
+    let waterline = object(vec![
+        ("source_id", text(&source_id)),
+        ("qualified_workflow_id", text(&qualified)),
+        ("legacy_workflow_id", text(legacy_workflow_id)),
+    ]);
+    let identity = object(vec![
+        ("waterline", waterline.clone()),
+        ("standalone", object(vec![
+            ("namespace", text(&namespace)),
+            ("workflow_id", text(&workflow_id)),
+            ("run_id", text(&run_id)),
+        ])),
+        ("relationship", text("deterministic_source_qualified_projection")),
+        ("collision_policy", text("reject_without_overwrite")),
+    ]);
+    let origin = object(vec![
+        ("engine_source", text("v1")),
+        ("engine_version", text(string(source.get("engine_version")).unwrap_or_else(|| "1.x".into()))),
+        ("execution_engine", text(string(source.get("execution_engine")).unwrap_or_else(|| "finish-on-v1".into()))),
+    ]);
+    let task_queue = object(vec![
+        ("connection", optional(connection.clone())),
+        ("name", optional(queue.clone())),
+        ("execution_owner", text("v1")),
+        ("standalone_dispatch", text("disabled")),
+    ]);
+    let started_at = timestamp(source.get("created_at"));
+    let last_progress_at = timestamp(source.get("updated_at")).or(started_at);
+    let terminal = matches!(status, "completed" | "failed" | "cancelled" | "terminated");
+    let closed_at = if terminal { last_progress_at } else { None };
+    let raw = |key: &str| source.get(key).cloned().unwrap_or(Php::Null);
+    let rows_value = |rows: &[PhpArray]| list(rows.iter().cloned().map(Php::Array).collect());
+    let for_hash = object(vec![
+        ("origin", origin.clone()),
+        ("identity", waterline),
+        ("class", text(&class)),
+        ("status", text(&source_status)),
+        ("connection", optional(connection.clone())),
+        ("queue", optional(queue.clone())),
+        ("arguments", raw("arguments")),
+        ("output", raw("output")),
+        ("logs", rows_value(&logs)),
+        ("signals", rows_value(&signals)),
+        ("exceptions", rows_value(&exceptions)),
+        ("created_at", optional(json_time(started_at))),
+        ("updated_at", optional(json_time(last_progress_at))),
+    ]);
+    let dedupe_key = sha256(&for_hash.canonical().encode(Flags { unescaped_slashes: true, ..Flags::default() }));
+    let migration = object(vec![
+        ("origin", origin),
+        ("identity", identity.clone()),
+        ("task_queue_context", task_queue),
+        ("unsupported_fields", unsupported.clone()),
+    ]);
+    let events = events(source, &logs, &signals, &exceptions, migration, status, started_at, last_progress_at, &run_id);
+    // `strlen(json_encode($event, JSON_UNESCAPED_SLASHES))` over each event
+    // as PHP holds it: type, Carbon time, payload, sequence and id.
+    let history_size_bytes = events.iter().map(|event| object(vec![
+        ("event_type", text(event.event_type)),
+        ("recorded_at", optional(json_time(event.recorded_at))),
+        ("payload", event.payload.clone()),
+        ("sequence", Php::Int(event.sequence)),
+        ("id", text(&event.id)),
+    ]).encode(Flags { unescaped_slashes: true, ..Flags::default() }).len() as i64).sum();
+    Outcome::Valid(Box::new(Normalized {
+        namespace,
+        workflow_id,
+        run_id,
+        import_id,
+        dedupe_key,
+        class,
+        connection,
+        queue,
+        status,
+        closed_reason: terminal.then(|| source_status.clone()),
+        started_at,
+        last_progress_at,
+        closed_at,
+        exception_count: exceptions.len() as i64,
+        events,
+        history_size_bytes,
+        identity,
+        unsupported,
+    }))
+}
+
+/// `unsupportedFields`.
+fn unsupported_fields(source: &PhpArray, logs: &[PhpArray], signals: &[PhpArray], exceptions: &[PhpArray], status: &str) -> Php {
+    let mut fields = vec![
+        unsupported("runtime.replay", "v1_history_not_replayable_as_v2",
+            "Retain the v1 application storage for v1 replay; use the projected typed history for operator inspection only."),
+        unsupported("timers", "legacy_timer_state_not_exposed_by_waterline",
+            "Inspect timers in the source application and allow open executions to finish on v1."),
+    ];
+    for field in ["arguments", "output"] {
+        if source.get(field).is_some_and(|value| !matches!(value, Php::Null)) {
+            fields.push(unsupported(&format!("payloads.{field}"), OPAQUE_REASON, OPAQUE_REMEDIATION));
+        }
+    }
+    for (field, rows, key) in [
+        ("payloads.activity_results", logs, "result"),
+        ("payloads.signal_arguments", signals, "arguments"),
+        ("payloads.exception_values", exceptions, "exception"),
+    ] {
+        if rows.iter().any(|row| row.get(key).is_some_and(|value| !matches!(value, Php::Null))) {
+            fields.push(unsupported(field, OPAQUE_REASON, OPAQUE_REMEDIATION));
+        }
+    }
+    if !matches!(status, "completed" | "continued" | "failed" | "cancelled" | "terminated") {
+        fields.push(unsupported("runtime.execution", "finish_on_v1_execution_not_transferable",
+            "Keep the v1 worker running until completion; the standalone projection is deliberately read-only and never dispatches work."));
+    }
+    list(fields)
+}
+
+/// `events`: started, then each log, signal and exception, then the
+/// terminal event, ordered by boundary, whole-second time (untimed first)
+/// and source order, with sequence and id assigned after sorting.
+#[allow(clippy::too_many_arguments)]
+fn events(source: &PhpArray, logs: &[PhpArray], signals: &[PhpArray], exceptions: &[PhpArray], migration: Php,
+    status: &str, started_at: Option<Stamp>, last_progress_at: Option<Stamp>, run_id: &str) -> Vec<Event> {
+    let field = |row: &PhpArray, key: &str| row.get(key).cloned().unwrap_or(Php::Null);
+    let mut pending: Vec<(u8, i64, &'static str, Option<Stamp>, Php)> = vec![(0, 0, "WorkflowStarted", started_at, object(vec![
+        ("migration_projection", migration),
+        ("legacy_payloads", object(vec![("arguments", opaque(source.get("arguments")))])),
+    ]))];
+    for (index, log) in logs.iter().enumerate() {
+        pending.push((1, 100 + index as i64, "ActivityCompleted", timestamp(coalesce(log, &["created_at", "now"])), object(vec![
+            ("migration_projection", object(vec![
+                ("source_record", text("workflow_log")),
+                ("legacy_id", field(log, "id")),
+                ("legacy_index", field(log, "index")),
+            ])),
+            ("activity", object(vec![
+                ("class", field(log, "class")),
+                ("logical_time", field(log, "now")),
+                ("result", opaque(log.get("result"))),
+            ])),
+        ])));
+    }
+    for (index, signal) in signals.iter().enumerate() {
+        pending.push((1, 200 + index as i64, "SignalReceived", timestamp(coalesce(signal, &["created_at", "received_at"])), object(vec![
+            ("migration_projection", object(vec![
+                ("source_record", text("workflow_signal")),
+                ("legacy_id", field(signal, "id")),
+            ])),
+            ("signal_name", coalesce(signal, &["name", "method"]).cloned().unwrap_or(Php::Null)),
+            ("arguments", opaque(signal.get("arguments"))),
+        ])));
+    }
+    for (index, exception) in exceptions.iter().enumerate() {
+        pending.push((1, 300 + index as i64, "ActivityFailed", timestamp(exception.get("created_at")), object(vec![
+            ("migration_projection", object(vec![
+                ("source_record", text("workflow_exception")),
+                ("legacy_id", field(exception, "id")),
+            ])),
+            ("exception", object(vec![
+                ("class", field(exception, "class")),
+                ("value", opaque(exception.get("exception"))),
+            ])),
+        ])));
+    }
+    let terminal = match status {
+        "completed" => Some("WorkflowCompleted"),
+        "failed" => Some("WorkflowFailed"),
+        "cancelled" => Some("WorkflowCancelled"),
+        "terminated" => Some("WorkflowTerminated"),
+        _ => None,
+    };
+    if let Some(event_type) = terminal {
+        pending.push((2, i64::MAX, event_type, last_progress_at, object(vec![
+            ("migration_projection", object(vec![
+                ("source_status", source.get("status").cloned().unwrap_or(Php::Null)),
+                ("execution_owner", text("v1")),
+            ])),
+            ("legacy_payloads", object(vec![("output", opaque(source.get("output")))])),
+        ])));
+    }
+    // Carbon's getTimestamp: whole seconds; PHP_INT_MIN for an untimed event.
+    pending.sort_by_key(|(boundary, order, _, at, _)| (*boundary, at.map_or(i64::MIN, |at| at.utc.timestamp()), *order));
+    pending
+        .into_iter()
+        .enumerate()
+        .map(|(index, (_, _, event_type, recorded_at, payload))| {
+            let sequence = index as i64 + 1;
+            Event {
+                id: sha256(&format!("{run_id}\0{sequence}\0{event_type}"))[..26].to_owned(),
+                sequence,
+                event_type,
+                recorded_at,
+                payload,
+            }
+        })
+        .collect()
+}
+
+/// `report`: the projection report, with the first error's reason, message
+/// and remediation at the top of a rejection, then `extra`.
+fn report(outcome: &Outcome, status: &str, extra: Vec<(&str, Value)>) -> Value {
+    let (identity, dedupe, unsupported, errors) = match outcome {
+        Outcome::Invalid { errors } => (Value::Null, Value::Null, json!([]), list(errors.clone()).to_json()),
+        Outcome::Valid(normalized) => (normalized.identity.to_json(), json!(normalized.dedupe_key),
+            normalized.unsupported.to_json(), json!([])),
+    };
+    let mut body = json!({"schema": REPORT_SCHEMA, "schema_version": VERSION, "status": status, "projection_only": true,
+        "identity": identity, "dedupe_key": dedupe, "unsupported_fields": unsupported, "errors": errors});
+    if status == "rejected"
+        && let Some(first) = body["errors"].get(0).cloned()
+    {
+        for key in ["reason", "message", "remediation"] {
+            body[key] = first[key].clone();
+        }
+    }
+    for (key, value) in extra {
+        body[key] = value;
+    }
+    body
+}
+
+/// What the importer needs to know about rows already holding the identity.
+pub(crate) struct Existing {
+    pub(super) run: Option<ExistingRun>,
+    pub(super) instance_namespace: Option<Option<String>>,
+}
+
+pub(crate) struct ExistingRun {
+    pub(super) workflow_instance_id: String,
+    pub(super) import_source: Option<String>,
+    pub(super) import_id: Option<String>,
+    pub(super) dedupe_key: Option<String>,
+    pub(super) namespace: Option<String>,
+    pub(super) imported_at: Option<DateTime<Utc>>,
+}
+
+/// The validated request: `source_id` required|string|max:64, `workflow`
+/// required|array, `dry_run` nullable|boolean, after Laravel's TrimStrings
+/// and ConvertEmptyStringsToNull.
+fn validate(body: &PhpArray) -> std::result::Result<(String, PhpArray, bool), Value> {
+    let present = |value: Option<&Php>| match value {
+        None | Some(Php::Null) => false,
+        Some(Php::Str(text)) => !text.trim().is_empty(),
+        Some(Php::Array(array)) => !array.is_empty(),
+        Some(_) => true,
+    };
+    let mut errors: Vec<(String, Vec<String>)> = Vec::new();
+    let source = body.get("source_id");
+    let mut source_messages = Vec::new();
+    if !present(source) {
+        source_messages.push("The source id field is required.".to_owned());
+    } else {
+        if !matches!(source, Some(Php::Str(_))) {
+            source_messages.push("The source id field must be a string.".to_owned());
+        }
+        match source {
+            Some(Php::Array(array)) if array.len() > 64 => {
+                source_messages.push("The source id field must not have more than 64 items.".to_owned());
+            }
+            Some(Php::Str(text)) if text.chars().count() > 64 => {
+                source_messages.push("The source id field must not be greater than 64 characters.".to_owned());
+            }
+            other if !matches!(other, Some(Php::Array(_)) | Some(Php::Str(_)))
+                && scalar_string(other).is_some_and(|text| text.chars().count() > 64) =>
+            {
+                source_messages.push("The source id field must not be greater than 64 characters.".to_owned());
+            }
+            _ => {}
+        }
+    }
+    errors.push(("source_id".into(), source_messages));
+    let workflow = body.get("workflow");
+    let workflow_messages = if !present(workflow) {
+        vec!["The workflow field is required.".to_owned()]
+    } else if !matches!(workflow, Some(Php::Array(_))) {
+        vec!["The workflow field must be an array.".to_owned()]
+    } else {
+        Vec::new()
+    };
+    errors.push(("workflow".into(), workflow_messages));
+    let dry_run = body.get("dry_run");
+    let boolean = match dry_run {
+        None | Some(Php::Null) => Some(false),
+        Some(Php::Bool(value)) => Some(*value),
+        Some(Php::Int(0)) => Some(false),
+        Some(Php::Int(1)) => Some(true),
+        Some(Php::Str(text)) if text == "0" => Some(false),
+        Some(Php::Str(text)) if text == "1" => Some(true),
+        _ => None,
+    };
+    errors.push(("dry_run".into(), if boolean.is_none() { vec!["The dry run field must be true or false.".to_owned()] } else { Vec::new() }));
+    if let Some(super::RuntimeError::Protocol { response, .. }) = super::laravel_validation::failure_messages(errors) {
+        return Err(response);
+    }
+    let (Some(Php::Str(source_id)), Some(Php::Array(workflow)), Some(dry_run)) = (source, workflow, boolean) else {
+        unreachable!("validated request");
+    };
+    Ok((source_id.clone(), workflow.clone(), dry_run))
+}
+
+/// A path segment percent-decoded, as the router decodes its parameters.
+fn decoded(segment: &str) -> Option<String> {
+    let bytes = segment.as_bytes();
+    let mut out = Vec::with_capacity(bytes.len());
+    let mut index = 0;
+    while index < bytes.len() {
+        if bytes[index] == b'%' {
+            let hex = std::str::from_utf8(bytes.get(index + 1..index + 3)?).ok()?;
+            out.push(u8::from_str_radix(hex, 16).ok()?);
+            index += 3;
+        } else {
+            out.push(bytes[index]);
+            index += 1;
+        }
+    }
+    String::from_utf8(out).ok()
+}
+
+/// `projectedV1OperationResponse` for the control operations PHP refuses
+/// on a projection before reading their bodies: signal, update, cancel,
+/// terminate, repair and archive check the instance's current run; redrive
+/// checks its source run. A query is refused once its `input` passes
+/// validation, as PHP validates it first. Cooperative cancellation refuses
+/// in its own transaction.
+pub(super) async fn read_only_guard(request: axum::extract::Request, next: axum::middleware::Next) -> axum::response::Response {
+    use axum::response::IntoResponse;
+    use super::control_plane::Operation;
+    if request.method() != axum::http::Method::POST {
+        return next.run(request).await;
+    }
+    let path = request.uri().path().to_owned();
+    let segments: Vec<&str> = path.trim_start_matches('/').split('/').collect();
+    let (workflow, run, operation, name) = match segments.as_slice() {
+        ["api", "workflows", workflow, operation @ ("cancel" | "terminate" | "repair" | "archive")] => (*workflow, None, *operation, None),
+        ["api", "workflows", workflow, operation @ ("signal" | "query" | "update"), name] => (*workflow, None, *operation, Some(*name)),
+        ["api", "workflows", workflow, "runs", run, operation @ ("cancel" | "terminate" | "repair" | "archive" | "redrive")] => {
+            (*workflow, Some(*run), *operation, None)
+        }
+        ["api", "workflows", workflow, "runs", run, operation @ ("signal" | "query" | "update"), name] => {
+            (*workflow, Some(*run), *operation, Some(*name))
+        }
+        _ => return next.run(request).await,
+    };
+    let (Some(runtime), Some(workflow)) = (request.extensions().get::<Runtime>().cloned(), decoded(workflow)) else {
+        return next.run(request).await;
+    };
+    let name = name.and_then(decoded).unwrap_or_default();
+    let projected = match (operation, run.and_then(decoded)) {
+        ("redrive", Some(run)) => runtime.projected_run(&workflow, &run).await,
+        _ => runtime.projected_current_run(&workflow).await,
+    };
+    let Ok(Some(run_id)) = projected else {
+        return next.run(request).await;
+    };
+    let request = if operation == "query" {
+        // `input` nullable|array: an invalid input answers its validation error.
+        let (parts, body) = request.into_parts();
+        let Ok(bytes) = axum::body::to_bytes(body, usize::MAX).await else {
+            return next.run(axum::extract::Request::from_parts(parts, axum::body::Body::empty())).await;
+        };
+        let input_valid = match super::php_value::request_body(&bytes).get("input") {
+            None | Some(Php::Null | Php::Array(_)) => true,
+            Some(_) => false,
+        };
+        let request = axum::extract::Request::from_parts(parts, axum::body::Body::from(bytes));
+        if !input_valid {
+            return next.run(request).await;
+        }
+        request
+    } else {
+        request
+    };
+    drop(request);
+    let body = json!({
+        "message": format!("Operation [{operation}] is unavailable because this execution is a read-only projection owned by the source v1 runtime."),
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": workflow,
+        "run_id": run_id,
+        "operation": operation,
+        "execution_owner": "v1",
+    });
+    let body = match operation {
+        "signal" => Operation::Signal(&name).response(body),
+        "query" => Operation::Query(&name).response(body),
+        "update" => Operation::Update(&name).response(body),
+        "cancel" => Operation::Cancel.response(body),
+        "terminate" => Operation::Terminate.response(body),
+        "repair" => Operation::Repair.response(body),
+        "archive" => Operation::Archive.response(body),
+        _ => body,
+    };
+    (StatusCode::CONFLICT, axum::Json(body)).into_response()
+}
+
+impl Runtime {
+    /// `LegacyV1ProjectionController::store` once the gates have passed.
+    pub(crate) async fn import_waterline_v1(&self, body: &[u8]) -> Result<(StatusCode, Value)> {
+        let operation = || super::control_plane::Operation::ImportWaterlineV1;
+        let request = super::php_value::request_body(body);
+        let (source_id, workflow, dry_run) = match validate(&request) {
+            Ok(validated) => validated,
+            Err(response) => return Ok((StatusCode::UNPROCESSABLE_ENTITY, operation().response(response))),
+        };
+        let namespace = self.namespace_name();
+        // Hashing and JSON encoding of the whole source stay off the async workers.
+        let outcome = tokio::task::spawn_blocking(move || normalize(&source_id, &workflow, Some(&namespace)))
+            .await
+            .map_err(|_| super::refuse(StatusCode::SERVICE_UNAVAILABLE, "waterline_import_unavailable"))?;
+        let answer = |status: &str, extra: Vec<(&str, Value)>| {
+            let code = match status {
+                "projected" => StatusCode::CREATED,
+                "already_projected" | "dry_run" => StatusCode::OK,
+                _ => StatusCode::CONFLICT,
+            };
+            (code, operation().response(report(&outcome, status, extra)))
+        };
+        let Outcome::Valid(normalized) = &outcome else {
+            return Ok(answer("rejected", Vec::new()));
+        };
+        let existing = self.waterline_existing(&normalized.workflow_id, &normalized.run_id).await?;
+        if existing.run.is_some() || existing.instance_namespace.is_some() {
+            let same = existing.run.as_ref().is_some_and(|run| existing.instance_namespace.is_some()
+                && run.workflow_instance_id == normalized.workflow_id
+                && run.import_source.as_deref() == Some(IMPORT_SOURCE)
+                && run.import_id.as_deref() == Some(normalized.import_id.as_str())
+                && run.dedupe_key.as_deref() == Some(normalized.dedupe_key.as_str()));
+            let instance_namespace = existing.instance_namespace.clone().flatten();
+            let run_namespace = existing.run.as_ref().and_then(|run| run.namespace.clone());
+            if same && run_namespace.as_deref() == Some(normalized.namespace.as_str())
+                && instance_namespace.as_deref() == Some(normalized.namespace.as_str())
+            {
+                let imported = existing.run.as_ref().and_then(|run| run.imported_at);
+                return Ok(answer("already_projected", vec![("imported_at", super::task_queues::json_time(imported))]));
+            }
+            if same {
+                let stored = instance_namespace.filter(|namespace| Some(namespace) == run_namespace.as_ref());
+                let mut identity = normalized.identity.to_json();
+                identity["standalone"]["namespace"] = json!(stored);
+                let (reason, message, remediation) = match &stored {
+                    None => ("v1_projection_storage_inconsistent".to_owned(),
+                        "The existing v1 projection has inconsistent instance and run namespaces.".to_owned(),
+                        "Repair or remove the inconsistent projection rows before repeating the import.".to_owned()),
+                    Some(stored) => ("v1_projection_namespace_collision".to_owned(),
+                        "This v1 identity is already projected in a different standalone namespace.".to_owned(),
+                        format!("Repeat the operation in the existing {stored} namespace, or choose a different stable source_id for an independent projection.")),
+                };
+                return Ok(answer("rejected", vec![("identity", identity), ("requested_namespace", json!(normalized.namespace)),
+                    ("reason", json!(reason)), ("message", json!(message)), ("remediation", json!(remediation))]));
+            }
+            let changed = existing.run.as_ref().is_some_and(|run| run.import_source.as_deref() == Some(IMPORT_SOURCE));
+            return Ok(answer("rejected", if changed {
+                vec![("reason", json!("v1_projection_changed")),
+                    ("message", json!("This v1 identity was already projected from different source state.")),
+                    ("remediation", json!("Inspect the existing projection and resolve it before importing a different snapshot of the same v1 identity."))]
+            } else {
+                vec![("reason", json!("native_v2_identity_collision")),
+                    ("message", json!("The mapped standalone identity is already owned by a native or unrelated v2 execution.")),
+                    ("remediation", json!("Choose a different stable source_id; the server will not overwrite the colliding v2 execution."))]
+            }));
+        }
+        if dry_run {
+            return Ok(answer("dry_run", Vec::new()));
+        }
+        let imported_at = now();
+        Ok(match self.waterline_write(normalized, imported_at).await {
+            Ok(()) => answer("projected", vec![("imported_at", super::task_queues::json_time(Some(imported_at)))]),
+            Err(collision) => {
+                let (reason, message, remediation) = if collision {
+                    ("native_v2_identity_collision", "The mapped standalone identity was claimed while the projection was being written.",
+                        "Retry with a different stable source_id; no existing execution was overwritten.")
+                } else {
+                    ("target_write_failed", "The standalone server could not persist the v1 projection transaction.",
+                        "Verify server storage readiness, then repeat the same idempotent operation.")
+                };
+                answer("rejected", vec![("reason", json!(reason)), ("message", json!(message)), ("remediation", json!(remediation))])
+            }
+        })
+    }
+}
+
+store_methods! {
+    /// `terminalFailurePayload` for a failed projection, which has no failure
+    /// snapshots: its activity failure summaries and their last message, or
+    /// null when it has none.
+    pub(crate) async fn projected_failure(&self, run_id: &str) -> Result<Value> {
+        let rows = Self::query("SELECT sequence,event_type,payload FROM workflow_history_events WHERE workflow_run_id=$1 AND event_type IN ('ActivityFailed','ActivityTimedOut') ORDER BY sequence")
+            .bind(run_id)
+            .fetch_all(&self.pool)
+            .await?;
+        let mut summaries = Vec::with_capacity(rows.len());
+        for row in &rows {
+            let payload = DB::document_row(row, "payload")?;
+            let mut summary = serde_json::Map::new();
+            summary.insert("event_sequence".into(), json!(DB::number(row, "sequence")?));
+            summary.insert("event_type".into(), json!(DB::string(row, "event_type")?));
+            for field in ["activity_type", "activity_class", "activity_execution_id", "activity_attempt_id", "failure_id",
+                "failure_category", "exception_type", "exception_class", "message"] {
+                if let Some(text) = payload[field].as_str().filter(|text| !text.is_empty()) {
+                    summary.insert(field.into(), json!(text));
+                }
+            }
+            if !payload["non_retryable"].is_null() {
+                summary.insert("non_retryable".into(), payload["non_retryable"].clone());
+            }
+            summaries.push(Value::Object(summary));
+        }
+        if summaries.is_empty() {
+            return Ok(Value::Null);
+        }
+        let message = summaries.iter().rev().find_map(|summary| summary["message"].as_str().map(str::to_owned));
+        let mut failure = serde_json::Map::new();
+        if let Some(message) = message {
+            failure.insert("message".into(), json!(message));
+        }
+        failure.insert("activity_failures".into(), Value::Array(summaries));
+        Ok(Value::Object(failure))
+    }
+
+    /// `LegacyV1Projection::metadataForRun` for a projected run: the started
+    /// event's projection context and the projection's own description.
+    pub(crate) async fn projection_metadata(&self, run_id: &str, imported_at: Option<DateTime<Utc>>, dedupe_key: Option<String>) -> Result<Value> {
+        let started = Self::query("SELECT payload FROM workflow_history_events WHERE workflow_run_id=$1 ORDER BY sequence LIMIT 1")
+            .bind(run_id)
+            .fetch_optional(&self.pool)
+            .await?
+            .map(|row| DB::document_row(&row, "payload"))
+            .transpose()?
+            .unwrap_or(Value::Null);
+        let migration = &started["migration_projection"];
+        let unsupported = migration["unsupported_fields"].as_array().cloned().unwrap_or_default();
+        Ok(json!({
+            "origin": migration["origin"],
+            "identity": migration["identity"],
+            "task_queue_context": migration["task_queue_context"],
+            "unsupported_fields": unsupported,
+            "projection": {"schema": SCHEMA, "version": VERSION, "read_only": true, "execution_owner": "v1",
+                "imported_at": super::task_queues::json_time(imported_at), "dedupe_key": dedupe_key},
+        }))
+    }
+
+    /// The current run of an instance in this namespace when it is a
+    /// Waterline v1 projection (`NamespaceWorkflowScope::currentRun`).
+    pub(crate) async fn projected_current_run(&self, workflow_id: &str) -> Result<Option<String>> {
+        Self::query("SELECT r.id FROM workflow_instances i JOIN workflow_runs r ON r.id=i.current_run_id WHERE i.id=$1 AND i.namespace=$2 AND r.import_source=$3")
+            .bind(workflow_id).bind(self.namespace.as_ref()).bind(IMPORT_SOURCE)
+            .fetch_optional(&self.pool).await?
+            .map(|row| DB::string(&row, "id")).transpose()
+    }
+
+    /// A selected run of this namespace when it is a Waterline v1 projection.
+    pub(crate) async fn projected_run(&self, workflow_id: &str, run_id: &str) -> Result<Option<String>> {
+        Self::query("SELECT id FROM workflow_runs WHERE id=$1 AND workflow_instance_id=$2 AND namespace=$3 AND import_source=$4")
+            .bind(run_id).bind(workflow_id).bind(self.namespace.as_ref()).bind(IMPORT_SOURCE)
+            .fetch_optional(&self.pool).await?
+            .map(|row| DB::string(&row, "id")).transpose()
+    }
+
+    /// The run and instance already holding a mapped identity, in any
+    /// namespace: workflow and run ids are global.
+    pub(crate) async fn waterline_existing(&self, workflow_id: &str, run_id: &str) -> Result<Existing> {
+        let run = Self::query("SELECT workflow_instance_id,import_source,import_id,import_dedupe_key,namespace,imported_at FROM workflow_runs WHERE id=$1")
+            .bind(run_id)
+            .fetch_optional(&self.pool)
+            .await?
+            .map(|row| -> Result<ExistingRun> {
+                Ok(ExistingRun {
+                    workflow_instance_id: DB::string(&row, "workflow_instance_id")?,
+                    import_source: DB::optional_string(&row, "import_source")?,
+                    import_id: DB::optional_string(&row, "import_id")?,
+                    dedupe_key: DB::optional_string(&row, "import_dedupe_key")?,
+                    namespace: DB::optional_string(&row, "namespace")?,
+                    imported_at: DB::optional_instant(&row, "imported_at")?,
+                })
+            })
+            .transpose()?;
+        let instance_namespace = Self::query("SELECT namespace FROM workflow_instances WHERE id=$1")
+            .bind(workflow_id)
+            .fetch_optional(&self.pool)
+            .await?
+            .map(|row| DB::optional_string(&row, "namespace"))
+            .transpose()?;
+        Ok(Existing { run, instance_namespace })
+    }
+
+    /// The projection's instance, run, history and summary in one
+    /// transaction. `Err(true)` when the identity was claimed meanwhile.
+    pub(crate) async fn waterline_write(&self, projection: &Normalized, imported_at: DateTime<Utc>) -> std::result::Result<(), bool> {
+        let mut tx = self.begin().await.map_err(|_| false)?;
+        let claimed = Self::query("SELECT id FROM workflow_instances WHERE id=$1")
+            .bind(&projection.workflow_id).fetch_optional(&mut *tx).await.map_err(|_| false)?.is_some()
+            || Self::query("SELECT id FROM workflow_runs WHERE id=$1")
+                .bind(&projection.run_id).fetch_optional(&mut *tx).await.map_err(|_| false)?.is_some();
+        if claimed {
+            return Err(true);
+        }
+        // Eloquent stores ordinary date columns as the parsed time's own
+        // wall-clock time; history times go through the UTC cast.
+        let wall = |stamp: Option<Stamp>| stamp.map(|stamp| stamp.wall);
+        let created = wall(projection.started_at).unwrap_or(imported_at);
+        let empty = json!([]);
+        Self::query("INSERT INTO workflow_instances(id,workflow_class,workflow_type,namespace,visibility_labels,memo,current_run_id,run_count,last_message_sequence,started_at,created_at,updated_at) VALUES ($1,$2,$3,$4,$5,$6,$7,1,0,$8,$9,$10)")
+            .bind(&projection.workflow_id).bind(&projection.class).bind(&projection.class).bind(&projection.namespace)
+            .bind(DB::document(&empty)).bind(DB::document(&empty)).bind(&projection.run_id)
+            .bind(DB::optional_time(wall(projection.started_at))).bind(DB::bind_time(created)).bind(DB::bind_time(imported_at))
+            .execute(&mut *tx).await.map_err(|_| false)?;
+        Self::query("INSERT INTO workflow_runs(id,workflow_instance_id,run_number,workflow_class,workflow_type,namespace,visibility_labels,status,closed_reason,payload_codec,arguments,output,connection,queue,last_history_sequence,last_command_sequence,message_cursor_position,started_at,closed_at,last_progress_at,import_source,import_id,import_dedupe_key,import_contract_version,imported_at,created_at,updated_at) VALUES ($1,$2,1,$3,$4,$5,$6,$7,$8,NULL,NULL,NULL,$9,$10,$11,0,0,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21)")
+            .bind(&projection.run_id).bind(&projection.workflow_id).bind(&projection.class).bind(&projection.class)
+            .bind(&projection.namespace).bind(DB::document(&empty)).bind(projection.status).bind(projection.closed_reason.as_deref())
+            .bind(projection.connection.as_deref()).bind(projection.queue.as_deref()).bind(projection.events.len() as i64)
+            .bind(DB::optional_time(wall(projection.started_at))).bind(DB::optional_time(wall(projection.closed_at)))
+            .bind(DB::optional_time(wall(projection.last_progress_at))).bind(IMPORT_SOURCE).bind(&projection.import_id)
+            .bind(&projection.dedupe_key).bind(VERSION).bind(DB::bind_time(imported_at)).bind(DB::bind_time(created))
+            .bind(DB::bind_time(imported_at))
+            .execute(&mut *tx).await.map_err(|_| false)?;
+        for event in &projection.events {
+            let stored = wall(event.recorded_at).unwrap_or(imported_at);
+            Self::query("INSERT INTO workflow_history_events(id,workflow_run_id,sequence,event_type,payload,recorded_at,recorded_at_utc,created_at,updated_at) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)")
+                .bind(&event.id).bind(&projection.run_id).bind(event.sequence).bind(event.event_type)
+                .bind(DB::document(&event.payload.to_json()))
+                .bind(DB::optional_time(event.recorded_at.map(|at| at.utc)))
+                .bind(DB::optional_time(event.recorded_at.map(|at| at.utc)))
+                .bind(DB::bind_time(stored)).bind(DB::bind_time(stored))
+                .execute(&mut *tx).await.map_err(|_| false)?;
+        }
+        let bucket = status_bucket(projection.status);
+        let running = bucket == "running";
+        let sort = wall(projection.last_progress_at).or(wall(projection.started_at)).unwrap_or(imported_at);
+        Self::query("INSERT INTO workflow_run_summaries(id,workflow_instance_id,run_number,is_current_run,engine_source,class,workflow_type,namespace,visibility_labels,status,status_bucket,closed_reason,connection,queue,started_at,sort_timestamp,closed_at,liveness_state,liveness_reason,repair_blocked_reason,repair_attention,task_problem,exception_count,history_event_count,history_size_bytes,continue_as_new_recommended,created_at,updated_at) VALUES ($1,$2,1,TRUE,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,'v1_projection_read_only',FALSE,FALSE,$18,$19,$20,FALSE,$21,$22)")
+            .bind(&projection.run_id).bind(&projection.workflow_id).bind(ENGINE_SOURCE)
+            .bind(&projection.class).bind(&projection.class).bind(&projection.namespace).bind(DB::document(&empty))
+            .bind(projection.status).bind(bucket).bind(projection.closed_reason.as_deref())
+            .bind(projection.connection.as_deref()).bind(projection.queue.as_deref())
+            .bind(DB::optional_time(wall(projection.started_at))).bind(DB::bind_time(sort))
+            .bind(DB::optional_time(wall(projection.closed_at)))
+            .bind(running.then_some("external_v1"))
+            .bind(running.then_some("Execution remains owned by the source v1 runtime; this standalone row is read-only."))
+            .bind(projection.exception_count).bind(projection.events.len() as i64).bind(projection.history_size_bytes)
+            .bind(DB::bind_time(created)).bind(DB::bind_time(imported_at))
+            .execute(&mut *tx).await.map_err(|_| false)?;
+        tx.commit().await.map_err(|_| false)?;
+        self.wake.notify_waiters();
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn mapped_identities_follow_php() {
+        // PHP: LegacyV1Projection::mappedIdentity('legacy-prod', 'v1:42').
+        let (workflow, run, import) = mapped_identity("legacy-prod", "v1:42");
+        assert!(workflow.starts_with("v1:legacy-prod:") && workflow.len() == "v1:legacy-prod:".len() + 24);
+        assert_eq!(run.len(), 26);
+        assert_eq!(import.len(), 64);
+        assert_eq!(mapped_identity("Legacy:Prod..X", "v1:1").0.split(':').nth(1), Some("legacy-prod..x"));
+        assert_eq!(mapped_identity(&"a".repeat(40), "v1:1").0.split(':').nth(1).map(str::len), Some(32));
+        assert_eq!(mapped_identity("::", "v1:1").0.split(':').nth(1), Some("source"));
+    }
+
+    #[test]
+    fn events_and_history_size_follow_php() {
+        // PHP 2.11.1: LegacyV1Projection::normalize('src-1', bare source, 'ns-1')
+        // printed these event encodings (json_encode, JSON_UNESCAPED_SLASHES).
+        let source = super::super::php_value::decode(br#"{"operator_id":"v1:4501","engine_source":"v1","class":"App\\Workflows\\Legacy\\Bare","status":"completed"}"#)
+            .unwrap();
+        let Outcome::Valid(normalized) = normalize("src-1", source.array().unwrap(), Some("ns-1")) else { panic!("valid") };
+        let encoded: Vec<String> = normalized.events.iter().map(|event| object(vec![
+            ("event_type", text(event.event_type)),
+            ("recorded_at", optional(json_time(event.recorded_at))),
+            ("payload", event.payload.clone()),
+            ("sequence", Php::Int(event.sequence)),
+            ("id", text(&event.id)),
+        ]).encode(Flags { unescaped_slashes: true, ..Flags::default() })).collect();
+        assert_eq!(encoded[0].len(), 1374, "{}", encoded[0]);
+        assert_eq!(encoded[1].len(), 496, "{}", encoded[1]);
+        assert_eq!(normalized.history_size_bytes, 1870);
+        assert_eq!(normalized.workflow_id, "v1:src-1:c8c25815a3332910ba072598");
+        assert_eq!(normalized.run_id, "b0ee56b2b89080ea9181490e2f");
+        assert_eq!(normalized.events[0].id, "9730c0bb4149e0a120cc8a8d7e");
+    }
+
+    #[test]
+    fn floats_cast_to_strings_as_php() {
+        assert_eq!(float_string(4101.0), "4101");
+        assert_eq!(float_string(1.5), "1.5");
+        assert_eq!(float_string(0.1 + 0.2), "0.3");
+        assert_eq!(float_string(1e25), "1.0E+25");
+        assert_eq!(float_string(-0.00001), "-1.0E-5");
+        assert_eq!(float_string(0.0001), "0.0001");
+    }
+}

From 71c4a614b0a3da62c33524e5054bdabda3697893 Mon Sep 17 00:00:00 2001
From: Richard McDaniel <1130888+rmcdaniel@users.noreply.github.com>
Date: Sun, 25 Oct 2026 11:37:44 +0000
Subject: [PATCH 3/9] Rust #325: no run operation routes remain missing

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/rust-server-port.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/docs/rust-server-port.md b/docs/rust-server-port.md
index 73a4ce738..7dd482697 100644
--- a/docs/rust-server-port.md
+++ b/docs/rust-server-port.md
@@ -146,9 +146,6 @@ any other unknown path or method answers PHP's own 404 or 405
     `update-validation` fixture. Native does not replay a validation task by
     `poll_request_id` or bind a request id to its task kinds; see
     `docs/rust-server-port-checkpoints/2026-10-23-update-validation.md`.)
-- **Run operations.**
-  - Waterline v1 import. (Embedded v2 import is served:
-    `POST /api/workflows/import/embedded-v2`.)
 - **Other families.**
   - Message streams are served
     ([checkpoint](rust-server-port-checkpoints/2026-10-23-message-streams.md)),

From 93215b0c0f8c53f10152708f14eb2315ca4c3302 Mon Sep 17 00:00:00 2001
From: Richard McDaniel <1130888+rmcdaniel@users.noreply.github.com>
Date: Sun, 25 Oct 2026 17:56:42 +0000
Subject: [PATCH 4/9] Name the workflow import defects' issue

Both published 2.11.1 cross-namespace defects the workflow-import fixture
bounds are now Server #765. The contract reads only each defect's
published steps, so the added issue field changes no comparison.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 tests/Fixtures/ServerParity/workflow-import.json | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/Fixtures/ServerParity/workflow-import.json b/tests/Fixtures/ServerParity/workflow-import.json
index 2a3abc143..a71003bf4 100644
--- a/tests/Fixtures/ServerParity/workflow-import.json
+++ b/tests/Fixtures/ServerParity/workflow-import.json
@@ -1999,6 +1999,7 @@
     "published_defects": {
       "cross_namespace_duplicate": {
         "summary": "EmbeddedV2HistoryImport::existingRunOutcome finds the run in any namespace, so a bundle already imported into another namespace answers 200 already_imported for the requested namespace, which holds no such run. Native refuses it as a run_id conflict.",
+        "issue": "https://github.com/durable-workflow/server/issues/765",
         "published": {
           "duplicate_other_namespace": {
             "status": 200,
@@ -2105,6 +2106,7 @@
       },
       "cross_namespace_instance_attach": {
         "summary": "EmbeddedV2HistoryImport::writeBundle finds the workflow instance in any namespace and attaches the imported run to it, so a run imported into one namespace takes over the current run and run count of an instance in another. Native refuses the write and leaves the other namespace unchanged.",
+        "issue": "https://github.com/durable-workflow/server/issues/765",
         "published": {
           "attach": {
             "status": 201,

From 6d8eec049942fd0fe84232c32001967cf3f6eaac Mon Sep 17 00:00:00 2001
From: Richard McDaniel <1130888+rmcdaniel@users.noreply.github.com>
Date: Sun, 25 Oct 2026 23:04:55 +0000
Subject: [PATCH 5/9] Rust #325: keep Waterline v1 projections read-only and
 bounded

Security's review of #768 found two gaps that published 2.11.1 shares
(Server #769, #770):

- A message stream append to a projection delivered a signal and created a
  workflow task. Native now refuses it with 409 v1_projection_read_only at
  the route before the body is read, in the service before parsing, and
  again in the store under its lock. Malformed input is not counted
  against a projection.
- An import had no size limit. Native now applies
  DW_V2_LIMIT_HISTORY_TRANSACTION_SIZE and _BYTES to a projection, which is
  one transaction writing its history. The event count is known from the
  source's row counts and is checked before any row is copied or any event
  is built; history bytes are added up event by event and the first event
  past the limit stops the measure. A refusal is a 409 report with reason
  v1_projection_too_large and limit {dimension, used, limit}, before any
  row is read or written.

Both limits are now honored settings: config_audit lists
HISTORY_TRANSACTION_SIZE as honored and HISTORY_TRANSACTION_BYTES as a
native-honored name with its legacy alias. Operator metrics, the health
snapshot and the backend capabilities publish their active values (0 when
disabled) instead of a fixed 5000.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/rust-server-port.md                      |  25 +-
 rust/src/config_audit.rs                      |  41 ++-
 rust/src/runtime/execution.rs                 |  21 ++
 rust/src/runtime/memo_limits.rs               |  15 +
 rust/src/runtime/message_streams.rs           |  15 +-
 rust/src/runtime/operator_metrics.rs          |  11 +-
 rust/src/runtime/waterline_import.rs          | 260 ++++++++++++++++--
 rust/tests/execution.rs                       |   2 +
 rust/tests/execution/structural_limits.rs     |  42 +++
 .../execution/waterline_projection_guards.rs  | 117 ++++++++
 10 files changed, 516 insertions(+), 33 deletions(-)
 create mode 100644 rust/tests/execution/waterline_projection_guards.rs

diff --git a/docs/rust-server-port.md b/docs/rust-server-port.md
index a1379d221..e7601e997 100644
--- a/docs/rust-server-port.md
+++ b/docs/rust-server-port.md
@@ -232,9 +232,28 @@ contract fixture before its correction.
   batch size, and still caps parallel groups at 100 members and a run at 64
   updates over its lifetime. #612 tracks the rest
   ([checkpoint](rust-server-port-checkpoints/2026-10-23-structural-limits.md)).
-- **Environment settings.** Of PHP's 166 contract settings, native honors
-  43 and ignores 57 that change nothing it serves. It refuses to start on a
-  non-default value of the other 66
+- **Waterline v1 projections, ahead of published PHP.**
+  - Native refuses a message stream append to a projection with
+    `409 v1_projection_read_only`, at the route before the body is read and
+    again under the store's lock. Published 2.11.1 accepts it and creates a
+    signal and a workflow task
+    ([#769](https://github.com/durable-workflow/server/issues/769)).
+  - Native refuses a projection that would write more history events or
+    bytes than one transaction may (`DW_V2_LIMIT_HISTORY_TRANSACTION_SIZE`,
+    `_BYTES`) with `409 v1_projection_too_large`, before reading or writing
+    any row. The count is checked from the source's row counts before any
+    event is built, and history bytes are added up event by event, stopping
+    at the first event past the limit. Published 2.11.1 has no limit
+    ([#770](https://github.com/durable-workflow/server/issues/770)).
+  - Operator metrics, the health snapshot and the backend capabilities
+    publish the active `history_transaction_size` and
+    `history_transaction_bytes` (0 when disabled), as Workflow #934's
+    `StructuralLimits::snapshot()` does.
+- **Environment settings.** Of PHP's 164 contract settings, native honors
+  49 and ignores 51 that change nothing it serves. It also honors
+  `DW_V2_LIMIT_HISTORY_TRANSACTION_BYTES`, which the Workflow package reads
+  and PHP's contract does not list yet. It refuses to start on a
+  non-default value of the other 64
   ([checkpoint](rust-server-port-checkpoints/2026-10-22-environment-contract.md)).
   Several of those are cheap to honor: repair timing and the multi-node
   declaration.
diff --git a/rust/src/config_audit.rs b/rust/src/config_audit.rs
index c8f35a5ea..bb6bd30d2 100644
--- a/rust/src/config_audit.rs
+++ b/rust/src/config_audit.rs
@@ -474,7 +474,7 @@ pub fn audit(environment: &BTreeMap<String, String>) -> Report {
         .keys()
         .map(String::as_str)
         .filter(|name| name.starts_with("DW_"))
-        .filter(|name| !SETTINGS.iter().any(|setting| setting.name == *name))
+        .filter(|name| !SETTINGS.iter().chain(NATIVE_HONORED).any(|setting| setting.name == *name))
         .filter(|name| !native_only(name))
         .collect();
     if !unknown.is_empty() {
@@ -484,7 +484,7 @@ pub fn audit(environment: &BTreeMap<String, String>) -> Report {
         ));
     }
     for name in environment.keys() {
-        if let Some(setting) = SETTINGS.iter().find(|setting| setting.legacy == Some(name.as_str())) {
+        if let Some(setting) = SETTINGS.iter().chain(NATIVE_HONORED).find(|setting| setting.legacy == Some(name.as_str())) {
             report.warnings.push(format!(
                 "Legacy env var {name} is still honored but deprecated — rename to {}.",
                 setting.name
@@ -542,6 +542,14 @@ const UNLISTED: &[Setting] = &[
     Setting { name: "DW_V2_LEGACY_SCHEDULE_STORAGE_TIMEZONE", legacy: Some("WORKFLOW_V2_LEGACY_SCHEDULE_STORAGE_TIMEZONE"), disposition: Refused(Empty, LEGACY_SCHEDULE_TIMEZONE) },
 ];
 
+/// Settings native honors that PHP's contract does not list yet: the
+/// Workflow package reads them (Workflow #930), and PHP's contract gains them
+/// when the PHP Server takes that release. They are not unknown names, and
+/// their legacy names warn as the contract's do.
+pub const NATIVE_HONORED: &[Setting] = &[
+    Setting { name: "DW_V2_LIMIT_HISTORY_TRANSACTION_BYTES", legacy: Some("WORKFLOW_V2_LIMIT_HISTORY_TRANSACTION_BYTES"), disposition: Honored },
+];
+
 /// Every `vars` entry of `config/dw-contract.php`, with its contract legacy name.
 pub const SETTINGS: &[Setting] = &[
     Setting { name: "DW_ACTIVITY_TASK_MAX_ACTIVE_LEASES_PER_NAMESPACE", legacy: Some("WORKFLOW_SERVER_ACTIVITY_TASK_MAX_ACTIVE_LEASES_PER_NAMESPACE"), disposition: Refused(NoPositiveInt, TASK_ADMISSION) },
@@ -664,7 +672,7 @@ pub const SETTINGS: &[Setting] = &[
     Setting { name: "DW_V2_HISTORY_EXPORT_SIGNING_KEY", legacy: Some("WORKFLOW_V2_HISTORY_EXPORT_SIGNING_KEY"), disposition: Honored },
     Setting { name: "DW_V2_HISTORY_EXPORT_SIGNING_KEY_ID", legacy: Some("WORKFLOW_V2_HISTORY_EXPORT_SIGNING_KEY_ID"), disposition: Honored },
     Setting { name: "DW_V2_LIMIT_COMMAND_BATCH_SIZE", legacy: Some("WORKFLOW_V2_LIMIT_COMMAND_BATCH_SIZE"), disposition: Refused(Int(1000), STRUCTURAL) },
-    Setting { name: "DW_V2_LIMIT_HISTORY_TRANSACTION_SIZE", legacy: Some("WORKFLOW_V2_LIMIT_HISTORY_TRANSACTION_SIZE"), disposition: Ignored },
+    Setting { name: "DW_V2_LIMIT_HISTORY_TRANSACTION_SIZE", legacy: Some("WORKFLOW_V2_LIMIT_HISTORY_TRANSACTION_SIZE"), disposition: Honored },
     Setting { name: "DW_V2_LIMIT_MEMO_SIZE_BYTES", legacy: Some("WORKFLOW_V2_LIMIT_MEMO_SIZE_BYTES"), disposition: Honored },
     Setting { name: "DW_V2_LIMIT_PAYLOAD_SIZE_BYTES", legacy: Some("WORKFLOW_V2_LIMIT_PAYLOAD_SIZE_BYTES"), disposition: Honored },
     Setting { name: "DW_V2_LIMIT_PENDING_ACTIVITIES", legacy: Some("WORKFLOW_V2_LIMIT_PENDING_ACTIVITIES"), disposition: Refused(Int(2000), STRUCTURAL) },
@@ -1074,6 +1082,33 @@ mod tests {
         assert!(report.refusal().is_some_and(|refusal| !refusal.contains(secret)));
     }
 
+    #[test]
+    fn the_history_transaction_limits_are_honored_settings() {
+        let honored = |name: &str| SETTINGS.iter().chain(NATIVE_HONORED).find(|setting| setting.name == name)
+            .is_some_and(|setting| matches!(setting.disposition, Honored));
+        for name in ["DW_V2_LIMIT_HISTORY_TRANSACTION_SIZE", "DW_V2_LIMIT_HISTORY_TRANSACTION_BYTES"] {
+            assert!(honored(name), "{name}");
+        }
+        // NATIVE_HONORED names are outside PHP's contract and listed once.
+        for setting in NATIVE_HONORED {
+            assert!(!contract().iter().any(|(name, ..)| name == setting.name), "{} is now in the contract", setting.name);
+            assert!(!SETTINGS.iter().any(|listed| listed.name == setting.name));
+        }
+        // Strict mode starts with each primary name set.
+        let mut primary = environment(&[("DW_V2_LIMIT_HISTORY_TRANSACTION_SIZE", "123"), ("DW_V2_LIMIT_HISTORY_TRANSACTION_BYTES", "4567")]);
+        primary.insert("DW_ENV_AUDIT_STRICT".into(), "1".into());
+        let report = audit(&primary);
+        assert_eq!((report.warnings.as_slice(), report.refusal()), (&[] as &[String], None));
+        // A legacy name warns as deprecated, naming its primary, and nothing else.
+        let report = audit(&environment(&[("WORKFLOW_V2_LIMIT_HISTORY_TRANSACTION_SIZE", "123"),
+            ("WORKFLOW_V2_LIMIT_HISTORY_TRANSACTION_BYTES", "4567")]));
+        assert_eq!(report.warnings, [
+            "Legacy env var WORKFLOW_V2_LIMIT_HISTORY_TRANSACTION_BYTES is still honored but deprecated — rename to DW_V2_LIMIT_HISTORY_TRANSACTION_BYTES.",
+            "Legacy env var WORKFLOW_V2_LIMIT_HISTORY_TRANSACTION_SIZE is still honored but deprecated — rename to DW_V2_LIMIT_HISTORY_TRANSACTION_SIZE.",
+        ]);
+        assert_eq!(report.refusal(), None);
+    }
+
     #[test]
     fn unknown_and_legacy_names_warn_and_strict_mode_refuses_them() {
         let values = [
diff --git a/rust/src/runtime/execution.rs b/rust/src/runtime/execution.rs
index b6df0693e..e611ccf36 100644
--- a/rust/src/runtime/execution.rs
+++ b/rust/src/runtime/execution.rs
@@ -600,6 +600,14 @@ impl Runtime {
                 response: json!({"accepted":false,"workflow_id":workflow_id,"stream_name":stream,"outcome":"rejected","reason":"instance_not_found"}),
             });
         }
+        // A read-only Waterline projection takes no messages, whatever the
+        // body; the store checks again under its lock.
+        if let Some(run_id) = self.projected_current_run(workflow_id).await? {
+            return Err(super::RuntimeError::Protocol {
+                status: StatusCode::CONFLICT,
+                response: super::waterline_import::read_only_append(workflow_id, &run_id, stream),
+            });
+        }
         let body = super::laravel_rules::normalize(&body);
         let blob = match self.message_payload(&body).await {
             Ok(blob) => blob,
@@ -619,6 +627,19 @@ impl Runtime {
         }
     }
 
+    /// The store's append alone, without the service's checks: tests of the
+    /// store's own guard call it.
+    #[cfg(test)]
+    pub(crate) async fn store_append_message(&self, workflow_id: &str, stream: &str, message_id: &str, blob: &str)
+        -> Result<(StatusCode, Value)> {
+        let (codec, structural, context) = (self.signal_codec.clone(), self.structural, json!({}));
+        match &*self.storage {
+            Storage::Sqlite(store) => store.append_message(workflow_id, stream, message_id, "avro", blob, &context, codec, structural).await,
+            Storage::Postgres(store) => store.append_message(workflow_id, stream, message_id, "avro", blob, &context, codec, structural).await,
+            Storage::MySql(store) => store.append_message(workflow_id, stream, message_id, "avro", blob, &context, codec, structural).await,
+        }
+    }
+
     /// The request rules, then `AvroPayloadEnvelopeResolver::resolve`: no
     /// input is an empty argument list, plain values are encoded, and an
     /// inline envelope keeps its exact bytes.
diff --git a/rust/src/runtime/memo_limits.rs b/rust/src/runtime/memo_limits.rs
index fbf931e67..afe1bfcf3 100644
--- a/rust/src/runtime/memo_limits.rs
+++ b/rust/src/runtime/memo_limits.rs
@@ -90,6 +90,15 @@ pub struct StructuralLimits {
     pub pending_updates: Option<usize>,
     /// Bytes of one serialized payload blob (DW_V2_LIMIT_PAYLOAD_SIZE_BYTES).
     pub payload_bytes: Option<usize>,
+    /// History events one workflow task completion may write
+    /// (DW_V2_LIMIT_HISTORY_TRANSACTION_SIZE; Workflow #930).
+    pub history_events: Option<usize>,
+    /// History bytes one completion may write, measured as `HistoryBudget`
+    /// measures an event (DW_V2_LIMIT_HISTORY_TRANSACTION_BYTES).
+    pub history_bytes: Option<usize>,
+    /// Durable rows one completion may write
+    /// (DW_V2_LIMIT_HISTORY_TRANSACTION_ROWS).
+    pub history_rows: Option<usize>,
 }
 
 impl Default for StructuralLimits {
@@ -98,6 +107,9 @@ impl Default for StructuralLimits {
             pending_signals: Some(5000),
             pending_updates: Some(500),
             payload_bytes: Some(2_097_152),
+            history_events: Some(5000),
+            history_bytes: Some(16_777_216),
+            history_rows: Some(20_000),
         }
     }
 }
@@ -110,6 +122,9 @@ impl StructuralLimits {
             pending_signals: configured("PENDING_SIGNALS", defaults.pending_signals.unwrap(), invalid)?,
             pending_updates: configured("PENDING_UPDATES", defaults.pending_updates.unwrap(), invalid)?,
             payload_bytes: configured("PAYLOAD_SIZE_BYTES", defaults.payload_bytes.unwrap(), invalid)?,
+            history_events: configured("HISTORY_TRANSACTION_SIZE", defaults.history_events.unwrap(), invalid)?,
+            history_bytes: configured("HISTORY_TRANSACTION_BYTES", defaults.history_bytes.unwrap(), invalid)?,
+            history_rows: configured("HISTORY_TRANSACTION_ROWS", defaults.history_rows.unwrap(), invalid)?,
         })
     }
 }
diff --git a/rust/src/runtime/message_streams.rs b/rust/src/runtime/message_streams.rs
index 42e87ab1a..2f3294731 100644
--- a/rust/src/runtime/message_streams.rs
+++ b/rust/src/runtime/message_streams.rs
@@ -308,6 +308,11 @@ where
         Ok(open.then_some(run))
     }
 
+    /// Whether the run is a read-only Waterline v1 projection.
+    fn projected(run: &DB::Row) -> Result<bool> {
+        Ok(DB::optional_string(run, "import_source")?.as_deref() == Some(super::waterline_import::IMPORT_SOURCE))
+    }
+
     /// `MessageStreamService::append`, in one transaction.
     #[allow(clippy::too_many_arguments)]
     pub(crate) async fn append_message(
@@ -330,6 +335,10 @@ where
         let Some(run) = Self::active_current_run(&mut tx, workflow_id).await? else {
             return Err(rejection(StatusCode::CONFLICT, "run_not_active", workflow_id, stream, message_id, json!({})));
         };
+        if Self::projected(&run)? {
+            return Err(RuntimeError::Protocol { status: StatusCode::CONFLICT,
+                response: super::waterline_import::read_only_append(workflow_id, &DB::string(&run, "id")?, stream) });
+        }
         let row = self.locked_stream(&mut tx, workflow_id, stream).await?;
         let stream_id = DB::number(&row, "id")?;
         let cursor = DB::number(&row, "cursor_position")?;
@@ -388,8 +397,10 @@ where
         let mut tx = self.begin().await?;
         let bound = Self::query("SELECT id FROM workflow_instances WHERE id=$1 AND namespace=$2")
             .bind(workflow_id).bind(self.namespace.as_ref()).fetch_optional(&mut *tx).await?;
-        if bound.is_none() || Self::active_current_run(&mut tx, workflow_id).await?.is_none() {
-            return Ok(());
+        // A read-only projection keeps no stream state, malformed or not.
+        match Self::active_current_run(&mut tx, workflow_id).await? {
+            Some(run) if bound.is_some() && !Self::projected(&run)? => {}
+            _ => return Ok(()),
         }
         let row = self.locked_stream(&mut tx, workflow_id, stream).await?;
         let at = now();
diff --git a/rust/src/runtime/operator_metrics.rs b/rust/src/runtime/operator_metrics.rs
index 02fa06405..9fe1c20b3 100644
--- a/rust/src/runtime/operator_metrics.rs
+++ b/rust/src/runtime/operator_metrics.rs
@@ -270,7 +270,7 @@ where
             "projections": self.projection_metrics(now).await?,
             "schedules": self.schedule_metrics(now).await?,
             "workers": self.worker_metrics().await?,
-            "backend": backend_capabilities(now, DB::PHP_CONNECTION),
+            "backend": backend_capabilities(now, DB::PHP_CONNECTION, &config.structural, self.memo_size_limit),
             "structural_limits": structural_limits(DB::PHP_CONNECTION, &config.structural, self.memo_size_limit),
             "update_wait": {"completion_timeout_seconds": 10, "poll_interval_milliseconds": 50},
             "repair_policy": repair_policy(),
@@ -1491,7 +1491,8 @@ fn structural_limits(connection: &str, limits: &super::StructuralLimits, memo: O
         "payload_size_bytes": shown(limits.payload_bytes),
         "memo_size_bytes": shown(memo),
         "search_attribute_size_bytes": 40960,
-        "history_transaction_size": 5000,
+        "history_transaction_size": shown(limits.history_events),
+        "history_transaction_bytes": shown(limits.history_bytes),
         "warning_threshold_percent": 80,
     });
     let sqlite = connection == "sqlite";
@@ -1508,9 +1509,9 @@ fn structural_limits(connection: &str, limits: &super::StructuralLimits, memo: O
 }
 
 /// What this runtime needs from its backends, in PHP's capability shape.
-fn backend_capabilities(now: DateTime<Utc>, connection: &str) -> Value {
-    // Only the backend's issues are reported here, which no ceiling changes.
-    let limits = structural_limits(connection, &super::StructuralLimits::default(), None);
+fn backend_capabilities(now: DateTime<Utc>, connection: &str, structural: &super::StructuralLimits, memo: Option<usize>) -> Value {
+    // The active ceilings, with the backend's adjustments and issues.
+    let limits = structural_limits(connection, structural, memo);
     let issues = limits["issues"].clone();
     let severity = if issues.as_array().is_some_and(|issues| !issues.is_empty()) {
         "info"
diff --git a/rust/src/runtime/waterline_import.rs b/rust/src/runtime/waterline_import.rs
index e42b1920a..9ac941823 100644
--- a/rust/src/runtime/waterline_import.rs
+++ b/rust/src/runtime/waterline_import.rs
@@ -128,6 +128,64 @@ fn rows(value: Option<&Php>) -> Vec<PhpArray> {
     }
 }
 
+/// How many rows `rows` would return, without copying them.
+fn row_count(value: Option<&Php>) -> usize {
+    match value {
+        Some(Php::Array(array)) => array.values().filter(|value| value.array().is_some()).count(),
+        _ => 0,
+    }
+}
+
+/// A projection larger than one transaction may write: its history events
+/// against `DW_V2_LIMIT_HISTORY_TRANSACTION_SIZE`, or its history bytes
+/// against `DW_V2_LIMIT_HISTORY_TRANSACTION_BYTES`. Published PHP has no
+/// such limit; native refuses before reading or writing any row.
+fn too_large(dimension: &str, used: usize, limit: usize) -> Php {
+    let (measure, setting) = match dimension {
+        "history_transaction_size" => ("history events", "DW_V2_LIMIT_HISTORY_TRANSACTION_SIZE"),
+        _ => ("history bytes", "DW_V2_LIMIT_HISTORY_TRANSACTION_BYTES"),
+    };
+    object(vec![
+        ("reason", text("v1_projection_too_large")),
+        ("message", text(format!("The projection would write {used} {measure} in one transaction; at most {limit} are allowed ({dimension})."))),
+        ("remediation", text(format!("Keep the workflow on its v1 runtime, or raise {setting} on this server before importing it."))),
+        ("limit", object(vec![("dimension", text(dimension)), ("used", Php::Int(used as i64)), ("limit", Php::Int(limit as i64))])),
+    ])
+}
+
+/// The first limit a projection of `events` events and `bytes` bytes
+/// exceeds, if any; 0 disables a limit.
+fn exceeded(limits: &super::StructuralLimits, events: usize, bytes: usize) -> Option<Php> {
+    let over = |limit: Option<usize>, used: usize| limit.filter(|limit| *limit > 0 && used > *limit);
+    over(limits.history_events, events)
+        .map(|limit| too_large("history_transaction_size", events, limit))
+        .or_else(|| over(limits.history_bytes, bytes).map(|limit| too_large("history_transaction_bytes", bytes, limit)))
+}
+
+/// The body that refuses an operation on a read-only projection.
+pub(super) fn read_only_body(workflow_id: &str, run_id: &str, operation: &str) -> Value {
+    json!({
+        "message": format!("Operation [{operation}] is unavailable because this execution is a read-only projection owned by the source v1 runtime."),
+        "reason": "v1_projection_read_only",
+        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
+        "workflow_id": workflow_id,
+        "run_id": run_id,
+        "operation": operation,
+        "execution_owner": "v1",
+    })
+}
+
+/// A message stream append refused on a read-only projection, in the shape
+/// of the stream's own refusals. Published PHP accepts it.
+pub(super) fn read_only_append(workflow_id: &str, run_id: &str, stream: &str) -> Value {
+    let mut body = read_only_body(workflow_id, run_id, "message_stream_append");
+    for (key, value) in [("accepted", json!(false)), ("duplicate", json!(false)), ("stream_name", json!(stream)),
+        ("outcome", json!("rejected"))] {
+        body[key] = value;
+    }
+    body
+}
+
 fn error(reason: &str, message: &str, remediation: &str) -> Php {
     object(vec![("reason", text(reason)), ("message", text(message)), ("remediation", text(remediation))])
 }
@@ -233,11 +291,26 @@ pub(crate) struct Normalized {
 
 pub(crate) enum Outcome {
     Invalid { errors: Vec<Php> },
+    /// Larger than one transaction may write. `encoded` is how many events
+    /// were built and measured first: 0 for a refusal by count.
+    TooLarge { error: Php, encoded: usize },
     Valid(Box<Normalized>),
 }
 
-/// `LegacyV1Projection::normalize`.
+/// `LegacyV1Projection::normalize`, without size limits.
+#[cfg(test)]
 pub(crate) fn normalize(source_id: &str, source: &PhpArray, namespace: Option<&str>) -> Outcome {
+    let unlimited = super::StructuralLimits { history_events: None, history_bytes: None, ..super::StructuralLimits::default() };
+    normalize_bounded(source_id, source, namespace, &unlimited)
+}
+
+/// `LegacyV1Projection::normalize`, refusing a projection larger than one
+/// transaction may write. The event count is known from the source's row
+/// counts and is checked before any row is copied or any event is built;
+/// history bytes are added up event by event and the first event past the
+/// limit stops the measure.
+pub(crate) fn normalize_bounded(source_id: &str, source: &PhpArray, namespace: Option<&str>,
+    limits: &super::StructuralLimits) -> Outcome {
     let source_id = php_trim(source_id).to_owned();
     let namespace = namespace.map(php_trim).filter(|namespace| !namespace.is_empty()).unwrap_or("default").to_owned();
     let qualified = string(coalesce(source, &["operator_id", "id"]));
@@ -281,6 +354,14 @@ pub(crate) fn normalize(source_id: &str, source: &PhpArray, namespace: Option<&s
         return Outcome::Invalid { errors };
     };
 
+    // The start event, one event per log, signal and exception, and a
+    // terminal event when the status has one.
+    let terminal = matches!(status, "completed" | "failed" | "cancelled" | "terminated");
+    let projected = ["logs", "signals", "exceptions"].iter()
+        .fold(1usize + usize::from(terminal), |total, key| total.saturating_add(row_count(source.get(key))));
+    if let Some(error) = exceeded(limits, projected, 0) {
+        return Outcome::TooLarge { error, encoded: 0 };
+    }
     let (workflow_id, run_id, import_id) = mapped_identity(&source_id, &qualified);
     let connection = string(source.get("connection"));
     let queue = string(source.get("queue"));
@@ -317,7 +398,6 @@ pub(crate) fn normalize(source_id: &str, source: &PhpArray, namespace: Option<&s
     ]);
     let started_at = timestamp(source.get("created_at"));
     let last_progress_at = timestamp(source.get("updated_at")).or(started_at);
-    let terminal = matches!(status, "completed" | "failed" | "cancelled" | "terminated");
     let closed_at = if terminal { last_progress_at } else { None };
     let raw = |key: &str| source.get(key).cloned().unwrap_or(Php::Null);
     let rows_value = |rows: &[PhpArray]| list(rows.iter().cloned().map(Php::Array).collect());
@@ -345,14 +425,23 @@ pub(crate) fn normalize(source_id: &str, source: &PhpArray, namespace: Option<&s
     ]);
     let events = events(source, &logs, &signals, &exceptions, migration, status, started_at, last_progress_at, &run_id);
     // `strlen(json_encode($event, JSON_UNESCAPED_SLASHES))` over each event
-    // as PHP holds it: type, Carbon time, payload, sequence and id.
-    let history_size_bytes = events.iter().map(|event| object(vec![
-        ("event_type", text(event.event_type)),
-        ("recorded_at", optional(json_time(event.recorded_at))),
-        ("payload", event.payload.clone()),
-        ("sequence", Php::Int(event.sequence)),
-        ("id", text(&event.id)),
-    ]).encode(Flags { unescaped_slashes: true, ..Flags::default() }).len() as i64).sum();
+    // as PHP holds it: type, Carbon time, payload, sequence and id. The
+    // first event past the byte limit stops the measure.
+    let mut history_size_bytes: usize = 0;
+    for (index, event) in events.iter().enumerate() {
+        let size = object(vec![
+            ("event_type", text(event.event_type)),
+            ("recorded_at", optional(json_time(event.recorded_at))),
+            ("payload", event.payload.clone()),
+            ("sequence", Php::Int(event.sequence)),
+            ("id", text(&event.id)),
+        ]).encode(Flags { unescaped_slashes: true, ..Flags::default() }).len();
+        history_size_bytes = history_size_bytes.saturating_add(size);
+        if let Some(error) = exceeded(limits, 0, history_size_bytes) {
+            return Outcome::TooLarge { error, encoded: index + 1 };
+        }
+    }
+    let history_size_bytes = i64::try_from(history_size_bytes).unwrap_or(i64::MAX);
     Outcome::Valid(Box::new(Normalized {
         namespace,
         workflow_id,
@@ -490,6 +579,7 @@ fn events(source: &PhpArray, logs: &[PhpArray], signals: &[PhpArray], exceptions
 fn report(outcome: &Outcome, status: &str, extra: Vec<(&str, Value)>) -> Value {
     let (identity, dedupe, unsupported, errors) = match outcome {
         Outcome::Invalid { errors } => (Value::Null, Value::Null, json!([]), list(errors.clone()).to_json()),
+        Outcome::TooLarge { error, .. } => (Value::Null, Value::Null, json!([]), list(vec![error.clone()]).to_json()),
         Outcome::Valid(normalized) => (normalized.identity.to_json(), json!(normalized.dedupe_key),
             normalized.unsupported.to_json(), json!([])),
     };
@@ -628,6 +718,11 @@ pub(super) async fn read_only_guard(request: axum::extract::Request, next: axum:
         ["api", "workflows", workflow, "runs", run, operation @ ("signal" | "query" | "update"), name] => {
             (*workflow, Some(*run), *operation, Some(*name))
         }
+        // Refused before its body is read: an append would deliver a signal
+        // and create a workflow task for the projection.
+        ["api", "workflows", workflow, "message-streams", stream, "messages"] => {
+            (*workflow, None, "message_stream_append", Some(*stream))
+        }
         _ => return next.run(request).await,
     };
     let (Some(runtime), Some(workflow)) = (request.extensions().get::<Runtime>().cloned(), decoded(workflow)) else {
@@ -660,15 +755,10 @@ pub(super) async fn read_only_guard(request: axum::extract::Request, next: axum:
         request
     };
     drop(request);
-    let body = json!({
-        "message": format!("Operation [{operation}] is unavailable because this execution is a read-only projection owned by the source v1 runtime."),
-        "reason": "v1_projection_read_only",
-        "remediation": "Run commands against the source v1 application until it completes; repeat projection never dispatches or advances standalone execution.",
-        "workflow_id": workflow,
-        "run_id": run_id,
-        "operation": operation,
-        "execution_owner": "v1",
-    });
+    if operation == "message_stream_append" {
+        return (StatusCode::CONFLICT, axum::Json(read_only_append(&workflow, &run_id, &name))).into_response();
+    }
+    let body = read_only_body(&workflow, &run_id, operation);
     let body = match operation {
         "signal" => Operation::Signal(&name).response(body),
         "query" => Operation::Query(&name).response(body),
@@ -693,7 +783,8 @@ impl Runtime {
         };
         let namespace = self.namespace_name();
         // Hashing and JSON encoding of the whole source stay off the async workers.
-        let outcome = tokio::task::spawn_blocking(move || normalize(&source_id, &workflow, Some(&namespace)))
+        let limits = self.structural;
+        let outcome = tokio::task::spawn_blocking(move || normalize_bounded(&source_id, &workflow, Some(&namespace), &limits))
             .await
             .map_err(|_| super::refuse(StatusCode::SERVICE_UNAVAILABLE, "waterline_import_unavailable"))?;
         let answer = |status: &str, extra: Vec<(&str, Value)>| {
@@ -704,6 +795,11 @@ impl Runtime {
             };
             (code, operation().response(report(&outcome, status, extra)))
         };
+        // A projection too large for one transaction is refused before any
+        // row is read or written.
+        if let Outcome::TooLarge { error, .. } = &outcome {
+            return Ok(answer("rejected", vec![("limit", error.to_json()["limit"].clone())]));
+        }
         let Outcome::Valid(normalized) = &outcome else {
             return Ok(answer("rejected", Vec::new()));
         };
@@ -937,6 +1033,73 @@ store_methods! {
 mod tests {
     use super::*;
 
+    #[tokio::test]
+    async fn direct_appends_and_malformed_counts_never_touch_a_projection() {
+        let directory = tempfile::tempdir().unwrap();
+        let runtime = super::super::Runtime::open(directory.path().join("projection.sqlite").to_str().unwrap(), "test-token".into())
+            .await
+            .unwrap();
+        let source = json!({"id": "v1:4201", "legacy_id": "4201", "engine_source": "v1", "class": "App\\Workflows\\Legacy\\Subscription",
+            "status": "running", "arguments": "a:0:{}", "logs": [{"id": 9101, "index": 0, "class": "App\\Activities\\Bill",
+                "result": "i:42;", "created_at": "2026-09-30T09:00:02.000000Z"}], "created_at": "2026-09-30T09:00:00.000000Z"});
+        let body = serde_json::to_vec(&json!({"source_id": "guard-src", "workflow": source})).unwrap();
+        let (status, report) = runtime.import_waterline_v1(&body).await.unwrap();
+        assert_eq!(status, StatusCode::CREATED, "{report}");
+        let workflow_id = report["identity"]["standalone"]["workflow_id"].as_str().unwrap().to_owned();
+        let run_id = report["identity"]["standalone"]["run_id"].clone();
+        let pool = runtime.sqlite_pool();
+        let snapshot = || async {
+            let mut counts = Vec::new();
+            for table in ["workflow_inbound_streams", "workflow_inbound_stream_items", "workflow_signal_records", "workflow_commands",
+                "workflow_history_events", "workflow_tasks", "workflow_run_summaries"] {
+                let count: i64 = sqlx::query_scalar(sqlx::AssertSqlSafe(format!("SELECT COUNT(*) FROM {table}"))).fetch_one(pool).await.unwrap();
+                counts.push((table, count));
+            }
+            let summary: Option<String> = sqlx::query_scalar("SELECT CAST(updated_at AS TEXT) FROM workflow_run_summaries")
+                .fetch_one(pool).await.unwrap();
+            (counts, summary)
+        };
+        let before = snapshot().await;
+
+        // The service refuses before reading the body, valid or not.
+        for body in [json!({"message_id": "m-1", "input": ["x"]}), json!({"message_id": 7, "input": "not a list"})] {
+            match runtime.append_message(&workflow_id, "orders", body, json!({})).await {
+                Err(super::super::RuntimeError::Protocol { status, response }) => {
+                    assert_eq!(status, StatusCode::CONFLICT, "{response}");
+                    assert_eq!((&response["reason"], &response["run_id"]), (&json!("v1_projection_read_only"), &run_id), "{response}");
+                    assert_eq!(response["operation"], "message_stream_append");
+                }
+                other => panic!("{other:?}"),
+            }
+        }
+        // The store's own guard refuses under its lock, and malformed input
+        // is not counted against a projection.
+        match runtime.store_append_message(&workflow_id, "orders", "m-2", "wwHioz3/VYAiNwA=").await {
+            Err(super::super::RuntimeError::Protocol { status, response }) => {
+                assert_eq!((status, &response["reason"]), (StatusCode::CONFLICT, &json!("v1_projection_read_only")), "{response}");
+            }
+            other => panic!("{other:?}"),
+        }
+        runtime.record_malformed_message(&workflow_id, "orders", &json!("m-3")).await.unwrap();
+
+        assert_eq!(snapshot().await, before);
+        runtime.close().await;
+    }
+
+    #[test]
+    fn size_limits_name_the_first_dimension_exceeded() {
+        let limits = |events, bytes| super::super::StructuralLimits { history_events: events, history_bytes: bytes,
+            ..super::super::StructuralLimits::default() };
+        assert!(exceeded(&limits(Some(3), Some(100)), 3, 100).is_none());
+        let refusal = exceeded(&limits(Some(3), Some(100)), 4, 101).unwrap().to_json();
+        assert_eq!((&refusal["reason"], &refusal["limit"]), (&json!("v1_projection_too_large"),
+            &json!({"dimension": "history_transaction_size", "used": 4, "limit": 3})));
+        let refusal = exceeded(&limits(Some(3), Some(100)), 3, 101).unwrap().to_json();
+        assert_eq!(refusal["limit"]["dimension"], "history_transaction_bytes");
+        // 0 disables a limit.
+        assert!(exceeded(&limits(Some(0), Some(0)), usize::MAX, usize::MAX).is_none());
+    }
+
     #[test]
     fn mapped_identities_follow_php() {
         // PHP: LegacyV1Projection::mappedIdentity('legacy-prod', 'v1:42').
@@ -949,6 +1112,63 @@ mod tests {
         assert_eq!(mapped_identity("::", "v1:1").0.split(':').nth(1), Some("source"));
     }
 
+    /// A completed source with `logs` logs, parsed as the request body is.
+    fn completed_source(logs: usize) -> Php {
+        let logs: Vec<Value> = (0..logs).map(|index| json!({"id": index, "class": "App\\Activities\\Step",
+            "result": "s:4:\"done\";", "created_at": "2026-09-30T08:00:01.000000Z"})).collect();
+        let body = json!({"operator_id": "v1:4501", "engine_source": "v1", "class": "App\\Workflows\\Legacy\\Bare",
+            "status": "completed", "logs": logs, "signals": [{"id": 1, "name": "go"}], "exceptions": "not rows"});
+        super::super::php_value::decode(body.to_string().as_bytes()).unwrap()
+    }
+
+    fn limited(events: Option<usize>, bytes: Option<usize>) -> super::super::StructuralLimits {
+        super::super::StructuralLimits { history_events: events, history_bytes: bytes, ..super::super::StructuralLimits::default() }
+    }
+
+    #[test]
+    fn the_event_count_is_refused_before_any_event_is_built() {
+        let source = completed_source(10);
+        let source = source.array().unwrap();
+        // Start, ten logs, one signal and the terminal event; a non-row
+        // exceptions value counts nothing.
+        let Outcome::Valid(normalized) = normalize_bounded("src-1", source, None, &limited(Some(13), None)) else { panic!("exact count") };
+        assert_eq!(normalized.events.len(), 13);
+        match normalize_bounded("src-1", source, None, &limited(Some(12), None)) {
+            Outcome::TooLarge { error, encoded } => {
+                // Refused from the row counts: no event built or measured.
+                assert_eq!(encoded, 0);
+                assert_eq!(error.to_json()["limit"], json!({"dimension": "history_transaction_size", "used": 13, "limit": 12}));
+            }
+            _ => panic!("one over the event limit"),
+        }
+        // An invalid source still answers its own errors first.
+        let invalid = super::super::php_value::decode(br#"{"engine_source":"v1","logs":[{},{},{}]}"#).unwrap();
+        assert!(matches!(normalize_bounded("src-1", invalid.array().unwrap(), None, &limited(Some(1), None)), Outcome::Invalid { .. }));
+    }
+
+    #[test]
+    fn history_bytes_stop_at_the_first_event_over_the_limit() {
+        let source = completed_source(10);
+        let source = source.array().unwrap();
+        let Outcome::Valid(normalized) = normalize_bounded("src-1", source, None, &limited(None, None)) else { panic!("valid") };
+        let total = usize::try_from(normalized.history_size_bytes).unwrap();
+        let Outcome::Valid(exact) = normalize_bounded("src-1", source, None, &limited(None, Some(total))) else { panic!("exact bytes") };
+        assert_eq!(exact.history_size_bytes, normalized.history_size_bytes);
+        // One byte short: measured to the last event, which passes the limit.
+        match normalize_bounded("src-1", source, None, &limited(None, Some(total - 1))) {
+            Outcome::TooLarge { error, encoded } => {
+                assert_eq!(encoded, normalized.events.len());
+                assert_eq!(error.to_json()["limit"], json!({"dimension": "history_transaction_bytes", "used": total, "limit": total - 1}));
+            }
+            _ => panic!("one byte over"),
+        }
+        // A limit below the first event stops after measuring that event.
+        match normalize_bounded("src-1", source, None, &limited(None, Some(1))) {
+            Outcome::TooLarge { encoded, .. } => assert_eq!(encoded, 1),
+            _ => panic!("far over"),
+        }
+    }
+
     #[test]
     fn events_and_history_size_follow_php() {
         // PHP 2.11.1: LegacyV1Projection::normalize('src-1', bare source, 'ns-1')
diff --git a/rust/tests/execution.rs b/rust/tests/execution.rs
index 8d41575e4..ee445d5a3 100644
--- a/rust/tests/execution.rs
+++ b/rust/tests/execution.rs
@@ -204,6 +204,8 @@ mod command_requests;
 mod describe_actions;
 #[path = "execution/run_deadlines.rs"]
 mod run_deadlines;
+#[path = "execution/waterline_projection_guards.rs"]
+mod waterline_projection_guards;
 #[path = "execution/operator_dashboard.rs"]
 mod operator_dashboard;
 #[path = "execution/waterline_reads.rs"]
diff --git a/rust/tests/execution/structural_limits.rs b/rust/tests/execution/structural_limits.rs
index 42534b31e..2a6d49b4d 100644
--- a/rust/tests/execution/structural_limits.rs
+++ b/rust/tests/execution/structural_limits.rs
@@ -11,6 +11,7 @@ async fn limited(database: &TestDatabase, signals: usize, updates: usize, payloa
         pending_signals: Some(signals),
         pending_updates: Some(updates),
         payload_bytes: Some(payload),
+        ..StructuralLimits::default()
     };
     let runtime = database.open().await.unwrap().with_structural_limits(limits);
     (runtime.clone(), router(runtime))
@@ -221,3 +222,44 @@ async fn an_oversized_activity_result_fails_the_activity_like_php() {
     runtime.close().await;
     database.remove().await;
 }
+
+/// The history transaction ceilings as the operator metrics, the health
+/// snapshot and the nested backend capabilities report them.
+async fn published_history_limits(app: &Router) -> Vec<(String, Value, Value)> {
+    let (status, metrics) = request(app, "GET", "/api/system/operator-metrics", Value::Null).await;
+    assert_eq!(status, StatusCode::OK, "{metrics}");
+    let (status, health) = request(app, "GET", "/api/system/health", Value::Null).await;
+    assert_eq!(status, StatusCode::OK, "{health}");
+    let metrics = &metrics["operator_metrics"];
+    let surfaces = [
+        ("metrics configured", &metrics["structural_limits"]["configured"]),
+        ("metrics effective", &metrics["structural_limits"]["effective"]),
+        ("backend configured", &metrics["backend"]["structural_limits"]["configured"]),
+        ("backend effective", &metrics["backend"]["structural_limits"]["effective"]),
+        ("health configured", &health["health"]["structural_limits"]["configured"]),
+        ("health effective", &health["health"]["structural_limits"]["effective"]),
+    ];
+    surfaces.into_iter().map(|(surface, limits)| {
+        (surface.to_owned(), limits["history_transaction_size"].clone(), limits["history_transaction_bytes"].clone())
+    }).collect()
+}
+
+#[tokio::test]
+async fn every_surface_reports_the_active_history_transaction_limits() {
+    let database = TestDatabase::new().await;
+    for (events, bytes, shown) in [
+        (Some(4321), Some(987_654), (json!(4321), json!(987_654))),
+        (Some(0), None, (json!(0), json!(0))),
+    ] {
+        let limits = StructuralLimits { history_events: events, history_bytes: bytes, ..StructuralLimits::default() };
+        let app = router(database.open().await.unwrap().with_structural_limits(limits));
+        for (surface, size, published_bytes) in published_history_limits(&app).await {
+            assert_eq!((&size, &published_bytes), (&shown.0, &shown.1), "{surface}");
+        }
+    }
+    // The defaults, from no configuration.
+    let app = router(database.open().await.unwrap());
+    for (surface, size, bytes) in published_history_limits(&app).await {
+        assert_eq!((size, bytes), (json!(5000), json!(16_777_216)), "{surface}");
+    }
+}
diff --git a/rust/tests/execution/waterline_projection_guards.rs b/rust/tests/execution/waterline_projection_guards.rs
new file mode 100644
index 000000000..fb984355d
--- /dev/null
+++ b/rust/tests/execution/waterline_projection_guards.rs
@@ -0,0 +1,117 @@
+use super::*;
+use durable_workflow_server::runtime::StructuralLimits;
+
+// A Waterline v1 projection is one standalone, read-only run. Native refuses
+// a message stream append to it before reading the body (published 2.11.1
+// accepts one and creates a signal and a workflow task), and refuses a
+// projection larger than one transaction may write before reading or
+// writing any row (published 2.11.1 has no limit).
+
+const ROUTE: &str = "/api/workflows/import/waterline-v1";
+
+/// The running source of the waterline-import fixture, with `logs` logs.
+fn running(logs: usize) -> Value {
+    json!({"id": "v1:4201", "legacy_id": "4201", "engine_source": "v1", "class": "App\\Workflows\\Legacy\\Subscription",
+        "status": "running", "connection": "database", "queue": "legacy-billing", "arguments": "a:0:{}",
+        "logs": (0..logs).map(|index| json!({"id": 9101 + index, "index": index, "now": "2026-09-30T09:00:01.000000Z",
+            "class": "App\\Activities\\Bill", "result": "i:42;", "created_at": "2026-09-30T09:00:02.000000Z"})).collect::<Vec<_>>(),
+        "signals": [], "exceptions": [], "created_at": "2026-09-30T09:00:00.000000Z"})
+}
+
+async fn import(app: &Router, source_id: &str, workflow: Value) -> (StatusCode, Value) {
+    request(app, "POST", ROUTE, json!({"source_id": source_id, "workflow": workflow})).await
+}
+
+async fn count(database: &TestDatabase, table: &str) -> i64 {
+    task_retry::rows(database, Box::leak(format!("SELECT COUNT(*) FROM {table}").into_boxed_str())).await
+}
+
+/// Every table a projection or a stream append could write.
+async fn rows(database: &TestDatabase) -> Vec<(&'static str, i64)> {
+    let mut counts = Vec::new();
+    for table in ["workflow_instances", "workflow_runs", "workflow_history_events", "workflow_run_summaries", "workflow_tasks",
+        "workflow_commands", "workflow_signal_records", "workflow_inbound_streams", "workflow_inbound_stream_items"] {
+        counts.push((table, count(database, table).await));
+    }
+    counts
+}
+
+#[tokio::test]
+async fn appends_to_a_projection_are_refused_before_their_body_is_read() {
+    let database = TestDatabase::new().await;
+    let app = router(database.open().await.unwrap());
+    let (status, report) = import(&app, "guard-src", running(1)).await;
+    assert_eq!(status, StatusCode::CREATED, "{report}");
+    let workflow_id = report["identity"]["standalone"]["workflow_id"].as_str().unwrap().to_owned();
+    let run_id = report["identity"]["standalone"]["run_id"].clone();
+    let path = format!("/api/workflows/{}/message-streams/orders/messages", workflow_id.replace(':', "%3A"));
+    let before = rows(&database).await;
+    let (status, described) = request(&app, "GET", &format!("/api/workflows/{}", workflow_id.replace(':', "%3A")), Value::Null).await;
+    assert_eq!(status, StatusCode::OK, "{described}");
+
+    for body in [json!({"message_id": "m-1", "input": ["x"]}), json!({"message_id": 7, "input": "not a list"}), json!("not an object")] {
+        let (status, refusal) = request(&app, "POST", &path, body.clone()).await;
+        assert_eq!(status, StatusCode::CONFLICT, "{body}: {refusal}");
+        assert_eq!(refusal["reason"], "v1_projection_read_only", "{refusal}");
+        assert_eq!((&refusal["operation"], &refusal["run_id"], &refusal["stream_name"]),
+            (&json!("message_stream_append"), &run_id, &json!("orders")), "{refusal}");
+        assert_eq!((&refusal["accepted"], &refusal["outcome"]), (&json!(false), &json!("rejected")), "{refusal}");
+    }
+
+    // No stream, item, signal, command, history, task or summary changed.
+    assert_eq!(rows(&database).await, before);
+    let (_, after) = request(&app, "GET", &format!("/api/workflows/{}", workflow_id.replace(':', "%3A")), Value::Null).await;
+    assert_eq!(after, described);
+}
+
+#[tokio::test]
+async fn a_projection_past_the_event_limit_is_refused_before_any_row() {
+    let database = TestDatabase::new().await;
+    let limits = StructuralLimits { history_events: Some(3), ..StructuralLimits::default() };
+    let app = router(database.open().await.unwrap().with_structural_limits(limits));
+
+    // The start event and two logs: exactly the limit.
+    let (status, report) = import(&app, "events-a", running(2)).await;
+    assert_eq!(status, StatusCode::CREATED, "{report}");
+    let before = rows(&database).await;
+
+    // One log more, and many more: refused, nothing written.
+    for (source, logs, used) in [("events-b", 3, 4), ("events-c", 500, 501)] {
+        let (status, refusal) = import(&app, source, running(logs)).await;
+        assert_eq!(status, StatusCode::CONFLICT, "{refusal}");
+        assert_eq!((&refusal["status"], &refusal["reason"]), (&json!("rejected"), &json!("v1_projection_too_large")), "{refusal}");
+        assert_eq!(refusal["limit"], json!({"dimension": "history_transaction_size", "used": used, "limit": 3}), "{refusal}");
+        assert_eq!(rows(&database).await, before);
+    }
+}
+
+#[tokio::test]
+async fn a_projection_past_the_byte_limit_is_refused_before_any_row() {
+    let database = TestDatabase::new().await;
+    // Measure one projection's history bytes as the summary records them.
+    let open = router(database.open().await.unwrap());
+    let (status, report) = import(&open, "bytes-a", running(2)).await;
+    assert_eq!(status, StatusCode::CREATED, "{report}");
+    let standalone = &report["identity"]["standalone"];
+    let export = format!("/api/workflows/{}/runs/{}/history/export",
+        standalone["workflow_id"].as_str().unwrap().replace(':', "%3A"), standalone["run_id"].as_str().unwrap());
+    let (status, bundle) = request(&open, "GET", &export, Value::Null).await;
+    assert_eq!(status, StatusCode::OK, "{bundle}");
+    let bytes = usize::try_from(bundle["summary"]["history_size_bytes"].as_i64().unwrap()).unwrap();
+    assert!(bytes > 0, "{bundle}");
+
+    // Source ids of one length give projections of one size.
+    let exact = router(database.open().await.unwrap()
+        .with_structural_limits(StructuralLimits { history_bytes: Some(bytes), ..StructuralLimits::default() }));
+    let (status, report) = import(&exact, "bytes-b", running(2)).await;
+    assert_eq!(status, StatusCode::CREATED, "{report}");
+    let before = rows(&database).await;
+
+    let short = router(database.open().await.unwrap()
+        .with_structural_limits(StructuralLimits { history_bytes: Some(bytes - 1), ..StructuralLimits::default() }));
+    let (status, refusal) = import(&short, "bytes-c", running(2)).await;
+    assert_eq!(status, StatusCode::CONFLICT, "{refusal}");
+    assert_eq!(refusal["reason"], "v1_projection_too_large", "{refusal}");
+    assert_eq!(refusal["limit"], json!({"dimension": "history_transaction_bytes", "used": bytes, "limit": bytes - 1}), "{refusal}");
+    assert_eq!(rows(&database).await, before);
+}

From 66767200024bf09fcfd6ba505b823834b1f7c942 Mon Sep 17 00:00:00 2001
From: Richard McDaniel <1130888+rmcdaniel@users.noreply.github.com>
Date: Sun, 25 Oct 2026 23:09:15 +0000
Subject: [PATCH 6/9] Rust #325: prove appends racing a projection import never
 write

Twenty-four appends race the import that creates a Waterline v1
projection on a four-thread runtime. Each answers 404 instance_not_found
or 409 v1_projection_read_only, and afterwards only the projection's own
rows exist: the store decides under the lock every durable transaction
takes, before the duplicate-replay update and the new item.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../execution/waterline_projection_guards.rs  | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/rust/tests/execution/waterline_projection_guards.rs b/rust/tests/execution/waterline_projection_guards.rs
index fb984355d..17ab2b93b 100644
--- a/rust/tests/execution/waterline_projection_guards.rs
+++ b/rust/tests/execution/waterline_projection_guards.rs
@@ -115,3 +115,47 @@ async fn a_projection_past_the_byte_limit_is_refused_before_any_row() {
     assert_eq!(refusal["limit"], json!({"dimension": "history_transaction_bytes", "used": bytes, "limit": bytes - 1}), "{refusal}");
     assert_eq!(rows(&database).await, before);
 }
+
+/// Appends racing the import that creates a projection: each answers that
+/// the instance does not exist yet or that it is read-only, and no stream,
+/// item, signal, command or task is ever written. The store decides under
+/// the lock every durable transaction takes, so the race has one outcome.
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn appends_racing_a_projection_import_never_write() {
+    let database = TestDatabase::new().await;
+    let app = router(database.open().await.unwrap());
+    let (status, dry) = request(&app, "POST", ROUTE, json!({"source_id": "race-src", "workflow": running(1), "dry_run": true})).await;
+    assert_eq!(status, StatusCode::OK, "{dry}");
+    let workflow_id = dry["identity"]["standalone"]["workflow_id"].as_str().unwrap().to_owned();
+    let path = format!("/api/workflows/{}/message-streams/orders/messages", workflow_id.replace(':', "%3A"));
+    let before = rows(&database).await;
+
+    let mut appends = tokio::task::JoinSet::new();
+    for index in 0..24 {
+        let (app, path) = (app.clone(), path.clone());
+        appends.spawn(async move {
+            request(&app, "POST", &path, json!({"message_id": format!("m-{index}"), "input": ["x"]})).await
+        });
+    }
+    let (status, report) = import(&app, "race-src", running(1)).await;
+    assert_eq!(status, StatusCode::CREATED, "{report}");
+    while let Some(answer) = appends.join_next().await {
+        let (status, body) = answer.unwrap();
+        let expected = match status {
+            StatusCode::NOT_FOUND => "instance_not_found",
+            StatusCode::CONFLICT => "v1_projection_read_only",
+            other => panic!("{other}: {body}"),
+        };
+        assert_eq!(body["reason"], expected, "{body}");
+    }
+    // After the race, the projection and only the projection was written.
+    let after = rows(&database).await;
+    for ((table, was), (_, now)) in before.iter().zip(&after) {
+        let grew = match *table {
+            "workflow_instances" | "workflow_runs" | "workflow_run_summaries" => 1,
+            "workflow_history_events" => 2,
+            _ => 0,
+        };
+        assert_eq!(*now, was + grew, "{table}");
+    }
+}

From f9fdc66837b69fb6800f7eb658f72a45e9e86fec Mon Sep 17 00:00:00 2001
From: Richard McDaniel <1130888+rmcdaniel@users.noreply.github.com>
Date: Sun, 25 Oct 2026 23:34:06 +0000
Subject: [PATCH 7/9] Rust #325: build Waterline v1 events within the byte
 limit

Security's review of 66767200:

- events() now orders the projected events from their boundary, time and
  source order alone, then builds, encodes and counts one event at a time.
  The first event past DW_V2_LIMIT_HISTORY_TRANSACTION_BYTES stops the
  build before it is kept or any later event is built. TooLarge reports
  how many events were built, and a test-only counter proves an early
  over-limit event builds none of the thousands after it.
- history_rows is removed from this change: #766 adds it with its
  enforcement, audit and disclosure.
- The no-write snapshots count every table of the test database,
  workflow_links included.
- A lock barrier control holds each backend's transition lock while the
  projection's install waits on it: an append then finds no instance and
  writes nothing, and once the install commits an append is refused.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/rust-server-port.md                      |   4 +-
 rust/src/runtime/memo_limits.rs               |  14 +-
 rust/src/runtime/waterline_import.rs          | 282 ++++++++++++------
 rust/tests/execution.rs                       |  38 +++
 .../execution/waterline_projection_guards.rs  | 107 ++++++-
 5 files changed, 325 insertions(+), 120 deletions(-)

diff --git a/docs/rust-server-port.md b/docs/rust-server-port.md
index e7601e997..1e7858d07 100644
--- a/docs/rust-server-port.md
+++ b/docs/rust-server-port.md
@@ -242,8 +242,8 @@ contract fixture before its correction.
     bytes than one transaction may (`DW_V2_LIMIT_HISTORY_TRANSACTION_SIZE`,
     `_BYTES`) with `409 v1_projection_too_large`, before reading or writing
     any row. The count is checked from the source's row counts before any
-    event is built, and history bytes are added up event by event, stopping
-    at the first event past the limit. Published 2.11.1 has no limit
+    event is built; then each event is built and measured in turn, and the
+    first event past the byte limit stops the build. Published 2.11.1 has no limit
     ([#770](https://github.com/durable-workflow/server/issues/770)).
   - Operator metrics, the health snapshot and the backend capabilities
     publish the active `history_transaction_size` and
diff --git a/rust/src/runtime/memo_limits.rs b/rust/src/runtime/memo_limits.rs
index afe1bfcf3..dd5efdd89 100644
--- a/rust/src/runtime/memo_limits.rs
+++ b/rust/src/runtime/memo_limits.rs
@@ -90,15 +90,13 @@ pub struct StructuralLimits {
     pub pending_updates: Option<usize>,
     /// Bytes of one serialized payload blob (DW_V2_LIMIT_PAYLOAD_SIZE_BYTES).
     pub payload_bytes: Option<usize>,
-    /// History events one workflow task completion may write
-    /// (DW_V2_LIMIT_HISTORY_TRANSACTION_SIZE; Workflow #930).
+    /// History events one transaction may write
+    /// (DW_V2_LIMIT_HISTORY_TRANSACTION_SIZE; Workflow #930): here, a
+    /// Waterline v1 projection import.
     pub history_events: Option<usize>,
-    /// History bytes one completion may write, measured as `HistoryBudget`
-    /// measures an event (DW_V2_LIMIT_HISTORY_TRANSACTION_BYTES).
+    /// History bytes one transaction may write, measured as PHP measures an
+    /// event (DW_V2_LIMIT_HISTORY_TRANSACTION_BYTES).
     pub history_bytes: Option<usize>,
-    /// Durable rows one completion may write
-    /// (DW_V2_LIMIT_HISTORY_TRANSACTION_ROWS).
-    pub history_rows: Option<usize>,
 }
 
 impl Default for StructuralLimits {
@@ -109,7 +107,6 @@ impl Default for StructuralLimits {
             payload_bytes: Some(2_097_152),
             history_events: Some(5000),
             history_bytes: Some(16_777_216),
-            history_rows: Some(20_000),
         }
     }
 }
@@ -124,7 +121,6 @@ impl StructuralLimits {
             payload_bytes: configured("PAYLOAD_SIZE_BYTES", defaults.payload_bytes.unwrap(), invalid)?,
             history_events: configured("HISTORY_TRANSACTION_SIZE", defaults.history_events.unwrap(), invalid)?,
             history_bytes: configured("HISTORY_TRANSACTION_BYTES", defaults.history_bytes.unwrap(), invalid)?,
-            history_rows: configured("HISTORY_TRANSACTION_ROWS", defaults.history_rows.unwrap(), invalid)?,
         })
     }
 }
diff --git a/rust/src/runtime/waterline_import.rs b/rust/src/runtime/waterline_import.rs
index 9ac941823..fa2c6fa11 100644
--- a/rust/src/runtime/waterline_import.rs
+++ b/rust/src/runtime/waterline_import.rs
@@ -291,9 +291,9 @@ pub(crate) struct Normalized {
 
 pub(crate) enum Outcome {
     Invalid { errors: Vec<Php> },
-    /// Larger than one transaction may write. `encoded` is how many events
-    /// were built and measured first: 0 for a refusal by count.
-    TooLarge { error: Php, encoded: usize },
+    /// Larger than one transaction may write. `built` is how many events
+    /// were built first: 0 for a refusal by count.
+    TooLarge { error: Php, built: usize },
     Valid(Box<Normalized>),
 }
 
@@ -360,7 +360,7 @@ pub(crate) fn normalize_bounded(source_id: &str, source: &PhpArray, namespace: O
     let projected = ["logs", "signals", "exceptions"].iter()
         .fold(1usize + usize::from(terminal), |total, key| total.saturating_add(row_count(source.get(key))));
     if let Some(error) = exceeded(limits, projected, 0) {
-        return Outcome::TooLarge { error, encoded: 0 };
+        return Outcome::TooLarge { error, built: 0 };
     }
     let (workflow_id, run_id, import_id) = mapped_identity(&source_id, &qualified);
     let connection = string(source.get("connection"));
@@ -423,24 +423,13 @@ pub(crate) fn normalize_bounded(source_id: &str, source: &PhpArray, namespace: O
         ("task_queue_context", task_queue),
         ("unsupported_fields", unsupported.clone()),
     ]);
-    let events = events(source, &logs, &signals, &exceptions, migration, status, started_at, last_progress_at, &run_id);
-    // `strlen(json_encode($event, JSON_UNESCAPED_SLASHES))` over each event
-    // as PHP holds it: type, Carbon time, payload, sequence and id. The
-    // first event past the byte limit stops the measure.
-    let mut history_size_bytes: usize = 0;
-    for (index, event) in events.iter().enumerate() {
-        let size = object(vec![
-            ("event_type", text(event.event_type)),
-            ("recorded_at", optional(json_time(event.recorded_at))),
-            ("payload", event.payload.clone()),
-            ("sequence", Php::Int(event.sequence)),
-            ("id", text(&event.id)),
-        ]).encode(Flags { unescaped_slashes: true, ..Flags::default() }).len();
-        history_size_bytes = history_size_bytes.saturating_add(size);
-        if let Some(error) = exceeded(limits, 0, history_size_bytes) {
-            return Outcome::TooLarge { error, encoded: index + 1 };
-        }
-    }
+    // Events are built one at a time, and the first past the byte limit
+    // stops the build.
+    let (events, history_size_bytes) = match events(source, &logs, &signals, &exceptions, migration, status, started_at,
+        last_progress_at, &run_id, limits) {
+        Ok(built) => built,
+        Err((error, built)) => return Outcome::TooLarge { error, built },
+    };
     let history_size_bytes = i64::try_from(history_size_bytes).unwrap_or(i64::MAX);
     Outcome::Valid(Box::new(Normalized {
         namespace,
@@ -497,49 +486,34 @@ fn unsupported_fields(source: &PhpArray, logs: &[PhpArray], signals: &[PhpArray]
 /// terminal event, ordered by boundary, whole-second time (untimed first)
 /// and source order, with sequence and id assigned after sorting.
 #[allow(clippy::too_many_arguments)]
+#[cfg(test)]
+thread_local! {
+    /// How many events `events` has built, for the controls that prove a
+    /// refused build stops at the first event past the limit.
+    static EVENTS_BUILT: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
+}
+
+/// Where a projected event comes from.
+#[derive(Clone, Copy)]
+enum Origin {
+    Start,
+    Log(usize),
+    Signal(usize),
+    Exception(usize),
+    Terminal(&'static str),
+}
+
+/// The projected events, ordered as PHP orders them, with their history
+/// bytes (`strlen(json_encode($event, JSON_UNESCAPED_SLASHES))` over each
+/// event as PHP holds it: type, Carbon time, payload, sequence and id).
+/// The order is decided from each event's boundary, time and source order
+/// alone; then each event is built and measured in turn, and the first one
+/// past the byte limit stops the build with how many were built.
+#[allow(clippy::too_many_arguments)]
 fn events(source: &PhpArray, logs: &[PhpArray], signals: &[PhpArray], exceptions: &[PhpArray], migration: Php,
-    status: &str, started_at: Option<Stamp>, last_progress_at: Option<Stamp>, run_id: &str) -> Vec<Event> {
+    status: &str, started_at: Option<Stamp>, last_progress_at: Option<Stamp>, run_id: &str,
+    limits: &super::StructuralLimits) -> std::result::Result<(Vec<Event>, usize), (Php, usize)> {
     let field = |row: &PhpArray, key: &str| row.get(key).cloned().unwrap_or(Php::Null);
-    let mut pending: Vec<(u8, i64, &'static str, Option<Stamp>, Php)> = vec![(0, 0, "WorkflowStarted", started_at, object(vec![
-        ("migration_projection", migration),
-        ("legacy_payloads", object(vec![("arguments", opaque(source.get("arguments")))])),
-    ]))];
-    for (index, log) in logs.iter().enumerate() {
-        pending.push((1, 100 + index as i64, "ActivityCompleted", timestamp(coalesce(log, &["created_at", "now"])), object(vec![
-            ("migration_projection", object(vec![
-                ("source_record", text("workflow_log")),
-                ("legacy_id", field(log, "id")),
-                ("legacy_index", field(log, "index")),
-            ])),
-            ("activity", object(vec![
-                ("class", field(log, "class")),
-                ("logical_time", field(log, "now")),
-                ("result", opaque(log.get("result"))),
-            ])),
-        ])));
-    }
-    for (index, signal) in signals.iter().enumerate() {
-        pending.push((1, 200 + index as i64, "SignalReceived", timestamp(coalesce(signal, &["created_at", "received_at"])), object(vec![
-            ("migration_projection", object(vec![
-                ("source_record", text("workflow_signal")),
-                ("legacy_id", field(signal, "id")),
-            ])),
-            ("signal_name", coalesce(signal, &["name", "method"]).cloned().unwrap_or(Php::Null)),
-            ("arguments", opaque(signal.get("arguments"))),
-        ])));
-    }
-    for (index, exception) in exceptions.iter().enumerate() {
-        pending.push((1, 300 + index as i64, "ActivityFailed", timestamp(exception.get("created_at")), object(vec![
-            ("migration_projection", object(vec![
-                ("source_record", text("workflow_exception")),
-                ("legacy_id", field(exception, "id")),
-            ])),
-            ("exception", object(vec![
-                ("class", field(exception, "class")),
-                ("value", opaque(exception.get("exception"))),
-            ])),
-        ])));
-    }
     let terminal = match status {
         "completed" => Some("WorkflowCompleted"),
         "failed" => Some("WorkflowFailed"),
@@ -547,31 +521,104 @@ fn events(source: &PhpArray, logs: &[PhpArray], signals: &[PhpArray], exceptions
         "terminated" => Some("WorkflowTerminated"),
         _ => None,
     };
+    let mut order: Vec<(u8, i64, Option<Stamp>, Origin)> =
+        Vec::with_capacity(2 + logs.len() + signals.len() + exceptions.len());
+    order.push((0, 0, started_at, Origin::Start));
+    for (index, log) in logs.iter().enumerate() {
+        order.push((1, 100 + index as i64, timestamp(coalesce(log, &["created_at", "now"])), Origin::Log(index)));
+    }
+    for (index, signal) in signals.iter().enumerate() {
+        order.push((1, 200 + index as i64, timestamp(coalesce(signal, &["created_at", "received_at"])), Origin::Signal(index)));
+    }
+    for (index, exception) in exceptions.iter().enumerate() {
+        order.push((1, 300 + index as i64, timestamp(exception.get("created_at")), Origin::Exception(index)));
+    }
     if let Some(event_type) = terminal {
-        pending.push((2, i64::MAX, event_type, last_progress_at, object(vec![
-            ("migration_projection", object(vec![
-                ("source_status", source.get("status").cloned().unwrap_or(Php::Null)),
-                ("execution_owner", text("v1")),
-            ])),
-            ("legacy_payloads", object(vec![("output", opaque(source.get("output")))])),
-        ])));
+        order.push((2, i64::MAX, last_progress_at, Origin::Terminal(event_type)));
     }
     // Carbon's getTimestamp: whole seconds; PHP_INT_MIN for an untimed event.
-    pending.sort_by_key(|(boundary, order, _, at, _)| (*boundary, at.map_or(i64::MIN, |at| at.utc.timestamp()), *order));
-    pending
-        .into_iter()
-        .enumerate()
-        .map(|(index, (_, _, event_type, recorded_at, payload))| {
-            let sequence = index as i64 + 1;
-            Event {
-                id: sha256(&format!("{run_id}\0{sequence}\0{event_type}"))[..26].to_owned(),
-                sequence,
-                event_type,
-                recorded_at,
-                payload,
+    order.sort_by_key(|(boundary, order, at, _)| (*boundary, at.map_or(i64::MIN, |at| at.utc.timestamp()), *order));
+
+    let mut migration = Some(migration);
+    let mut built = Vec::with_capacity(order.len());
+    let mut bytes: usize = 0;
+    for (index, (_, _, recorded_at, origin)) in order.into_iter().enumerate() {
+        let (event_type, payload) = match origin {
+            Origin::Start => ("WorkflowStarted", object(vec![
+                ("migration_projection", migration.take().unwrap_or(Php::Null)),
+                ("legacy_payloads", object(vec![("arguments", opaque(source.get("arguments")))])),
+            ])),
+            Origin::Log(index) => {
+                let log = &logs[index];
+                ("ActivityCompleted", object(vec![
+                    ("migration_projection", object(vec![
+                        ("source_record", text("workflow_log")),
+                        ("legacy_id", field(log, "id")),
+                        ("legacy_index", field(log, "index")),
+                    ])),
+                    ("activity", object(vec![
+                        ("class", field(log, "class")),
+                        ("logical_time", field(log, "now")),
+                        ("result", opaque(log.get("result"))),
+                    ])),
+                ]))
             }
-        })
-        .collect()
+            Origin::Signal(index) => {
+                let signal = &signals[index];
+                ("SignalReceived", object(vec![
+                    ("migration_projection", object(vec![
+                        ("source_record", text("workflow_signal")),
+                        ("legacy_id", field(signal, "id")),
+                    ])),
+                    ("signal_name", coalesce(signal, &["name", "method"]).cloned().unwrap_or(Php::Null)),
+                    ("arguments", opaque(signal.get("arguments"))),
+                ]))
+            }
+            Origin::Exception(index) => {
+                let exception = &exceptions[index];
+                ("ActivityFailed", object(vec![
+                    ("migration_projection", object(vec![
+                        ("source_record", text("workflow_exception")),
+                        ("legacy_id", field(exception, "id")),
+                    ])),
+                    ("exception", object(vec![
+                        ("class", field(exception, "class")),
+                        ("value", opaque(exception.get("exception"))),
+                    ])),
+                ]))
+            }
+            Origin::Terminal(event_type) => (event_type, object(vec![
+                ("migration_projection", object(vec![
+                    ("source_status", source.get("status").cloned().unwrap_or(Php::Null)),
+                    ("execution_owner", text("v1")),
+                ])),
+                ("legacy_payloads", object(vec![("output", opaque(source.get("output")))])),
+            ])),
+        };
+        #[cfg(test)]
+        EVENTS_BUILT.with(|count| count.set(count.get() + 1));
+        let sequence = index as i64 + 1;
+        let event = Event {
+            id: sha256(&format!("{run_id}\0{sequence}\0{event_type}"))[..26].to_owned(),
+            sequence,
+            event_type,
+            recorded_at,
+            payload,
+        };
+        let size = object(vec![
+            ("event_type", text(event.event_type)),
+            ("recorded_at", optional(json_time(event.recorded_at))),
+            ("payload", event.payload.clone()),
+            ("sequence", Php::Int(event.sequence)),
+            ("id", text(&event.id)),
+        ]).encode(Flags { unescaped_slashes: true, ..Flags::default() }).len();
+        bytes = bytes.checked_add(size).unwrap_or(usize::MAX);
+        if let Some(error) = exceeded(limits, 0, bytes) {
+            return Err((error, index + 1));
+        }
+        built.push(event);
+    }
+    Ok((built, bytes))
 }
 
 /// `report`: the projection report, with the first error's reason, message
@@ -1125,18 +1172,27 @@ mod tests {
         super::super::StructuralLimits { history_events: events, history_bytes: bytes, ..super::super::StructuralLimits::default() }
     }
 
+    /// Events built by `events` while `run` runs on this thread.
+    fn events_built<T>(run: impl FnOnce() -> T) -> (T, usize) {
+        EVENTS_BUILT.with(|count| count.set(0));
+        let result = run();
+        (result, EVENTS_BUILT.with(std::cell::Cell::get))
+    }
+
     #[test]
     fn the_event_count_is_refused_before_any_event_is_built() {
         let source = completed_source(10);
         let source = source.array().unwrap();
         // Start, ten logs, one signal and the terminal event; a non-row
         // exceptions value counts nothing.
-        let Outcome::Valid(normalized) = normalize_bounded("src-1", source, None, &limited(Some(13), None)) else { panic!("exact count") };
-        assert_eq!(normalized.events.len(), 13);
-        match normalize_bounded("src-1", source, None, &limited(Some(12), None)) {
-            Outcome::TooLarge { error, encoded } => {
-                // Refused from the row counts: no event built or measured.
-                assert_eq!(encoded, 0);
+        let (outcome, built) = events_built(|| normalize_bounded("src-1", source, None, &limited(Some(13), None)));
+        let Outcome::Valid(normalized) = outcome else { panic!("exact count") };
+        assert_eq!((normalized.events.len(), built), (13, 13));
+        let (outcome, built) = events_built(|| normalize_bounded("src-1", source, None, &limited(Some(12), None)));
+        match outcome {
+            Outcome::TooLarge { error, built: reported } => {
+                // Refused from the row counts: no event built.
+                assert_eq!((reported, built), (0, 0));
                 assert_eq!(error.to_json()["limit"], json!({"dimension": "history_transaction_size", "used": 13, "limit": 12}));
             }
             _ => panic!("one over the event limit"),
@@ -1147,26 +1203,56 @@ mod tests {
     }
 
     #[test]
-    fn history_bytes_stop_at_the_first_event_over_the_limit() {
+    fn history_bytes_stop_the_build_at_the_first_event_over_the_limit() {
         let source = completed_source(10);
         let source = source.array().unwrap();
         let Outcome::Valid(normalized) = normalize_bounded("src-1", source, None, &limited(None, None)) else { panic!("valid") };
         let total = usize::try_from(normalized.history_size_bytes).unwrap();
         let Outcome::Valid(exact) = normalize_bounded("src-1", source, None, &limited(None, Some(total))) else { panic!("exact bytes") };
         assert_eq!(exact.history_size_bytes, normalized.history_size_bytes);
-        // One byte short: measured to the last event, which passes the limit.
+        // One byte short: every event is built, and the last passes the limit.
         match normalize_bounded("src-1", source, None, &limited(None, Some(total - 1))) {
-            Outcome::TooLarge { error, encoded } => {
-                assert_eq!(encoded, normalized.events.len());
+            Outcome::TooLarge { error, built } => {
+                assert_eq!(built, normalized.events.len());
                 assert_eq!(error.to_json()["limit"], json!({"dimension": "history_transaction_bytes", "used": total, "limit": total - 1}));
             }
             _ => panic!("one byte over"),
         }
-        // A limit below the first event stops after measuring that event.
-        match normalize_bounded("src-1", source, None, &limited(None, Some(1))) {
-            Outcome::TooLarge { encoded, .. } => assert_eq!(encoded, 1),
-            _ => panic!("far over"),
+    }
+
+    #[test]
+    fn an_early_event_over_the_byte_limit_builds_no_later_event() {
+        // The start event is first and carries the source's arguments; many
+        // valid logs follow it.
+        let mut source = completed_source(2_000);
+        if let Php::Array(array) = &mut source {
+            array.0.push((Key::of("arguments"), text("x".repeat(50_000))));
+        }
+        let source = source.array().unwrap();
+        let (outcome, built) = events_built(|| normalize_bounded("src-1", source, None, &limited(None, Some(10_000))));
+        match outcome {
+            Outcome::TooLarge { error, built: reported } => {
+                // Only the start event was built; none of the 2,002 after it.
+                assert_eq!((reported, built), (1, 1));
+                assert_eq!(error.to_json()["limit"]["dimension"], "history_transaction_bytes");
+            }
+            _ => panic!("the start event alone passes the limit"),
         }
+        // With room for the start event and a few more, the build stops at
+        // the first event past the limit.
+        let (outcome, start) = events_built(|| normalize_bounded("src-1", source, None, &limited(None, None)));
+        let Outcome::Valid(all) = outcome else { panic!("valid") };
+        assert_eq!(start, all.events.len());
+        let first = |count: usize| all.events[..count].iter().map(|event| object(vec![
+            ("event_type", text(event.event_type)),
+            ("recorded_at", optional(json_time(event.recorded_at))),
+            ("payload", event.payload.clone()),
+            ("sequence", Php::Int(event.sequence)),
+            ("id", text(&event.id)),
+        ]).encode(Flags { unescaped_slashes: true, ..Flags::default() }).len()).sum::<usize>();
+        let (outcome, built) = events_built(|| normalize_bounded("src-1", source, None, &limited(None, Some(first(4)))));
+        assert!(matches!(outcome, Outcome::TooLarge { built: 5, .. }));
+        assert_eq!(built, 5);
     }
 
     #[test]
diff --git a/rust/tests/execution.rs b/rust/tests/execution.rs
index ee445d5a3..c86070a05 100644
--- a/rust/tests/execution.rs
+++ b/rust/tests/execution.rs
@@ -324,6 +324,44 @@ enum TestDatabase {
     },
 }
 
+/// The rows of a two-column text query, written for each backend.
+async fn text_rows(database: &TestDatabase, sqlite: &str, postgres: &str, mysql: &str) -> Vec<(String, String)> {
+    match database {
+        TestDatabase::Sqlite(dir) => {
+            let pool = sqlx::SqlitePool::connect(&format!("sqlite://{}", dir.path().join("runtime.sqlite").display())).await.unwrap();
+            let rows = sqlx::query_as(sqlx::AssertSqlSafe(sqlite.to_owned())).fetch_all(&pool).await.unwrap();
+            pool.close().await;
+            rows
+        }
+        TestDatabase::Postgres { options, .. } => {
+            let pool = sqlx::postgres::PgPoolOptions::new().connect_with(options.as_ref().clone()).await.unwrap();
+            let rows = sqlx::query_as(sqlx::AssertSqlSafe(postgres.to_owned())).fetch_all(&pool).await.unwrap();
+            pool.close().await;
+            rows
+        }
+        TestDatabase::MySql { options, .. } => {
+            let pool = sqlx::mysql::MySqlPoolOptions::new().connect_with(options.as_ref().clone()).await.unwrap();
+            let rows = sqlx::query_as(sqlx::AssertSqlSafe(mysql.to_owned())).fetch_all(&pool).await.unwrap();
+            pool.close().await;
+            rows
+        }
+    }
+}
+
+/// Every table of the test database, by name, with its row count.
+async fn table_counts(database: &TestDatabase) -> Vec<(String, i64)> {
+    let tables = text_rows(database,
+        "SELECT name, name FROM sqlite_master WHERE type='table' ORDER BY name",
+        "SELECT table_name::text, table_name::text FROM information_schema.tables WHERE table_schema='public' ORDER BY 1",
+        "SELECT CAST(table_name AS CHAR), CAST(table_name AS CHAR) FROM information_schema.tables WHERE table_schema=DATABASE() ORDER BY 1").await;
+    let mut counts = Vec::with_capacity(tables.len());
+    for (table, _) in tables {
+        let sql: &'static str = Box::leak(format!("SELECT COUNT(*) FROM {table}").into_boxed_str());
+        counts.push((table, task_retry::rows(database, sql).await));
+    }
+    counts
+}
+
 impl TestDatabase {
     async fn new() -> Self {
         assert!(
diff --git a/rust/tests/execution/waterline_projection_guards.rs b/rust/tests/execution/waterline_projection_guards.rs
index 17ab2b93b..414723e4e 100644
--- a/rust/tests/execution/waterline_projection_guards.rs
+++ b/rust/tests/execution/waterline_projection_guards.rs
@@ -22,16 +22,12 @@ async fn import(app: &Router, source_id: &str, workflow: Value) -> (StatusCode,
     request(app, "POST", ROUTE, json!({"source_id": source_id, "workflow": workflow})).await
 }
 
-async fn count(database: &TestDatabase, table: &str) -> i64 {
-    task_retry::rows(database, Box::leak(format!("SELECT COUNT(*) FROM {table}").into_boxed_str())).await
-}
-
-/// Every table a projection or a stream append could write.
-async fn rows(database: &TestDatabase) -> Vec<(&'static str, i64)> {
-    let mut counts = Vec::new();
-    for table in ["workflow_instances", "workflow_runs", "workflow_history_events", "workflow_run_summaries", "workflow_tasks",
-        "workflow_commands", "workflow_signal_records", "workflow_inbound_streams", "workflow_inbound_stream_items"] {
-        counts.push((table, count(database, table).await));
+/// Every table's row count: a projection or a stream append may write no
+/// other row than the ones each test expects.
+async fn rows(database: &TestDatabase) -> Vec<(String, i64)> {
+    let counts = table_counts(database).await;
+    for table in ["workflow_links", "workflow_inbound_streams", "workflow_inbound_stream_items", "workflow_signal_records"] {
+        assert!(counts.iter().any(|(name, _)| name == table), "{table} is not in {counts:?}");
     }
     counts
 }
@@ -150,8 +146,97 @@ async fn appends_racing_a_projection_import_never_write() {
     }
     // After the race, the projection and only the projection was written.
     let after = rows(&database).await;
+    assert_eq!(before.len(), after.len());
+    for ((table, was), (_, now)) in before.iter().zip(&after) {
+        let grew = match table.as_str() {
+            "workflow_instances" | "workflow_runs" | "workflow_run_summaries" => 1,
+            "workflow_history_events" => 2,
+            _ => 0,
+        };
+        assert_eq!(*now, was + grew, "{table}");
+    }
+}
+
+/// A connection holding the lock every durable transaction takes on this
+/// backend: while it is held, no transaction can begin its writes.
+enum TransitionLock {
+    Sqlite(sqlx::SqliteConnection),
+    Postgres(sqlx::PgConnection),
+    MySql(sqlx::MySqlConnection),
+}
+
+async fn hold_transition_lock(database: &TestDatabase) -> TransitionLock {
+    use sqlx::Connection;
+    match database {
+        TestDatabase::Sqlite(dir) => {
+            let url = format!("sqlite://{}", dir.path().join("runtime.sqlite").display());
+            let mut connection = sqlx::SqliteConnection::connect(&url).await.unwrap();
+            sqlx::query("BEGIN IMMEDIATE").execute(&mut connection).await.unwrap();
+            TransitionLock::Sqlite(connection)
+        }
+        TestDatabase::Postgres { options, .. } => {
+            let mut connection = sqlx::PgConnection::connect_with(options).await.unwrap();
+            sqlx::query("SELECT pg_advisory_lock(4924501473315676163)").execute(&mut connection).await.unwrap();
+            TransitionLock::Postgres(connection)
+        }
+        TestDatabase::MySql { options, .. } => {
+            let mut connection = sqlx::MySqlConnection::connect_with(options).await.unwrap();
+            // MySQL runs transaction control only outside prepared statements.
+            sqlx::raw_sql("START TRANSACTION").execute(&mut connection).await.unwrap();
+            sqlx::query("SELECT engine FROM dw_server_schema WHERE engine='rust-development' FOR UPDATE")
+                .execute(&mut connection).await.unwrap();
+            TransitionLock::MySql(connection)
+        }
+    }
+}
+
+async fn release(lock: TransitionLock) {
+    match lock {
+        TransitionLock::Sqlite(mut connection) => { sqlx::query("ROLLBACK").execute(&mut connection).await.unwrap(); }
+        TransitionLock::Postgres(mut connection) => {
+            sqlx::query("SELECT pg_advisory_unlock(4924501473315676163)").execute(&mut connection).await.unwrap();
+        }
+        TransitionLock::MySql(mut connection) => { sqlx::raw_sql("ROLLBACK").execute(&mut connection).await.unwrap(); }
+    }
+}
+
+/// The projection's install waits on the transition lock, so its outcome is
+/// fixed on both sides: an append made while the install is pending finds
+/// no instance and writes nothing, and one made after it commits is refused.
+/// An append reaches the store only for an existing instance, and a
+/// projection's instance and run are written in one transaction, so no
+/// append can pass the store's check and then see the projection appear.
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn an_append_cannot_cross_a_projection_install_waiting_on_the_lock() {
+    let database = TestDatabase::new().await;
+    let app = router(database.open().await.unwrap());
+    let (status, dry) = request(&app, "POST", ROUTE, json!({"source_id": "barrier-src", "workflow": running(1), "dry_run": true})).await;
+    assert_eq!(status, StatusCode::OK, "{dry}");
+    let workflow_id = dry["identity"]["standalone"]["workflow_id"].as_str().unwrap().to_owned();
+    let path = format!("/api/workflows/{}/message-streams/orders/messages", workflow_id.replace(':', "%3A"));
+    let before = rows(&database).await;
+
+    let lock = hold_transition_lock(&database).await;
+    let install = tokio::spawn({
+        let app = app.clone();
+        async move { import(&app, "barrier-src", running(1)).await }
+    });
+    // Give the install time to reach its transaction; it cannot commit.
+    tokio::time::sleep(std::time::Duration::from_millis(300)).await;
+    let (status, body) = request(&app, "POST", &path, json!({"message_id": "m-pending", "input": ["x"]})).await;
+    assert_eq!((status, &body["reason"]), (StatusCode::NOT_FOUND, &json!("instance_not_found")), "{body}");
+    assert!(!install.is_finished(), "the install committed while the transition lock was held");
+    release(lock).await;
+
+    let (status, report) = install.await.unwrap();
+    assert_eq!(status, StatusCode::CREATED, "{report}");
+    let (status, body) = request(&app, "POST", &path, json!({"message_id": "m-after", "input": ["x"]})).await;
+    assert_eq!((status, &body["reason"]), (StatusCode::CONFLICT, &json!("v1_projection_read_only")), "{body}");
+
+    let after = rows(&database).await;
+    assert_eq!(before.len(), after.len());
     for ((table, was), (_, now)) in before.iter().zip(&after) {
-        let grew = match *table {
+        let grew = match table.as_str() {
             "workflow_instances" | "workflow_runs" | "workflow_run_summaries" => 1,
             "workflow_history_events" => 2,
             _ => 0,

From 3e62112dd1758beeb224fba1c43d541404d071dd Mon Sep 17 00:00:00 2001
From: Richard McDaniel <1130888+rmcdaniel@users.noreply.github.com>
Date: Mon, 26 Oct 2026 00:05:57 +0000
Subject: [PATCH 8/9] Rust #325: observe the projection install waiting on the
 transition lock

The barrier control no longer sleeps and assumes. With the backend's
transition lock held, it waits until the install is seen waiting on that
lock in this test's own database (PostgreSQL's ungranted advisory lock,
or an InnoDB transaction in LOCK WAIT), polling on one connection, and
fails if it never is; only then is the append made. SQLite's writer waits
inside its own busy handler, which no other connection can see, so there
the result rests on the held lock alone.

On MariaDB the install did not reach its lock wait while the observer
polled information_schema from the start, so the observer waits a moment
first and still requires the wait to be seen.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../execution/waterline_projection_guards.rs  | 50 ++++++++++++++++++-
 1 file changed, 48 insertions(+), 2 deletions(-)

diff --git a/rust/tests/execution/waterline_projection_guards.rs b/rust/tests/execution/waterline_projection_guards.rs
index 414723e4e..d0c980d61 100644
--- a/rust/tests/execution/waterline_projection_guards.rs
+++ b/rust/tests/execution/waterline_projection_guards.rs
@@ -190,6 +190,49 @@ async fn hold_transition_lock(database: &TestDatabase) -> TransitionLock {
     }
 }
 
+/// Wait until another transaction waits on the transition lock, where the
+/// backend shows it: PostgreSQL's ungranted advisory lock, or an InnoDB
+/// transaction in LOCK WAIT, in this test's database only (other tests run
+/// in parallel). One connection polls, so the observer adds no connection
+/// churn. SQLite's writer waits inside its own busy handler, which no other
+/// connection can see; returns false there.
+async fn lock_waiter_observed(database: &TestDatabase) -> bool {
+    use sqlx::Connection;
+    const POSTGRES: &str = "SELECT COUNT(*) FROM pg_locks WHERE locktype='advisory' AND NOT granted \
+        AND database=(SELECT oid FROM pg_database WHERE datname=current_database())";
+    const MYSQL: &str = "SELECT COUNT(*) FROM information_schema.innodb_trx t \
+        JOIN information_schema.processlist p ON p.id=t.trx_mysql_thread_id WHERE t.trx_state='LOCK WAIT' AND p.db=DATABASE()";
+    let pause = || tokio::time::sleep(std::time::Duration::from_millis(50));
+    match database {
+        TestDatabase::Sqlite(_) => return false,
+        TestDatabase::Postgres { options, .. } => {
+            let mut connection = sqlx::PgConnection::connect_with(options).await.unwrap();
+            for _ in 0..200 {
+                let waiting: i64 = sqlx::query_scalar(POSTGRES).fetch_one(&mut connection).await.unwrap();
+                if waiting > 0 {
+                    return true;
+                }
+                pause().await;
+            }
+        }
+        TestDatabase::MySql { options, .. } => {
+            // On MariaDB the install did not reach its lock wait while this
+            // observer polled information_schema from the start; it waits
+            // a moment first, then still requires the wait to be seen.
+            tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
+            let mut connection = sqlx::MySqlConnection::connect_with(options).await.unwrap();
+            for _ in 0..200 {
+                let waiting: i64 = sqlx::query_scalar(MYSQL).fetch_one(&mut connection).await.unwrap();
+                if waiting > 0 {
+                    return true;
+                }
+                pause().await;
+            }
+        }
+    }
+    panic!("no transaction waited on the transition lock within ten seconds");
+}
+
 async fn release(lock: TransitionLock) {
     match lock {
         TransitionLock::Sqlite(mut connection) => { sqlx::query("ROLLBACK").execute(&mut connection).await.unwrap(); }
@@ -221,8 +264,11 @@ async fn an_append_cannot_cross_a_projection_install_waiting_on_the_lock() {
         let app = app.clone();
         async move { import(&app, "barrier-src", running(1)).await }
     });
-    // Give the install time to reach its transaction; it cannot commit.
-    tokio::time::sleep(std::time::Duration::from_millis(300)).await;
+    // On PostgreSQL and MySQL the install is seen waiting on the lock; on
+    // SQLite it cannot commit while the lock is held, wherever it is.
+    if !lock_waiter_observed(&database).await {
+        tokio::time::sleep(std::time::Duration::from_millis(300)).await;
+    }
     let (status, body) = request(&app, "POST", &path, json!({"message_id": "m-pending", "input": ["x"]})).await;
     assert_eq!((status, &body["reason"]), (StatusCode::NOT_FOUND, &json!("instance_not_found")), "{body}");
     assert!(!install.is_finished(), "the install committed while the transition lock was held");

From 6838f47feb76fc563a45b0a9f53cf4f048e447b1 Mon Sep 17 00:00:00 2001
From: Richard McDaniel <1130888+rmcdaniel@users.noreply.github.com>
Date: Mon, 26 Oct 2026 00:24:47 +0000
Subject: [PATCH 9/9] Rust #325: observe the SQLite install reaching the
 transition lock

SQLite's writer waits inside its own busy handler, which no other
connection can see, so the execution barrier no longer runs a timed
surrogate there. A test-only probe in waterline_write, keyed by workflow
id, now signals when a projection's install asks for the transition lock.
The library control holds BEGIN IMMEDIATE, waits for that signal, and only
then appends: the append finds no instance and writes nothing, the install
has not finished, and once it commits an append is refused; across every
table only the projection's rows were written. PostgreSQL, MySQL and
MariaDB keep the backend-visible waiter, now required without a fallback.

TooLarge.built, read only by the controls, no longer warns in a normal build.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 rust/src/runtime/waterline_import.rs          | 113 +++++++++++++++++-
 .../execution/waterline_projection_guards.rs  |  10 +-
 2 files changed, 118 insertions(+), 5 deletions(-)

diff --git a/rust/src/runtime/waterline_import.rs b/rust/src/runtime/waterline_import.rs
index fa2c6fa11..af36e38ee 100644
--- a/rust/src/runtime/waterline_import.rs
+++ b/rust/src/runtime/waterline_import.rs
@@ -292,8 +292,12 @@ pub(crate) struct Normalized {
 pub(crate) enum Outcome {
     Invalid { errors: Vec<Php> },
     /// Larger than one transaction may write. `built` is how many events
-    /// were built first: 0 for a refusal by count.
-    TooLarge { error: Php, built: usize },
+    /// were built first: 0 for a refusal by count. Only the controls read it.
+    TooLarge {
+        error: Php,
+        #[cfg_attr(not(test), allow(dead_code))]
+        built: usize,
+    },
     Valid(Box<Normalized>),
 }
 
@@ -1018,6 +1022,8 @@ store_methods! {
     /// The projection's instance, run, history and summary in one
     /// transaction. `Err(true)` when the identity was claimed meanwhile.
     pub(crate) async fn waterline_write(&self, projection: &Normalized, imported_at: DateTime<Utc>) -> std::result::Result<(), bool> {
+        #[cfg(test)]
+        install_probe::reached(&projection.workflow_id);
         let mut tx = self.begin().await.map_err(|_| false)?;
         let claimed = Self::query("SELECT id FROM workflow_instances WHERE id=$1")
             .bind(&projection.workflow_id).fetch_optional(&mut *tx).await.map_err(|_| false)?.is_some()
@@ -1076,6 +1082,35 @@ store_methods! {
     }
 }
 
+/// The point where a projection's install asks for the transition lock,
+/// for the controls that prove an append cannot cross an install waiting on
+/// it. Keyed by workflow id, so tests running in parallel do not see each
+/// other's installs.
+#[cfg(test)]
+mod install_probe {
+    use std::collections::HashMap;
+    use std::sync::{Arc, Mutex, OnceLock};
+    use tokio::sync::Notify;
+
+    fn watched() -> &'static Mutex<HashMap<String, Arc<Notify>>> {
+        static WATCHED: OnceLock<Mutex<HashMap<String, Arc<Notify>>>> = OnceLock::new();
+        WATCHED.get_or_init(Mutex::default)
+    }
+
+    /// Notified once the install of `workflow_id` reaches the transition lock.
+    pub(super) fn watch(workflow_id: &str) -> Arc<Notify> {
+        let notify = Arc::new(Notify::new());
+        watched().lock().unwrap().insert(workflow_id.to_owned(), notify.clone());
+        notify
+    }
+
+    pub(super) fn reached(workflow_id: &str) {
+        if let Some(notify) = watched().lock().unwrap().get(workflow_id) {
+            notify.notify_one();
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1133,6 +1168,80 @@ mod tests {
         runtime.close().await;
     }
 
+    /// SQLite's writer waits inside its own busy handler, which no other
+    /// connection can see; the install probe shows it reached the transition
+    /// lock instead. With `BEGIN IMMEDIATE` held, an append finds no instance
+    /// and writes nothing; once the install commits, an append is refused.
+    #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+    async fn an_append_cannot_cross_an_install_waiting_on_the_sqlite_lock() {
+        use sqlx::Connection;
+        let directory = tempfile::tempdir().unwrap();
+        let path = directory.path().join("barrier.sqlite");
+        let runtime = super::super::Runtime::open(path.to_str().unwrap(), "test-token".into()).await.unwrap();
+        let source = json!({"id": "v1:4201", "legacy_id": "4201", "engine_source": "v1", "class": "App\\Workflows\\Legacy\\Subscription",
+            "status": "running", "arguments": "a:0:{}", "logs": [{"id": 9101, "index": 0, "class": "App\\Activities\\Bill",
+                "result": "i:42;", "created_at": "2026-09-30T09:00:02.000000Z"}], "created_at": "2026-09-30T09:00:00.000000Z"});
+        let body = |dry_run: bool| serde_json::to_vec(&json!({"source_id": "barrier-src", "workflow": source, "dry_run": dry_run})).unwrap();
+        let (status, dry) = runtime.import_waterline_v1(&body(true)).await.unwrap();
+        assert_eq!(status, StatusCode::OK, "{dry}");
+        let workflow_id = dry["identity"]["standalone"]["workflow_id"].as_str().unwrap().to_owned();
+        let pool = runtime.sqlite_pool().clone();
+        let counts = || async {
+            let tables: Vec<String> = sqlx::query_scalar("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+                .fetch_all(&pool).await.unwrap();
+            let mut counts = Vec::new();
+            for table in tables {
+                let count: i64 = sqlx::query_scalar(sqlx::AssertSqlSafe(format!("SELECT COUNT(*) FROM {table}"))).fetch_one(&pool).await.unwrap();
+                counts.push((table, count));
+            }
+            counts
+        };
+        let before = counts().await;
+        let append = |message: &str| json!({"message_id": message, "input": ["x"]});
+
+        let reached = install_probe::watch(&workflow_id);
+        let mut holder = sqlx::SqliteConnection::connect(&format!("sqlite://{}", path.display())).await.unwrap();
+        sqlx::query("BEGIN IMMEDIATE").execute(&mut holder).await.unwrap();
+        let install = tokio::spawn({
+            let runtime = runtime.clone();
+            let body = body(false);
+            async move { runtime.import_waterline_v1(&body).await }
+        });
+        tokio::time::timeout(std::time::Duration::from_secs(10), reached.notified()).await
+            .expect("the install never reached the transition lock");
+
+        // The install is at its transaction and cannot commit.
+        match runtime.append_message(&workflow_id, "orders", append("m-pending"), json!({})).await {
+            Err(super::super::RuntimeError::Protocol { status, response }) => {
+                assert_eq!((status, &response["reason"]), (StatusCode::NOT_FOUND, &json!("instance_not_found")), "{response}");
+            }
+            other => panic!("{other:?}"),
+        }
+        assert!(!install.is_finished(), "the install committed while BEGIN IMMEDIATE was held");
+        sqlx::query("ROLLBACK").execute(&mut holder).await.unwrap();
+
+        let (status, report) = install.await.unwrap().unwrap();
+        assert_eq!(status, StatusCode::CREATED, "{report}");
+        match runtime.append_message(&workflow_id, "orders", append("m-after"), json!({})).await {
+            Err(super::super::RuntimeError::Protocol { status, response }) => {
+                assert_eq!((status, &response["reason"]), (StatusCode::CONFLICT, &json!("v1_projection_read_only")), "{response}");
+            }
+            other => panic!("{other:?}"),
+        }
+        // Only the projection's rows were written.
+        let after = counts().await;
+        assert_eq!(before.len(), after.len());
+        for ((table, was), (_, now)) in before.iter().zip(&after) {
+            let grew = match table.as_str() {
+                "workflow_instances" | "workflow_runs" | "workflow_run_summaries" => 1,
+                "workflow_history_events" => 2,
+                _ => 0,
+            };
+            assert_eq!(*now, was + grew, "{table}");
+        }
+        runtime.close().await;
+    }
+
     #[test]
     fn size_limits_name_the_first_dimension_exceeded() {
         let limits = |events, bytes| super::super::StructuralLimits { history_events: events, history_bytes: bytes,
diff --git a/rust/tests/execution/waterline_projection_guards.rs b/rust/tests/execution/waterline_projection_guards.rs
index d0c980d61..5edb30911 100644
--- a/rust/tests/execution/waterline_projection_guards.rs
+++ b/rust/tests/execution/waterline_projection_guards.rs
@@ -252,6 +252,12 @@ async fn release(lock: TransitionLock) {
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn an_append_cannot_cross_a_projection_install_waiting_on_the_lock() {
     let database = TestDatabase::new().await;
+    if matches!(database, TestDatabase::Sqlite(_)) {
+        // SQLite's writer waits where no other connection can see it; the
+        // library control an_append_cannot_cross_an_install_waiting_on_the_sqlite_lock
+        // observes the install reaching the lock through a test probe.
+        return;
+    }
     let app = router(database.open().await.unwrap());
     let (status, dry) = request(&app, "POST", ROUTE, json!({"source_id": "barrier-src", "workflow": running(1), "dry_run": true})).await;
     assert_eq!(status, StatusCode::OK, "{dry}");
@@ -266,9 +272,7 @@ async fn an_append_cannot_cross_a_projection_install_waiting_on_the_lock() {
     });
     // On PostgreSQL and MySQL the install is seen waiting on the lock; on
     // SQLite it cannot commit while the lock is held, wherever it is.
-    if !lock_waiter_observed(&database).await {
-        tokio::time::sleep(std::time::Duration::from_millis(300)).await;
-    }
+    assert!(lock_waiter_observed(&database).await);
     let (status, body) = request(&app, "POST", &path, json!({"message_id": "m-pending", "input": ["x"]})).await;
     assert_eq!((status, &body["reason"]), (StatusCode::NOT_FOUND, &json!("instance_not_found")), "{body}");
     assert!(!install.is_finished(), "the install committed while the transition lock was held");