Deliver a carried poll's lease from its completion's answer

External performance report, topic 16b. The reported timings and proposed fixes have not been independently reproduced. The supplied patches are reference drafts for review and current-source qualification.

Proposal

When a completion returns {"leased": true, "answer": ...}, the Worker
hands answer to the same response handling a poll's own answer goes
through. Payloads and activity lease supervision are unchanged.
The Worker sends the poll only when the completion returned no answer.
A poll delivered this way sends no request, so it records no request
metric.

Acceptance

Tests in tests/WorkerCarriedPollTest.php cover:

a workflow poll carried on a workflow task completion is delivered from
the answer without a poll;
a lease reported without an answer is polled under the carried request
ID;
an activity poll carried on a workflow task completion is delivered from
the answer, and the activity runs with no activity poll.

Dependencies

Native: return a carried poll's answer in its completion's response server#1067

Related existing work: #233.

Draft patches and validation boundary

Current main was independently read as afa5a95e3116cd69c731c821f00e8223d42f7ff6. The supplied draft series targets afa5a95e3116cd69c731c821f00e8223d42f7ff6; patches are cumulative reference material, not a current-main application or test result. Review and rebase on maintained source, preserve all existing tests and published compatibility, then establish causal controls and actual conformance before shipping. No patch was applied or executed during intake.

The following sanitized unified diffs identify proposed reference material:

0007-t16-Deliver-a-carried-poll-s-lease-from-its-completion-s.patch — 15,129 bytes, SHA-256 a711f94136904915e2ffdd273142506de7784117bcb0de9b6c8402129eb687e8.
0008-t16-Test-delivery-of-a-carried-poll-s-lease-from-its-com.patch — 9,210 bytes, SHA-256 efe50e91e8e2e2ea41b0b2f1ebf5a7ca2f1d8529257b392dee275cb8a5e3b30c.

Next action: the owning maintainer reviews the candidate against current source and the acceptance criteria above. Preserve durability, lease/fencing, idempotency, fairness and whole-completion/history budgets. New producer capabilities need versioned schemas and real producer/consumer compatibility proof; historical/frozen evidence is not rewritten.

Sanitized reference diff 0007-t16-Deliver-a-carried-poll-s-lease-from-its-completion-s.patch, part 1/1.

This is an unverified, cumulative draft from the external report. Mail author/date/commit-message metadata was removed; the unified-diff hunks were retained. No patch was applied or executed, and no build/test or compatibility result is implied. The known gaps and acceptance criteria in this issue remain mandatory.

Complete sanitized patch: 15,129 bytes, SHA-256 a711f94136904915e2ffdd273142506de7784117bcb0de9b6c8402129eb687e8. This part: 15,129 bytes, SHA-256 a711f94136904915e2ffdd273142506de7784117bcb0de9b6c8402129eb687e8. Parts concatenate in order; a part boundary is between complete file diffs.

diff --git a/src/Client.php b/src/Client.php
index 2b512ac..c77ebb8 100644
--- a/src/Client.php
+++ b/src/Client.php
@@ -94,8 +94,12 @@ final class Client implements WorkflowClientInterface
     private bool $claimedTaskReadyAgeSupported = false;
     private MetricsObserver $metricsObserver;
     private ?ClientRequestObservation $metricsRequest = null;
-    /** @var (\Closure(string, array<string, mixed>|null, array<string, mixed>, RequestBudget|null): (?\Closure))|null */
+    /** @var (\Closure(string, array<string, mixed>|null, array<string, mixed>, RequestBudget|null, float|null): (?\Closure))|null */
     private ?\Closure $workerPayloadObserver = null;
+    /** @var array<string, mixed>|null The answer a carried poll's completion returned, which polls through this copy deliver. */
+    private ?array $carriedPollAnswer = null;
+    /** When that completion's response arrived, in hrtime seconds. */
+    private ?float $carriedPollReceivedAt = null;
     /** @var (\Closure(array<string, mixed>): void)|null */
     private ?\Closure $workerPollCutoffObserver = null;
 
@@ -270,7 +274,7 @@ final class Client implements WorkflowClientInterface
 
     /**
      * @internal Keep Worker payload-transfer coordination on its own Client.
-     * @param \Closure(string, array<string, mixed>|null, array<string, mixed>, RequestBudget|null): (?\Closure) $observer
+     * @param \Closure(string, array<string, mixed>|null, array<string, mixed>, RequestBudget|null, float|null): (?\Closure) $observer
      */
     public function withWorkerPayloadObserver(\Closure $observer): self
     {
@@ -280,6 +284,28 @@ final class Client implements WorkflowClientInterface
         return $copy;
     }
 
+    /**
+     * @internal A copy whose worker polls deliver the answer the completion
+     * that carried the poll returned with its lease, received at $receivedAt
+     * (hrtime seconds), without sending the poll, which would replay just
+     * that answer. The answer is handled as the poll's own would be.
+     * @param array<string, mixed> $answer
+     */
+    public function withCarriedPollAnswer(array $answer, float $receivedAt): self
+    {
+        $copy = clone $this;
+        $copy->carriedPollAnswer = $answer;
+        $copy->carriedPollReceivedAt = $receivedAt;
+
+        return $copy;
+    }
+
+    /** @return array<string, mixed>|null The carried poll answer this request delivers instead of sending. */
+    private function carriedPollAnswerFor(string $method, string $path): ?array
+    {
+        return \DurableWorkflow\Transport\PollTransport::taskKind($method, $path) === null ? null : $this->carriedPollAnswer;
+    }
+
     /** @internal Isolate the cooperative worker's I/O policy from its caller's Client. */
     public function withBoundedWorkerRequests(): self
     {
@@ -2783,7 +2809,8 @@ final class Client implements WorkflowClientInterface
      */
     private function pollTaskResponse(string $path, array $body): array
     {
-        if (!$this->metricsObserver->enabled()) {
+        // A carried poll's answer makes no request to observe.
+        if (!$this->metricsObserver->enabled() || $this->carriedPollAnswerFor('POST', $path) !== null) {
             return $this->performPollTaskResponse($path, $body);
         }
 
@@ -2901,7 +2928,8 @@ final class Client implements WorkflowClientInterface
         ?\Closure $payloadPaths = null,
         ?string $requestId = null,
     ): array {
-        if ($this->metricsRequest !== null || !$this->metricsObserver->enabled()) {
+        if ($this->metricsRequest !== null || !$this->metricsObserver->enabled()
+            || ($worker && $this->carriedPollAnswerFor($method, $path) !== null)) {
             return $this->performRequest($method, $path, $worker, $body, $operation, $budget, $payloadPaths, $requestId, $this->metricsRequest);
         }
 
@@ -2946,6 +2974,7 @@ final class Client implements WorkflowClientInterface
             $observation->status = null;
         }
         $headers = $this->requestHeaders($worker);
+        $carried = $worker ? $this->carriedPollAnswerFor($method, $path) : null;
         try {
             $callerBudget = $budget;
             $poll = str_ends_with($path, '/poll') && is_int($body['timeout_seconds'] ?? null);
@@ -2966,7 +2995,7 @@ final class Client implements WorkflowClientInterface
                 $budget?->restrictAuthorityDeadline($activityLease->publicationDeadline());
             }
             try {
-                $response = $this->sendTransportRequest($method, $path, $worker, $headers, $body, $budget);
+                $response = $carried ?? $this->sendTransportRequest($method, $path, $worker, $headers, $body, $budget);
             } finally {
                 $observation?->captureStatus($this->transport);
             }
@@ -2980,7 +3009,8 @@ final class Client implements WorkflowClientInterface
                 && $this->transport instanceof BoundedTransport && $this->transport->supportsBoundedRequests();
             $observerBudget = $canStreamBounded && $callerBudget === null ? null : $responseBudget;
             $progress = $worker && $this->workerPayloadObserver !== null && is_array($response) && !array_is_list($response)
-                ? ($this->workerPayloadObserver)($path, $body, $response, $observerBudget) : null;
+                ? ($this->workerPayloadObserver)($path, $body, $response, $observerBudget,
+                    $carried === null ? null : $this->carriedPollReceivedAt) : null;
             $streamBounded = $canStreamBounded && $progress !== null;
             if ($streamBounded && $callerBudget === null) {
                 $responseBudget = null;
diff --git a/src/Worker.php b/src/Worker.php
index 7ba0fad..f6dcd4d 100644
--- a/src/Worker.php
+++ b/src/Worker.php
@@ -124,12 +124,16 @@ final class Worker
     private ?string $carriedActivityPollRequestId = null;
     /** Whether that completion's claim leased an activity, or null when it did not answer. */
     private ?bool $carriedActivityPollLeased = null;
+    /** @var array{answer: array<string, mixed>, received: float, captured: float}|null The poll answer that completion returned with its lease. */
+    private ?array $carriedActivityPollAnswer = null;
     private bool $activityCompletionWorkflowPollSupported = false;
     private bool $completionWorkflowPollSupported = false;
     /** The request ID of the workflow poll the last completion carried. */
     private ?string $carriedWorkflowPollRequestId = null;
     /** Whether that completion's claim leased a workflow task, or null when it did not answer. */
     private ?bool $carriedWorkflowPollLeased = null;
+    /** @var array{answer: array<string, mixed>, received: float, captured: float}|null The poll answer that completion returned with its lease. */
+    private ?array $carriedWorkflowPollAnswer = null;
     private ?string $claimDeliveredCancellationId = null;
     private bool $preparedLocalActivityGroupsSupported = false;
     /** @var list<string> */
@@ -794,11 +798,14 @@ final class Worker
         // its claim took is delivered by the poll under the same request ID,
         // even during shutdown, as an in-flight poll's would be. The poll
         // keeps the ID whatever the completion answered, so a lease whose
-        // answer was lost is delivered too.
+        // answer was lost is delivered too. A poll answer the completion
+        // returned with the lease is delivered without sending the poll.
         $carriedWorkflowRequestId = $this->carriedWorkflowPollRequestId;
         $carriedWorkflowLeased = $this->carriedWorkflowPollLeased === true;
+        $carriedWorkflowAnswer = $this->carriedWorkflowPollAnswer;
         $this->carriedWorkflowPollRequestId = null;
         $this->carriedWorkflowPollLeased = null;
+        $this->carriedWorkflowPollAnswer = null;
         if ($this->shutdownRequested && !$carriedWorkflowLeased) {
             return false;
         }
@@ -811,7 +818,7 @@ final class Worker
         $handled = false;
         $workflowPoll = $this->pollWithRetry(
             'workflow',
-            fn (string $requestId, int $timeoutSeconds): array => $this->client->pollWorkflowTaskResponse(
+            fn (string $requestId, int $timeoutSeconds): array => $this->pollClient($requestId, $carriedWorkflowRequestId, $carriedWorkflowAnswer)->pollWorkflowTaskResponse(
                 $this->workerId,
                 $this->taskQueue,
                 $timeoutSeconds,
@@ -830,7 +837,10 @@ final class Worker
         }
         $this->workflowGrant = is_array($workflowPoll['task'] ?? null) ? [
             'task_id' => (string) ($workflowPoll['task']['task_id'] ?? ''),
-            'received' => $this->now(),
+            // A carried answer was received with its completion.
+            'received' => $carriedWorkflowAnswer !== null
+                && ($workflowPoll['task']['task_id'] ?? null) === ($carriedWorkflowAnswer['answer']['task']['task_id'] ?? null)
+                ? $carriedWorkflowAnswer['received'] : $this->now(),
             'server_time' => $workflowPoll['server_time'] ?? null,
         ] : null;
         $this->rememberWorkflowMemoCapability($workflowPoll);
@@ -858,18 +868,21 @@ final class Worker
         // The workflow task's completion carried this activity poll. A lease
         // its claim took is delivered by the poll under the same request ID,
         // even during shutdown, as an in-flight poll's would be; a claim that
-        // leased nothing answered the poll.
+        // leased nothing answered the poll. A poll answer the completion
+        // returned with the lease is delivered without sending the poll.
         $carriedRequestId = $this->carriedActivityPollRequestId;
         $carriedLeased = $this->carriedActivityPollLeased;
+        $carriedAnswer = $this->carriedActivityPollAnswer;
         $this->carriedActivityPollRequestId = null;
         $this->carriedActivityPollLeased = null;
+        $this->carriedActivityPollAnswer = null;
         if ($this->shutdownRequested && $carriedLeased !== true) {
             return $handled;
         }
 
         $activityPoll = $carriedLeased === false ? ['task' => null, 'poll_status' => 'empty'] : $this->pollWithRetry(
             'activity',
-            fn (string $requestId, int $timeoutSeconds): array => $this->client->pollActivityTaskResponse(
+            fn (string $requestId, int $timeoutSeconds): array => $this->pollClient($requestId, $carriedRequestId, $carriedAnswer)->pollActivityTaskResponse(
                 $this->workerId,
                 $this->taskQueue,
                 $timeoutSeconds,
@@ -937,6 +950,37 @@ final class Worker
         return true;
     }
 
+    /**
+     * The client for a poll under this request ID: one that delivers the
+     * answer the completion carrying the poll returned with its lease, when
+     * it returned one, since the poll would replay just that answer.
+     *
+     * @param array{answer: array<string, mixed>, received: float, captured: float}|null $carried
+     */
+    private function pollClient(string $requestId, ?string $carriedRequestId, ?array $carried): Client
+    {
+        return $carried === null || $requestId !== $carriedRequestId
+            ? $this->client
+            : $this->client->withCarriedPollAnswer($carried['answer'], $carried['captured']);
+    }
+
+    /**
+     * The poll answer a completion returned with its carried poll's lease, or
+     * null when it returned none.
+     *
+     * @return array{answer: array<string, mixed>, received: float, captured: float}|null
+     */
+    private function carriedPollAnswer(mixed $poll): ?array
+    {
+        $answer = is_array($poll) && ($poll['leased'] ?? null) === true ? ($poll['answer'] ?? null) : null;
+        if (!is_array($answer) || array_is_list($answer) || !is_array($answer['task'] ?? null)) {
+            return null;
+        }
+
+        /** @var array<string, mixed> $answer */
+        return ['answer' => $answer, 'received' => $this->now(), 'captured' => hrtime(true) / 1e9];
+    }
+
     /**
      * @param \Closure(string, int): array<string, mixed> $poll
      * @return array<string, mixed>|null
@@ -1574,8 +1618,10 @@ final class Worker
             ]);
             $leased = $activityPoll === null ? null : ($completion['activity_poll']['leased'] ?? null);
             $this->carriedActivityPollLeased = is_bool($leased) ? $leased : null;
+            $this->carriedActivityPollAnswer = $activityPoll === null ? null : $this->carriedPollAnswer($completion['activity_poll'] ?? null);
             $leased = $workflowPoll === null ? null : ($completion['workflow_poll']['leased'] ?? null);
             $this->carriedWorkflowPollLeased = is_bool($leased) ? $leased : null;
+            $this->carriedWorkflowPollAnswer = $workflowPoll === null ? null : $this->carriedPollAnswer($completion['workflow_poll'] ?? null);
         } catch (Throwable $exception) {
             if ($exception instanceof WorkflowClaimDeferred) {
                 $this->diagnostic('worker.claim_deferred', [
@@ -1705,7 +1751,7 @@ final class Worker
      * @param array<string, mixed> $response
      * @return (\Closure(): void)|null
      */
-    private function workerPayloadProgress(string $path, ?array $body, array $response, ?RequestBudget $budget): ?\Closure
+    private function workerPayloadProgress(string $path, ?array $body, array $response, ?RequestBudget $budget, ?float $receivedAt = null): ?\Closure
     {
         if (in_array($path, ['/worker/query-tasks/poll', '/worker/activity-tasks/poll'], true)) {
             if (!$this->registered || !is_array($response['task'] ?? null)) {
@@ -1721,7 +1767,7 @@ final class Worker
                     throw new WorkflowClaimRevoked('activity_supervisor_conflict', 'A previous activity supervisor is still active.');
                 }
                 $this->activityLeaseProcess = new ActivityLeaseProcess($this->client, $task, $this->workerId,
-                    $this->taskQueue, $response['server_time'] ?? null, hrtime(true) / 1e9,
+                    $this->taskQueue, $response['server_time'] ?? null, $receivedAt ?? hrtime(true) / 1e9,
                     ['registered' => $this->registered, 'heartbeat_interval' => $this->heartbeatIntervalSeconds,
                         'presence_due_in' => max(0.0, $this->heartbeatIntervalSeconds - $this->elapsedSinceHeartbeat())]);
                 $this->unbindActivityLease = $this->client->bindActivityLease($this->activityLeaseProcess);
@@ -2732,6 +2778,7 @@ final class Worker
             );
             $leased = $workflowPoll === null ? null : ($completion['workflow_poll']['leased'] ?? null);
             $this->carriedWorkflowPollLeased = is_bool($leased) ? $leased : null;
+            $this->carriedWorkflowPollAnswer = $workflowPoll === null ? null : $this->carriedPollAnswer($completion['workflow_poll'] ?? null);
         } catch (Throwable $exception) {
             if ($exception instanceof ServerException && $this->discardClosedActivityAttempt($task, $exception)) {
                 return;

Sanitized reference diff 0008-t16-Test-delivery-of-a-carried-poll-s-lease-from-its-com.patch, part 1/1.

This is an unverified, cumulative draft from the external report. Mail author/date/commit-message metadata was removed; the unified-diff hunks were retained. No patch was applied or executed, and no build/test or compatibility result is implied. The known gaps and acceptance criteria in this issue remain mandatory.

Complete sanitized patch: 9,210 bytes, SHA-256 efe50e91e8e2e2ea41b0b2f1ebf5a7ca2f1d8529257b392dee275cb8a5e3b30c. This part: 9,210 bytes, SHA-256 efe50e91e8e2e2ea41b0b2f1ebf5a7ca2f1d8529257b392dee275cb8a5e3b30c. Parts concatenate in order; a part boundary is between complete file diffs.

diff --git a/tests/WorkerCarriedPollTest.php b/tests/WorkerCarriedPollTest.php
new file mode 100644
index 0000000..7d05b1e
--- /dev/null
+++ b/tests/WorkerCarriedPollTest.php
@@ -0,0 +1,201 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DurableWorkflow\Tests;
+
+use DurableWorkflow\Client;
+use DurableWorkflow\Tests\Support\FakeTransport;
+use DurableWorkflow\Worker;
+use DurableWorkflow\Worker\ActivityContext;
+use DurableWorkflow\Worker\WorkflowContext;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * A completion can carry the Worker's next poll, which the Server claims for
+ * in the completion's transaction. The lease comes back with the completion,
+ * as the answer the poll under the carried request ID would replay, or is
+ * delivered by that poll.
+ */
+final class WorkerCarriedPollTest extends TestCase
+{
+    public function testACarriedWorkflowPollsAnswerIsDeliveredWithoutSendingThePoll(): void
+    {
+        $polls = [];
+        $completions = [];
+        $transport = $this->transport(static function (string $uri, ?array $body) use (&$polls, &$completions): ?array {
+            if (str_ends_with($uri, '/workflow-tasks/poll')) {
+                $polls[] = $body;
+
+                return count($polls) === 1 ? self::workflowLease('carry-task-1') : ['task' => null, 'poll_status' => 'empty'];
+            }
+            if (str_ends_with($uri, '/activity-tasks/poll')) {
+                return ['task' => null, 'poll_status' => 'empty'];
+            }
+            if (preg_match('#/workflow-tasks/([^/]+)/complete$#', $uri, $match) === 1) {
+                $completions[] = [$match[1], $body];
+
+                return ['outcome' => 'completed', 'recorded' => true, 'workflow_poll' => $match[1] === 'carry-task-1'
+                    ? ['leased' => true, 'answer' => self::workflowLease('carry-task-2')]
+                    : ['leased' => false]];
+            }
+
+            return null;
+        });
+        $worker = $this->worker($transport);
+
+        self::assertTrue($worker->tick(0));
+        self::assertTrue($worker->tick(0));
+
+        self::assertCount(1, $polls);
+        self::assertSame(['carry-task-1', 'carry-task-2'], array_column($completions, 0));
+        $carried = $completions[0][1]['workflow_poll'] ?? null;
+        self::assertIsArray($carried);
+        self::assertSame('worker-1', $carried['worker_id'] ?? null);
+        self::assertSame('carry-workers', $carried['task_queue'] ?? null);
+        self::assertSame($polls[0]['history_page_size'] ?? null, $carried['history_page_size'] ?? null);
+        self::assertIsString($carried['poll_request_id'] ?? null);
+    }
+
+    public function testALeaseWithoutAnAnswerIsPolledUnderTheCarriedRequestId(): void
+    {
+        $polls = [];
+        $completions = [];
+        $transport = $this->transport(static function (string $uri, ?array $body) use (&$polls, &$completions): ?array {
+            if (str_ends_with($uri, '/workflow-tasks/poll')) {
+                $polls[] = $body;
+
+                return self::workflowLease('carry-task-'.count($polls));
+            }
+            if (str_ends_with($uri, '/activity-tasks/poll')) {
+                return ['task' => null, 'poll_status' => 'empty'];
+            }
+            if (preg_match('#/workflow-tasks/([^/]+)/complete$#', $uri, $match) === 1) {
+                $completions[] = [$match[1], $body];
+
+                return ['outcome' => 'completed', 'recorded' => true,
+                    'workflow_poll' => ['leased' => $match[1] === 'carry-task-1']];
+            }
+
+            return null;
+        });
+        $worker = $this->worker($transport);
+
+        self::assertTrue($worker->tick(0));
+        self::assertTrue($worker->tick(0));
+
+        self::assertCount(2, $polls);
+        self::assertSame(['carry-task-1', 'carry-task-2'], array_column($completions, 0));
+        self::assertSame($completions[0][1]['workflow_poll']['poll_request_id'] ?? null, $polls[1]['poll_request_id'] ?? null);
+    }
+
+    public function testACarriedActivityPollsAnswerIsDeliveredWithoutSendingThePoll(): void
+    {
+        $activityPolls = 0;
+        $completions = [];
+        $transport = $this->transport(static function (string $uri, ?array $body) use (&$activityPolls, &$completions): ?array {
+            if (str_ends_with($uri, '/workflow-tasks/poll')) {
+                static $served = false;
+                if ($served) {
+                    return ['task' => null, 'poll_status' => 'empty'];
+                }
+                $served = true;
+
+                return self::workflowLease('carry-task-1', 'carry.activity-workflow');
+            }
+            if (str_ends_with($uri, '/activity-tasks/poll')) {
+                $activityPolls++;
+
+                return ['task' => null, 'poll_status' => 'empty'];
+            }
+            if (str_ends_with($uri, '/workflow-tasks/carry-task-1/complete')) {
+                $completions[] = ['carry-task-1', $body];
+
+                return ['outcome' => 'completed', 'recorded' => true, 'activity_poll' => ['leased' => true, 'answer' => [
+                    'poll_status' => 'leased',
+                    'task' => ['task_id' => 'carry-activity-1', 'activity_attempt_id' => 'carry-attempt-1',
+                        'lease_owner' => 'worker-1', 'activity_type' => 'carry.activity', 'payload_codec' => 'avro'],
+                    'server_capabilities' => self::capabilities(),
+                ]]];
+            }
+            if (str_ends_with($uri, '/activity-tasks/carry-activity-1/complete')) {
+                $completions[] = ['carry-activity-1', $body];
+
+                return ['outcome' => 'completed', 'recorded' => true];
+            }
+
+            return null;
+        });
+        $worker = $this->worker($transport);
+        $worker->registerActivity('carry.activity', static fn (ActivityContext $context): string => 'carried');
+
+        self::assertTrue($worker->tick(0));
+
+        self::assertSame(0, $activityPolls);
+        self::assertSame(['carry-task-1', 'carry-activity-1'], array_column($completions, 0));
+        self::assertSame('schedule_activity', $completions[0][1]['commands'][0]['type'] ?? null);
+        self::assertIsString($completions[0][1]['activity_poll']['poll_request_id'] ?? null);
+        self::assertSame('carry-attempt-1', $completions[1][1]['activity_attempt_id'] ?? null);
+    }
+
+    /**
+     * A transport that answers the requests every test makes the same way and
+     * hands the rest to $handle, which returns null for a request it does not expect.
+     *
+     * @param \Closure(string, ?array<string, mixed>): ?array<string, mixed> $handle
+     */
+    private function transport(\Closure $handle): FakeTransport
+    {
+        return new FakeTransport(handler: static function (string $method, string $uri, array $headers, ?array $body) use ($handle): array {
+            if (str_ends_with($uri, '/query-tasks/poll')) {
+                return ['task' => null, 'poll_status' => 'empty'];
+            }
+            if (preg_match('#/workflow-tasks/([^/]+)/heartbeat$#', $uri, $match) === 1) {
+                return ['task_id' => $match[1], 'workflow_task_attempt' => $body['workflow_task_attempt'] ?? null,
+                    'lease_owner' => $body['lease_owner'] ?? null, 'renewed' => true];
+            }
+
+            return $handle($uri, $body) ?? self::fail("Unexpected worker request: {$method} {$uri}");
+        });
+    }
+
+    private function worker(FakeTransport $transport): Worker
+    {
+        $worker = new Worker(new Client('https://server.example', transport: $transport), 'carry-workers', workerId: 'worker-1');
+        $worker->registerWorkflow('carry.workflow', static fn (WorkflowContext $context): string => 'done');
+        $worker->registerWorkflow('carry.activity-workflow', static fn (WorkflowContext $context): mixed => $context->activity('carry.activity'));
+
+        return $worker;
+    }
+
+    /** @return array<string, mixed> A workflow poll's answer leasing $taskId. */
+    private static function workflowLease(string $taskId, string $type = 'carry.workflow'): array
+    {
+        return [
+            'poll_status' => 'leased',
+            'task' => [
+                'task_id' => $taskId,
+                'workflow_task_attempt' => 1,
+                'lease_owner' => 'worker-1',
+                'workflow_id' => $taskId.'-workflow',
+                'run_id' => $taskId.'-run',
+                'workflow_type' => $type,
+                'payload_codec' => 'avro',
+                'history_events' => [],
+                'task_kind' => 'workflow',
+            ],
+            'server_capabilities' => self::capabilities(),
+        ];
+    }
+
+    /** @return array<string, mixed> */
+    private static function capabilities(): array
+    {
+        return [
+            'supported_workflow_task_commands' => ['schedule_activity', 'complete_workflow', 'fail_workflow'],
+            'workflow_task_completion_activity_poll' => true,
+            'activity_completion_workflow_poll' => true,
+            'workflow_task_completion_workflow_poll' => true,
+        ];
+    }
+}

sdk-php owns this P0 consumer. I checked that current #335 deliberately contains no carried completion answer or receipt path. The actual Server #1067 response contract remains the producer prerequisite, in addition to the request/receipt foundations in #328–#330.

Next action: Server returns the accepted answer shape, lease identity/clock/history-budget binding and duplicate/replay semantics; I have asked the owner for that exact handoff. sdk-php then routes a proved returned answer through the existing poll response processing, payload hydration and activity supervision, omits a request metric only when no request occurred, and retains same-ID polling when a lease is reported without an answer. Source controls and advertising/non-advertising published acceptance remain distinct.

Server #1073 is now the concrete producer train, but its first activity-carrier slice returns only a lease disposition and does not advertise the capability or provide #1067 embedded normal answers. I reviewed the actual retry/omission path: a lost completion answer requires retaining the carried poll request ID through completion retry and ordinary follow-up; the versioned producer vectors must bind this alongside expiry/refencing. Server still owns the full answer envelope and clock/encoding/history/payload contract. The PHP consumer will preserve original request timing, deliver no lease for a missing workflow_poll member and release that reservation, and retain unchanged behavior without advertisement. Consumer source waits for the accepted exact handoff.

WITHDRAWN: predecessor cutover remains unresolved. See Security 6698603892. Passing source checks and same-spelling recovery do not prove padded-to-normalized retained receipt recovery. This acceptance/handoff must not be used for adoption; a corrected successor will follow.

Accepted producer SOURCE contract for #331: each existing carried-poll capability can return leased:true with the full ordinary answer. No additional capability is required. Route that answer through normal response handling without sending a redundant poll or inventing a request metric; a flag-only result still follows up with the original poll ID. Charge the original completion request transit before any lease-supervision shortcut.

Server owner acceptance is 1073/6698943724: exact-head original workflows are terminal SUCCESS, 62 checks passed/one declared skip, and all 48 shared SQLite/PostgreSQL/MySQL-family jobs passed. Normal integration and publication remain Server-owned.

Producer source: Server PR #1073, commit b63125944be09441329753803b1b5d4775808340, tree afed955104676fbd36ba29ddeed00802647d7aec.

The authoritative machine contract is OpenAPI revision 60, blob 755c25b653a844f9454a64964a29b4258b857799, SHA-256 912b42d25b7d32582131a8a67548281775fc7d6188f5a980fe47772684cbc516. The consumed v1 vectors have 29 unique HTTP cases, blob 7f6f4417ccec11d38005fa0dcd27ebb71ebde2a2, SHA-256 8531bb6e1a8c31a2c2166fd5d671d56d5902aafbc84e8e6013d922416ad48371. Protocol remains 1.20; the three capability keys are independent and there is no fourth embedded-answer capability.

The completing task's owner must match every supplied carrier's worker ID, before admission and again under the retained registration fence and stored completion authority. Activity dispatch has priority when both carriers are supplied. A delivered activity causes workflow-carrier omission; a live workflow/validation slot (including unknown/NULL expiry) prevents an activity grant, and a live activity slot prevents a workflow grant. Normal completion and stale-parent guards remain authoritative.

For a successful completion response, the result table is:

Result	Meaning and consumer action
`leased:true, answer:{...}`	One delivered lease. Use the complete answer through normal poll-response handling.
`leased:true` without `answer`	Legacy flag-only result. Recover through the original carried poll ID.
`leased:false`	Immediate probe leased nothing. Ordinary polling remains available.
carrier key absent	No lease delivered for that carried request. Release its reservation; do not infer queue emptiness or permanently disable the capability.
duplicate completion	No new dispatch. If the first response was lost, retry/follow up using the original completion and poll identities to recover its retained lease.
transport failure or `503 storage_unavailable`	Commit outcome may be unknown. Do not interpret an absent carrier on an error as a successful omission. Recover with the original identities.

The embedded answer has exactly task, poll_status, protocol_version, server_capabilities and server_time. Workflow encoding, configured history page/budget limits, task/session/attempt/deadline fields, ready-age data and external payload references follow the normal producer path. Only outer server_time is refreshed after commit. Charge the original completion request's transit; receiving, caching or replaying the answer does not renew lease authority.

Keep activity IDs raw and opaque. Workflow IDs use the same Laravel normalization for validation and cache keys. Bidirectional FEFF/200B/200E controls preserve one new canonical binding and original lease. Retained pre-normalization receipts recover through the exact originally supplied spelling without a new alias or lease rewrite. Expiry/refencing and changed-kind conflicts follow the declared ordinary-poll recovery rules.

Only the closed expected poll refusals decline a carrier. Unexpected claim, backend, decoder, history-budget and invariant faults remain visible; pre-commit claim failures roll back the completion. This source handoff does not establish a published image/SDK tuple, installed qualification, benchmark result or release. Server retains integration/publication follow-through; SDK owns its capability-gated consumer and non-advertising fallback.

Producer source acceptance and SDK handoff withdrawn. Security finding 6698603892 identifies a real predecessor cutover gap on b6312594: a normalized retry cannot discover the retained digest of an older padded request, so it can claim separately while a later same-spelling retry still recovers the old lease. The new retained-key test covered only the same spelling and did not establish this boundary.

PR #1073 is now out of the merge queue and draft. Its passing original checks remain attributed, but they do not close this defect. The earlier Server owner source acceptance and SDK #328–#331 handoffs are withdrawn. Do not adopt the advertised producer contract from this head. Server owns a bounded cutover mechanism and actual predecessor padded-to-normalized / normalized-to-padded causal controls across ordinary and carried paths, preserving raw activity IDs, fences, capacity and receipt authority. A reviewed and qualified successor handoff will be posted here before consumer adoption.

I rechecked the producer after SDK3.9.5 publication. Current Server1073 candidate b985a2c8 has62 successful checks/one intended skip, but exact Security Source HOLD identifies two real contract mismatches: the closed normalization503 schema omits the actual route's protocol/capability envelope, and its carried soft-decline predicate accepts malformed lookalikes instead of the complete typed refusal. Green CI does not accept that producer. The old b631 handoffs remain withdrawn.

I reviewed the successor's PHP retry boundary and posted the concrete same-original-ID consumer gap, then asked Server to drive the exact producer correction and accepted/versioned advertisement handoff. Server owns that source/schema/real-route correction; sdk-php owns the consumer immediately after the valid contract return. No Server implementation, guessed consumer wire, unqualified runtime or imported patch was executed by sdk-php. Published3.9.5 contains only the separate helper/grant fixes and does not enable these carriers.

Next SDK action after the accepted advertised contract: For embedded carried answers, the subsequent SDK source must use the producer-authoritative normal answer/history/clock fields, charge the original completion transit and preserve every lease/fence/deadline. It must not restamp an answer, invent history, or hide producer/internal errors as a decline.

Current producer checkpoint is538e9d82860dee83df58eb1300c47731f9918019 / schema63. The finite Security re-review passes the six-file envelope/classifier correction, explicitly not whole-PR acceptance. All original workflows are now terminal: Shared42320955891 passed all48 jobs, while PHP Feature42320955880 and its aggregate failed on the pre-expiry stream-retention assertion (expected409, received404). Bounded failure triage is with Server; no assertion was weakened and no run was retried by sdk-php.

Next owner/action remains Server's causal assessment/correction and normal exact-head qualification, followed by the accepted advertised versioned contract handoff. All old handoffs remain withdrawn. sdk-php's schema/consumer readback is complete at1073/6700026815; implementation starts on that valid return, retaining free slots, same-worker/original identity and timing, missing-result=no-lease and unchanged old-Server behavior. This SDK issue remains open; the released3.9.5 helper/grant changes do not implement this carrier.

Accepted producer source contract for this SDK item. This replaces the withdrawn b631 handoff; the old receipt is not restored.

SDK331 / Server1067: each leased carried result may include answer, using CarriedActivityPollAnswer or CarriedWorkflowPollAnswer. Gate each completion carrier on its corresponding capability above, accept old flag-only true results via same-ID ordinary follow-up, and validate the complete embedded answer before dispatch.

Immutable accepted source contract: Server 511bd6fd2898e28f31f23021f2e4006837767d65, OpenAPI revision63 (schema, SHA-256 d6c726a7f97417494d9897ae1101ac7300ba6414174041dea875ae01e5052391) and shared vectors, SHA-256 12ca5db29d96b5e0f03852b698ca1d15bd796c07486a1af85484d4e4dfc45e9b. Protocol remains1.20; these are three additive capability booleans, with no separate inline-answer capability.

A carrier is a closed immediate poll request with required worker_id, task_queue, nonblank poll_request_id, and only its documented ordinary-poll optional members. The worker must be the completion's retained lease_owner before admission and again inside the transaction under its retained registration fence. Workflow carriers are workflow-only. A live or unknown-expiry opposite slot blocks eager dispatch; workflow and validation both occupy the workflow slot. Activity dispatch has priority when both carriers are supplied, and a delivered activity causes workflow-result omission.

On a successful completion response, omitted result means no lease was delivered for that carried request: release its reserved capacity without declaring the queue empty or disabling capability. {leased:false} has no answer. {leased:true,answer:...} carries the exact ordinary leased-poll envelope; an older flag-only true result requires ordinary follow-up with the same original poll ID. The clock is post-commit server_time, while lease/session/deadline/attempt/history/reference authority stays original. Charge the ORIGINAL completion request transit, including lost-answer recovery; caching or receiving the embedded answer cannot renew authority.

Duplicate completion dispatches no new task. Retain the same carried ID across a lost acknowledgement, completion retry and ordinary follow-up to recover its retained deliverable lease. Activity IDs remain raw opaque strings; workflow IDs use ordinary Laravel normalization. Missing keys on a storage-unavailable/unknown-COMMIT error are not successful omissions and do not prove that a previous attempt delivered nothing.

The workflow-key cutover requires predecessor writers to be stopped before admission. Known predecessor keys replay; otherwise a database-wide unexpired predecessor drain can temporarily decline carriers and return the closed ordinary503 workflow_poll_normalization_pending. Its actual HTTP body has eleven required fields, including protocol_version and server_capabilities, with retry_same_poll_request_id:true, retry_after_seconds:1 and claim_admitted:false for this attempt. Internal soft-decline matching binds the exact nine-field producer body. Current PHP generic retry recognizes503 but rotates IDs; the new typed consumer must retain the original identity and timing. No mixed-version deployment or old-consumer same-ID-hint support is claimed.

Producer source qualification is accepted on this exact head:62 successful checks/one declared skip; all48 Shared Server jobs and all six original workflows succeed. SQLite738+2 execution tests and real PostgreSQL16/17, MySQL8.0/existing matrix and MariaDB10.11 carried-poll controls pass. PHP3623/90028 plus Nexus51/250 and regression1/12 pass. Finite source reviews6700189761/6700308349 close the recorded findings. Independent exact-head Security qualification PASS is 6700501752. The PR is in the normal merge queue, original group54af4640 on maintained2e5e2f43. Server retains queue/main/cleanup and the later immutable publication/consumer tuple. This handoff authorizes the existing bounded SDK source work under its normal gates; no published or installed producer is claimed. Keep old-Server behavior when the matching capability is absent or false.

Draft #344 now implements the activity-delivery portion of this issue against the accepted revision-63 producer handoff. Exact source is cc181120a8760f6d6e76fc677f1b682c44e8bdbc / tree 1a325a60afc66240ad3fba7922fded3757645d38.

Inline activity answers use the normal hydration/supervision path without an activity HTTP poll or poll/request metric. Flag-only answers and lost completion acknowledgements retain their carried ID. Payload errors are processed after the parent completion. The new and existing related suite passes 278 tests / 2,021 assertions; the unchanged-base negative and real loopback original-transit controls also reconcile. Normal CI and independent review are pending.

SDK-PHP owns the workflow-answer portion with #329/#330 next. This issue remains open until both kinds, ordinary qualification and actual published-tuple criteria are delivered. #332 remains ordered after #330/#331 land.

The activity half of inline delivery has landed through #344 at main e929f1dddcaa9d06ade98b687f155cd6ad061e5d. Its full PR and actual-main qualification plus independent Security acceptance pass; the completed topic is removed.

SDK-PHP is now implementing workflow delivery from activity completions in #329, with #330 next on the same accepted producer contract. This issue remains open for those workflow cases and real installed SDK/published producer qualification. #332 stays ordered after #330/#331 land. No release or measured speedup is claimed.

The activity-completion workflow-answer portion is now in draft #345, exact 67be44ced0b3d50f4a3c921f440e81ae6bcdd4ec / tree 562dea5996d0b6fbaa02b979aefa3172c144f2f9, on main-qualified #344. It shares ordinary workflow payload/history/grant supervision and preserves the original completion timing and same-ID recovery. Known delivered leases drain on shutdown; child errors cannot acknowledge failure of the completed activity.

SDK-PHP owns normal CI and requested independent review. Related regressions, new official corpus causal control and PHPStan pass locally. #330's workflow-completion workflow carrier remains next; this issue and #332's ordering gate remain open until that source lands and the actual published-tuple criteria are met. No real Server or release acceptance is inferred from these source fixtures.

All three inline-delivery source paths are now represented: main-qualified #344, main-qualified #345, and the final workflow-completion path in draft #346, exact 671f595c1c6fb8686b79728c2a5ff9a8c00bc26d / tree 3d7d2f7f883cfcda859d5a849d364827baa0ccf3.

SDK-PHP owns #346 normal CI and requested independent review. Its 77-test/306-assertion carrier/corpus set, PHPStan and official same-runner predecessor-fail/candidate-pass control pass locally. Activity-first/missing-key, flag-only, lost-ack, shutdown and truthful error/metric behavior have explicit controls. The source is against the accepted revision-63 producer contract, not a newly published Server artifact.

#332 authoring remains ordered after #346 lands. This issue remains open for that source acceptance and the actual installed SDK/published producer run. No release or performance acceptance is inferred.

All three carried-answer source paths have landed and passed actual-main qualification: #344 at e929f1d, #345 at 41a3e37, and #346 at fc6309bdb77b17c91f6875984df6997750966a5b. The final reviewed tree is 3d7d2f7f883cfcda859d5a849d364827baa0ccf3, with independent Source acceptance, 41 successful PR checks / one intended skip and 40 successful actual-main checks / two intended skips. Completed topic refs/worktrees and test containers are removed.

SDK-PHP now starts #332's explicit default-OFF source work. This issue remains open for actual installed SDK/published producer verification. The new tests include causal official consumers, ordinary payload/history/grant paths, flag-only and lost-ack recovery, activity-first/missing-key behavior, truthful metrics/errors, free-slot controls and shutdown. They do not establish a real published Native tuple, release or performance acceptance. Server owns the artifact handoff, General retains release disposition, and SDK-PHP owns installed consumer proof.

All three completion-answer delivery paths remain accepted through #344–#346. The #328–#332 source cohort is now complete at main 783d7effb92b3e34f0f65343dd2df10a40014702 / tree c80b22d9d16589d275b3c0dbd55a54c05eaead72. Final source/main/cleanup receipt binds independent Security acceptance, all 42 main checks terminal (40 success / two intended skips), PHP 8.3 8,402 tests / 85,970 assertions, preview/source binding and completed-topic cleanup. The pipeline option remains default OFF.

Next actions / owners: General returns the concrete combined release/cohort/freeze decision under #293; Server returns the immutable supported published producer artifact/runner handoff; sdk-php then verifies the actual installed SDK and producer/fallback behavior. I requested those inputs and separately asked Server to bind ordinary prefetch admission to the producer revision. Fresh release reads remain SDK 3.9.5, Workflow 2.20.4 and Server 3.0.5. No narrower maintenance feature release, unpublished-runtime qualification or performance result is inferred. This issue stays open for its published-product criteria.

The all three inline-answer delivery installed-acceptance runner is now maintained in #348 at exact main 530da5f3c27d94fffe631700c5da16bbf87299ac. Source/main/cleanup receipt binds independent acceptance, all actual-main checks successful (39 success / one intended skip), PHP8.3 8,449 tests / 86,063 assertions and completed topic/container cleanup. Product bytes remain the accepted 783d7ef bytes.

This is harness Source preparation, not installed carrier acceptance. Server’s release-metadata successor and actual immutable publication/index/runner packet are next; General retains its execution selection, qualified Workflow caller/published2.21 authority and final SDK cohort under #293. I returned those concrete requests. sdk-php owns normal installed-package, same-worker/fence/slot/missing-key/old-Server controls after the actual tuple is supplied. This issue remains open. No unsupported/mock, release or performance PASS is inferred.

The precise frozen4fb/schema63 workflow re-registration vector is now bound in Server1067/6703522814.

RegistrationB atomically releases A's existing workflow grant to ready while rotating the token. Under the isolated same-worker/queue/build fixture, original-ID workflow recovery then polls afresh and leases the same task at n+1. Old heartbeat/completion before recovery return409 task_not_leased; in the requested recovery-first order they return409 workflow_task_attempt_mismatch with current_attempt: n+1. This differs from the accepted ACT receipt's409 poll_cached_task_expired rule. No per-grant token comparison or producer change is invented.

SDK349 can author that public-register/recovery/old-attempt sequence against the source contract. Actual execution still requires the selected immutable published Server/SDK/runner tuple. This readback is not an installed or carried-sequence PASS. Server owns the one-line native3.2 metadata Source delivery after current1085 queue/main acceptance and the subsequent exact publication packet.

All three inline delivery paths now have answer-loss/original-ID controls, original task/history/deadline binding, real transit/buffer-age confirmation, expiry and both distinct activity/workflow refence controls. Draft #349 is pushed at b24555ccf5ca2485284744df420902965b002351; Source receipt records 102 focused Source tests / 206 assertions plus lint/static analysis and cleanup. Direct bounded local/remote load support and the three-repetition comparator are also prepared. No installed or Native scenario ran.

Next action/owner: SDK-PHP finishes exact-head ordinary CI and independent Source review. General supplies the immutable published tuple and actual caller selection; SDK-PHP then runs the required installed/fallback/failure/load rows. This issue remains open for actual acceptance. Workflow replacement follows the producer's atomic release vector, distinct from activity receipt refusal. No unsupported clock, tag or performance PASS is inferred.

The remaining consumer qualification harness is now maintained at main b9525ef5f685f79acdc7da172f7cab39f8251e4b: #349 Source/main/cleanup receipt. Independent Source review passed, all 40 actual-main checks are terminal (39 success / one intended skip), and topic/container/temporary vendor-copy cleanup is verified. PHP8.3 passes 8,504 tests / 86,176 assertions.

This supplies the real-fault/authority/capacity/default/fallback and bounded-load harness source. No installed or Native row ran. Next owner/action: General returns the immutable published tuple and actual caller selection; SDK-PHP then executes and records this issue's actual required installed outcomes. The issue remains open. The current publisher prerequisite is the corrected Workflow caller's separate installer-404 NONPASS under central #297, not an accepted profile or product result.

The publisher prerequisite has advanced: the corrected actual Workflow caller is now independently accepted, with terminal/custody reconciliation. Its earlier installer-404 original remains NONPASS. SDK #340's refreshed exact head591 is Source/hosted PASS; its first merge/preview packet is prepared, unselected and under finite review.

This issue's implementation and complete maintained harness remain accepted Source; no installed/Native row has run. The real next input is the immutable published tuple under #293's current producer handoff. Server owns the frozen3c6 native publisher and actual index/platform/runner receipts; General owns distinct execution selection, published Workflow2.21 metadata/verifier and the combined SDK freeze. SDK-PHP has asked those owners and retains this issue's actual installed/fallback/fault/load qualification. A docs preview does not supply that tuple. The issue remains open.

The actual producer is published as Native Server 3.2.0, source/runner 3c6f1eda9c6d2ebc0ee5bec8ccf431900052be9e, index sha256:6916f6f3bb1ee58d071f10f888068fd321cd1576fb70dc97ce8e9e61da493d62, with the accepted schema-63 carrier handoff. Published Workflow 2.21.0 authority is also available. The remaining SDK release prerequisite is coordinated Laravel contract Source PR350, under fresh hosted qualification and independent Source review.

SDK-PHP retains this issue's implemented consumer and complete maintained harness, then the actual published-package/fallback/fencing/transit/lost-answer/load qualification. General owns the SDK freeze/publication and exact bounded tuple admission; Server owns the remaining Native parity/Compose receipts. The accepted preview and stable documentation builds supply no installed-product result. No installed row has run and this issue remains open.

The coordinated Laravel prerequisite is now actually integrated on main 6ec471d with Source/main acceptance, preview terminal/artifact/nondeployment acceptance, and owned-topic cleanup. Live documentation remains on the accepted published SDK3.9.5 tuple. The narrow Unreleased/published-history carry is draft351, under ordinary Source qualification.

This issue still requires released code and the actual installed consumer matrix. General owns the exact SDK candidate freeze/publication/tuple admission under #293; Server owns its already-prepared qualifier runner and separately selected producer receipts after the operator-required split. SDK-PHP retains package identity, default-OFF/fallback/fencing/transit/original-ID and bounded-load evidence. No SDK3.10 tag/package or installed row is claimed; this issue remains open.

SDK source prerequisites are complete on main a969c1d4c07b5d1c1fab4e354f98a98a80e3cbd5: the coordinated Laravel contract and release-note/history carry have Source/main acceptance and exact topic cleanup. The complete maintained consumer harness remains accepted Source.

The real older-producer candidate Server3.0.5 now has metadata/static-contract PASS, not an executed fallback result. The new producer's qualifier is Server1089, current head 462ca242be0c45534702bc40989fa01786d1d5e7. Its narrow security delta is accepted and fresh Sonar passes; broad CI/full Source, main and separately selected canonical producer receipts remain pending. Old1a546's failed result stays attributed.

Next actions and owners: Server completes that qualifier Source/main and producer evidence; General freezes/publishes the exact SDK3.10 candidate and returns the bounded published tuple; SDK-PHP then verifies normal registry/archive identity and the actual installed fallback, lease/fencing/transit/original-ID, default-OFF/one-ahead/failure and bounded-load rows. Those owners have the concrete handoff requests and diagnosis. No SDK3.10 package, installed row or throughput result is claimed. This issue remains open for its released/installed acceptance.

Navigation Menu

Repository navigation

Deliver a carried poll's lease from its completion's answer #331

Proposal

Acceptance

Dependencies

Draft patches and validation boundary

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Deliver a carried poll's lease from its completion's answer #331

Description

Proposal

Acceptance

Dependencies

Draft patches and validation boundary

Activity

rmcdaniel commented on Nov 6, 2026

rmcdaniel commented on Nov 6, 2026

rmcdaniel commented on Nov 6, 2026

rmcdaniel commented on Nov 6, 2026

rmcdaniel commented on Nov 6, 2026

rmcdaniel commented on Nov 6, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

rmcdaniel commented on Nov 7, 2026

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions