diff --git a/.github/workflows/otel-conformance-tests.yml b/.github/workflows/otel-conformance-tests.yml
index 280dd2d41..96afa4848 100644
--- a/.github/workflows/otel-conformance-tests.yml
+++ b/.github/workflows/otel-conformance-tests.yml
@@ -49,6 +49,7 @@ on:
       conformance_test_ref:
         description: Optional conformance test commit SHA or branch name
         required: false
+        default: "05960beb6c81d7b24b53114f2581b3b6f9fef6d4"
         type: string
 
 permissions: {}
@@ -70,13 +71,13 @@ jobs:
       id-token: write
     uses: aws/aws-durable-execution-conformance-tests/.github/workflows/opentelemetry-orchestrator.yml@d8b8399264628dae57b7a96bf4cbf3e39a99fd8d
     with:
-      case_count: 20
+      case_count: 26
       runs_on: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository && 'ubuntu-latest' || format('codebuild-github-actions-runner-{0}-{1}', github.run_id, github.run_attempt) }}
       language: java
       resource_prefix: j
       sdk_repository: aws/aws-durable-execution-sdk-java
       sdk_ref: ${{ github.event.pull_request.head.sha || github.sha }}
-      conformance_test_ref: ${{ inputs.conformance_test_ref || '02d6dca971a38c13d94d6233d12f687e55b2a572' }}
+      conformance_test_ref: ${{ inputs.conformance_test_ref || '05960beb6c81d7b24b53114f2581b3b6f9fef6d4' }}
       checkout_sdk: true
       # Build the handlers from this repo's checked-out module instead of the conformance repo's
       # bundled examples/java. Path is relative to the conformance workspace where the SDK is
diff --git a/conformance-tests-otel/README.md b/conformance-tests-otel/README.md
new file mode 100644
index 000000000..ad2e300af
--- /dev/null
+++ b/conformance-tests-otel/README.md
@@ -0,0 +1,86 @@
+# Java OpenTelemetry conformance handlers
+
+The shared conformance repository owns the requirements and validators. This
+module supplies public-API handlers and SAM resources for both tracing views.
+Existing cases 1–20 and their resources are unchanged by the additions below.
+
+| Case | Scenario | Behavior |
+| --- | --- | --- |
+| 21 | `completed-step-replay` | Complete a step, suspend on a one-second durable wait, then complete another step. The first step body is skipped on replay. |
+| 22 | `user-function-context` | Probe handler entry/restoration/resume, step, child, concurrent parallel branches and map iterations, and their nested steps. |
+| 23 | `callback-function-context` | Probe step retry attempts, condition checks, callback submission, a wrapped retry helper's body and strategy, and a virtual child after the asynchronous work finishes. |
+| 24 | `invocation-retry-status` | Throw the public retryable execution exception after a checkpointed step, then recover on replay. |
+| 25 | `caught-callback-failure-replay` | Catch the expected public callback failure, checkpoint `caught`, then resume through two typed String callback barriers and return `caught/one/two`. The failed leaf stays `ERROR` without an exception event. |
+| 26 | `external-callback-completion-replay` | Observe a root callback completion, checkpoint its result, then revisit it through two later callback barriers without duplicate terminal export. |
+
+Cases 22 and 23 require a valid active `SpanContext` and create/end ordinary
+`conformance.<label>` user spans with `conformance.callback=<label>`. They do not
+set parents, attach contexts, copy the execution ARN onto user spans, or create
+SDK spans. The shared validator determines the canonical trace from SDK spans
+and checks the actual user-span parents.
+
+Root handler probes preserve a valid same-trace ambient Lambda parent. Otherwise
+the plugin activates its canonical Invocation/Workflow context on the handler
+thread and restores it in the same-thread end hook. The plugin requires the
+core's 2.2.2 lifecycle capability; older cores are rejected during configuration.
+Nested callbacks retain their named context or attempt parents. Execution-view
+context placeholders can be valid without recording, so probes do not require
+`isRecording()`.
+
+Case 23 uses the public step attempt number and checkpointed condition state;
+it has no mutable warm-container markers. Its helper and virtual child run
+after callback completion, so normal suspension/replay does not repeat those
+probes. Only the intentional helper failure is caught. The wrapped helper's
+strategy executes inside its established context lifecycle; this does not
+establish a parent contract for every other policy callback.
+
+Serialization, map item naming, completion policies, standalone step retry or
+condition wait strategies, and callbacks invoked before tracing setup are not
+claimed to share the stable user-function hook boundary. Plugin hooks,
+extractors, and samplers cannot be required to have made their future SDK span
+current. Arbitrary user-created threads are also outside these cases.
+
+Case 24 captures `isReplaying()` at handler entry before consuming the completed
+step. Java's public `UnrecoverableDurableExecutionException(ErrorObject, true)`
+requests invocation retry; the handler does not inject plugin hooks or
+checkpoint messages. Its expected invocation statuses are `RETRYING` then
+`SUCCEEDED`. Recovery may repeat telemetry delivery, so this case imposes no
+exact operation-export count.
+
+The module builds against the SDK selected by `JAVA_SDK_VERSION` or the
+`durable.sdk.version` Maven property. Run matched shared requirements when
+validating new cases; a workflow pinned to an older requirement set does not
+validate the newly added cases. The configured OTel conformance workflow owns
+deployment and backend validation.
+
+Case 26 creates `otel-external-target` directly on the root context and reads its
+stored result on every replay. The `otel-external-target-observed` step returns
+that result unchanged and runs only on the first completion. Two later
+`waitForCallback` barriers force two more handler replays. The shared driver sends
+each callback success only after its creating invocation has completed, producing
+four invocations and the final result `target/one/two`. Lossless S3 telemetry must
+show one terminal export for each callback; the first target completion precedes
+the observation-step attempt. This is SDK cloud behavior coverage, not a claim
+that a deployed Lambda exercises the JS local-runner wrapper.
+
+Case 25 requires the matching caught-failure/replay shared requirement revision;
+its successful result is incompatible with the older unhandled-failure requirement.
+The owning workflow pairs handler routing with the qualified shared source ref.
+Shared cloud checks establish the service error-payload representation and callback
+phase gates; local runner checks do not establish those service facts.
+
+Case 25 catches `CallbackFailedException` and the documented
+`ChildContextFailedException` replay fallback around its first `waitForCallback`.
+The fallback retains the actual failed context when its nested callback/submitter
+details have been pruned; it does not invent a callback failure category or ID.
+The marker step and both barriers remain outside that catch. Each barrier uses
+`String.class` callback deserialization, and the marker returns its checkpointed
+value rather than mutating a captured variable. Four invocations produce
+`PENDING`, `PENDING`, `PENDING`, then `SUCCEEDED`. Replaying the cached failed child
+can reach the catch without rerunning its callback body; this does not claim a
+direct callback revisit after child-history pruning. Case 17 remains unhandled.
+
+For case 25, Java reports no plugin error details for an entirely empty error
+container. The persisted container, callback failure, and caller error stay
+unchanged. Any present type, message, data, or stack-trace field remains an error
+detail, including an empty string or an explicitly supplied empty stack list.
diff --git a/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel21CompletedStepReplay.java b/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel21CompletedStepReplay.java
new file mode 100644
index 000000000..9e2098f71
--- /dev/null
+++ b/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel21CompletedStepReplay.java
@@ -0,0 +1,20 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.conformance.otel;
+
+import java.time.Duration;
+import java.util.Map;
+import software.amazon.lambda.durable.DurableContext;
+
+/** Completed-step replay scenario for OTel requirement 21 in both views. */
+public final class Otel21CompletedStepReplay extends OtelConformanceHandler<String> {
+
+    @Override
+    public String handleRequest(Map<String, Object> event, DurableContext context) {
+        requireScenario(event, "completed-step-replay");
+        var before = context.step("otel-before-wait", String.class, step -> "before");
+        context.wait("otel-replay-wait", Duration.ofSeconds(1));
+        var after = context.step("otel-after-wait", String.class, step -> "after");
+        return before + "-" + after;
+    }
+}
diff --git a/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel22UserFunctionContext.java b/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel22UserFunctionContext.java
new file mode 100644
index 000000000..a4da1f1f3
--- /dev/null
+++ b/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel22UserFunctionContext.java
@@ -0,0 +1,96 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.conformance.otel;
+
+import io.opentelemetry.api.GlobalOpenTelemetry;
+import io.opentelemetry.api.trace.Span;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import software.amazon.lambda.durable.DurableContext;
+import software.amazon.lambda.durable.config.MapConfig;
+import software.amazon.lambda.durable.config.ParallelConfig;
+
+/** Active user-function context scenario for OTel requirement 22 in both views. */
+public final class Otel22UserFunctionContext extends OtelConformanceHandler<String> {
+
+    @Override
+    public String handleRequest(Map<String, Object> event, DurableContext context) {
+        requireScenario(event, "user-function-context");
+        probe("handler");
+        context.step("otel-context-step", String.class, step -> {
+            probe("step");
+            return "step";
+        });
+        runChild(context);
+        runParallel(context);
+        runMap(context);
+        probe("handler-restored");
+        context.wait("otel-context-resume", Duration.ofSeconds(1));
+        probe("handler-after-resume");
+        return "context-complete";
+    }
+
+    private static void runChild(DurableContext context) {
+        context.runInChildContext("otel-context-child", String.class, child -> {
+            probe("child");
+            var result = child.step("otel-context-child-step", String.class, step -> {
+                probe("child-step");
+                return "child";
+            });
+            probe("child-restored");
+            return result;
+        });
+    }
+
+    private static void runMap(DurableContext context) {
+        context.map(
+                "otel-context-map",
+                List.of(0, 1),
+                Integer.class,
+                (item, index, iteration) -> {
+                    probe("map-" + index);
+                    return iteration.step("otel-context-map-step-" + index, Integer.class, step -> {
+                        probe("map-step-" + index);
+                        return item;
+                    });
+                },
+                MapConfig.builder()
+                        .maxConcurrency(2)
+                        .itemNamer((item, index) -> "otel-context-iteration-" + index)
+                        .build());
+    }
+
+    private static void runParallel(DurableContext context) {
+        var parallel = context.parallel(
+                "otel-context-parallel",
+                ParallelConfig.builder().maxConcurrency(2).build());
+        try (parallel) {
+            parallel.branch("otel-context-branch-a", String.class, branch -> {
+                probe("parallel-a");
+                return branch.step("otel-context-branch-step-a", String.class, step -> {
+                    probe("parallel-step-a");
+                    return "a";
+                });
+            });
+            parallel.branch("otel-context-branch-b", String.class, branch -> {
+                probe("parallel-b");
+                return branch.step("otel-context-branch-step-b", String.class, step -> {
+                    probe("parallel-step-b");
+                    return "b";
+                });
+            });
+        }
+    }
+
+    private static void probe(String label) {
+        if (!Span.current().getSpanContext().isValid()) {
+            throw new IllegalStateException("No active span context for " + label);
+        }
+        var span = GlobalOpenTelemetry.getTracer("durable-conformance")
+                .spanBuilder("conformance." + label)
+                .setAttribute("conformance.callback", label)
+                .startSpan();
+        span.end();
+    }
+}
diff --git a/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel23CallbackFunctionContext.java b/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel23CallbackFunctionContext.java
new file mode 100644
index 000000000..e4bd8898c
--- /dev/null
+++ b/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel23CallbackFunctionContext.java
@@ -0,0 +1,109 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.conformance.otel;
+
+import io.opentelemetry.api.GlobalOpenTelemetry;
+import io.opentelemetry.api.trace.Span;
+import java.time.Duration;
+import java.util.Map;
+import software.amazon.lambda.durable.DurableContext;
+import software.amazon.lambda.durable.config.RunInChildContextConfig;
+import software.amazon.lambda.durable.config.StepConfig;
+import software.amazon.lambda.durable.config.WaitForConditionConfig;
+import software.amazon.lambda.durable.config.WithRetryConfig;
+import software.amazon.lambda.durable.exception.DurableOperationException;
+import software.amazon.lambda.durable.model.WaitForConditionResult;
+import software.amazon.lambda.durable.retry.RetryDecision;
+import software.amazon.lambda.durable.retry.RetryStrategies;
+import software.amazon.lambda.durable.retry.WaitStrategies;
+
+/** Retry, polling, submitter, and helper callback contexts for OTel requirement 23. */
+public final class Otel23CallbackFunctionContext extends OtelConformanceHandler<String> {
+    private static final String HELPER_FAILURE = "intentional-helper-failure";
+
+    @Override
+    public String handleRequest(Map<String, Object> event, DurableContext context) {
+        requireScenario(event, "callback-function-context");
+        runRetryStep(context);
+        runCondition(context);
+        context.waitForCallback(
+                "otel-context-callback", String.class, (callbackId, step) -> probe("callback-submitter"));
+        runFailedHelper(context);
+        context.runInChildContext(
+                "otel-context-virtual",
+                String.class,
+                child -> {
+                    probe("virtual-child");
+                    return "virtual";
+                },
+                RunInChildContextConfig.builder().isVirtual(true).build());
+        return "callback-context-complete";
+    }
+
+    private static void runRetryStep(DurableContext context) {
+        context.step(
+                "otel-context-retry-step",
+                String.class,
+                step -> {
+                    var attempt = step.getAttempt();
+                    probe("retry-attempt-" + attempt);
+                    if (attempt == 1) throw new IllegalStateException("intentional-step-retry");
+                    return "retried";
+                },
+                StepConfig.builder()
+                        .retryStrategy(RetryStrategies.fixedDelay(2, Duration.ofSeconds(1)))
+                        .build());
+    }
+
+    private static void runCondition(DurableContext context) {
+        context.waitForCondition(
+                "otel-context-condition",
+                Integer.class,
+                (state, step) -> {
+                    var next = state + 1;
+                    probe("condition-check-" + next);
+                    return next == 2
+                            ? WaitForConditionResult.stopPolling(next)
+                            : WaitForConditionResult.continuePolling(next);
+                },
+                WaitForConditionConfig.<Integer>builder()
+                        .initialState(0)
+                        .waitStrategy(WaitStrategies.fixedDelay(2, Duration.ofSeconds(1)))
+                        .build());
+    }
+
+    private static void runFailedHelper(DurableContext context) {
+        try {
+            context.withRetry(
+                    "otel-context-with-retry",
+                    (attempt, child) -> {
+                        probe("with-retry-body");
+                        throw new IllegalStateException(HELPER_FAILURE);
+                    },
+                    WithRetryConfig.builder()
+                            .wrapInChildContext(true)
+                            .retryStrategy((error, attempt) -> {
+                                probe("with-retry-strategy");
+                                return RetryDecision.fail();
+                            })
+                            .build());
+        } catch (RuntimeException error) {
+            var message =
+                    error instanceof DurableOperationException operationError && operationError.getErrorObject() != null
+                            ? operationError.getErrorObject().errorMessage()
+                            : error.getMessage();
+            if (!HELPER_FAILURE.equals(message)) throw error;
+        }
+    }
+
+    private static void probe(String label) {
+        if (!Span.current().getSpanContext().isValid()) {
+            throw new IllegalStateException("No active span context for " + label);
+        }
+        var span = GlobalOpenTelemetry.getTracer("durable-conformance")
+                .spanBuilder("conformance." + label)
+                .setAttribute("conformance.callback", label)
+                .startSpan();
+        span.end();
+    }
+}
diff --git a/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel24InvocationRetryStatus.java b/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel24InvocationRetryStatus.java
new file mode 100644
index 000000000..fea430f84
--- /dev/null
+++ b/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel24InvocationRetryStatus.java
@@ -0,0 +1,28 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.conformance.otel;
+
+import java.util.Map;
+import software.amazon.awssdk.services.lambda.model.ErrorObject;
+import software.amazon.lambda.durable.DurableContext;
+import software.amazon.lambda.durable.exception.UnrecoverableDurableExecutionException;
+
+/** Public invocation-retry signal and checkpoint recovery for OTel requirement 24. */
+public final class Otel24InvocationRetryStatus extends OtelConformanceHandler<String> {
+
+    @Override
+    public String handleRequest(Map<String, Object> event, DurableContext context) {
+        requireScenario(event, "invocation-retry-status");
+        var replayingAtEntry = context.isReplaying();
+        context.step("otel-before-invocation-retry", String.class, step -> "saved");
+        if (!replayingAtEntry) {
+            throw new UnrecoverableDurableExecutionException(
+                    ErrorObject.builder()
+                            .errorType("ConformanceInvocationRetry")
+                            .errorMessage("intentional-invocation-retry")
+                            .build(),
+                    true);
+        }
+        return "retry-complete";
+    }
+}
diff --git a/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel25CaughtCallbackFailureReplay.java b/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel25CaughtCallbackFailureReplay.java
new file mode 100644
index 000000000..6f66bfb02
--- /dev/null
+++ b/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel25CaughtCallbackFailureReplay.java
@@ -0,0 +1,28 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.conformance.otel;
+
+import java.util.Map;
+import software.amazon.lambda.durable.DurableContext;
+import software.amazon.lambda.durable.exception.CallbackFailedException;
+import software.amazon.lambda.durable.exception.ChildContextFailedException;
+
+/** Catches an externally failed callback, then resumes twice before returning successfully. */
+public final class Otel25CaughtCallbackFailureReplay extends OtelConformanceHandler<String> {
+
+    @Override
+    public String handleRequest(Map<String, Object> event, DurableContext context) {
+        requireScenario(event, "caught-callback-failure-replay");
+        var caught = false;
+        try {
+            context.waitForCallback("otel-failed-callback", String.class, (callbackId, step) -> {});
+        } catch (CallbackFailedException | ChildContextFailedException expected) {
+            caught = true;
+        }
+        if (!caught) throw new IllegalStateException("Expected the first callback to fail");
+        var observed = context.step("otel-failed-callback-observed", String.class, step -> "caught");
+        var one = context.waitForCallback("otel-failed-callback-barrier-one", String.class, (callbackId, step) -> {});
+        var two = context.waitForCallback("otel-failed-callback-barrier-two", String.class, (callbackId, step) -> {});
+        return observed + "/" + one + "/" + two;
+    }
+}
diff --git a/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel26ExternalCompletionReplay.java b/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel26ExternalCompletionReplay.java
new file mode 100644
index 000000000..2c3f709fd
--- /dev/null
+++ b/conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel/Otel26ExternalCompletionReplay.java
@@ -0,0 +1,20 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.conformance.otel;
+
+import java.util.Map;
+import software.amazon.lambda.durable.DurableContext;
+
+/** Observes a root callback completion once, then revisits it through two later callback resumes. */
+public final class Otel26ExternalCompletionReplay extends OtelConformanceHandler<String> {
+
+    @Override
+    public String handleRequest(Map<String, Object> event, DurableContext context) {
+        requireScenario(event, "external-callback-completion-replay");
+        var target = context.createCallback("otel-external-target", String.class).get();
+        var observed = context.step("otel-external-target-observed", String.class, step -> target);
+        var one = context.waitForCallback("otel-external-barrier-one", String.class, (callbackId, step) -> {});
+        var two = context.waitForCallback("otel-external-barrier-two", String.class, (callbackId, step) -> {});
+        return observed + "/" + one + "/" + two;
+    }
+}
diff --git a/conformance-tests-otel/template.yaml b/conformance-tests-otel/template.yaml
index bdda8a5b0..2a183257b 100644
--- a/conformance-tests-otel/template.yaml
+++ b/conformance-tests-otel/template.yaml
@@ -316,6 +316,66 @@ Resources:
       Handler: software.amazon.lambda.durable.conformance.otel.Otel20VirtualContext
       Role: !Ref LambdaExecutionRoleArn
 
+  Otel21CompletedStepReplay:
+    Type: AWS::Serverless::Function
+    TestingMetadata:
+      TestDescription:
+        - otel-invocation-21
+    Properties:
+      CodeUri: .
+      Handler: software.amazon.lambda.durable.conformance.otel.Otel21CompletedStepReplay
+      Role: !Ref LambdaExecutionRoleArn
+
+  Otel22UserFunctionContext:
+    Type: AWS::Serverless::Function
+    TestingMetadata:
+      TestDescription:
+        - otel-invocation-22
+    Properties:
+      CodeUri: .
+      Handler: software.amazon.lambda.durable.conformance.otel.Otel22UserFunctionContext
+      Role: !Ref LambdaExecutionRoleArn
+
+  Otel23CallbackFunctionContext:
+    Type: AWS::Serverless::Function
+    TestingMetadata:
+      TestDescription:
+        - otel-invocation-23
+    Properties:
+      CodeUri: .
+      Handler: software.amazon.lambda.durable.conformance.otel.Otel23CallbackFunctionContext
+      Role: !Ref LambdaExecutionRoleArn
+
+  Otel24InvocationRetryStatus:
+    Type: AWS::Serverless::Function
+    TestingMetadata:
+      TestDescription:
+        - otel-invocation-24
+    Properties:
+      CodeUri: .
+      Handler: software.amazon.lambda.durable.conformance.otel.Otel24InvocationRetryStatus
+      Role: !Ref LambdaExecutionRoleArn
+
+  Otel25CaughtCallbackFailureReplay:
+    Type: AWS::Serverless::Function
+    TestingMetadata:
+      TestDescription:
+        - otel-invocation-25
+    Properties:
+      CodeUri: .
+      Handler: software.amazon.lambda.durable.conformance.otel.Otel25CaughtCallbackFailureReplay
+      Role: !Ref LambdaExecutionRoleArn
+
+  Otel26ExternalCompletionReplay:
+    Type: AWS::Serverless::Function
+    TestingMetadata:
+      TestDescription:
+        - otel-invocation-26
+    Properties:
+      CodeUri: .
+      Handler: software.amazon.lambda.durable.conformance.otel.Otel26ExternalCompletionReplay
+      Role: !Ref LambdaExecutionRoleArn
+
   OtelExecution1Success:
     Type: AWS::Serverless::Function
     TestingMetadata:
@@ -600,3 +660,81 @@ Resources:
       Environment:
         Variables:
           OTEL_PLUGIN_MODE: execution
+
+  OtelExecution21CompletedStepReplay:
+    Type: AWS::Serverless::Function
+    TestingMetadata:
+      TestDescription:
+        - otel-execution-21
+    Properties:
+      CodeUri: .
+      Handler: software.amazon.lambda.durable.conformance.otel.Otel21CompletedStepReplay
+      Role: !Ref LambdaExecutionRoleArn
+      Environment:
+        Variables:
+          OTEL_PLUGIN_MODE: execution
+
+  OtelExecution22UserFunctionContext:
+    Type: AWS::Serverless::Function
+    TestingMetadata:
+      TestDescription:
+        - otel-execution-22
+    Properties:
+      CodeUri: .
+      Handler: software.amazon.lambda.durable.conformance.otel.Otel22UserFunctionContext
+      Role: !Ref LambdaExecutionRoleArn
+      Environment:
+        Variables:
+          OTEL_PLUGIN_MODE: execution
+
+  OtelExecution23CallbackFunctionContext:
+    Type: AWS::Serverless::Function
+    TestingMetadata:
+      TestDescription:
+        - otel-execution-23
+    Properties:
+      CodeUri: .
+      Handler: software.amazon.lambda.durable.conformance.otel.Otel23CallbackFunctionContext
+      Role: !Ref LambdaExecutionRoleArn
+      Environment:
+        Variables:
+          OTEL_PLUGIN_MODE: execution
+
+  OtelExecution24InvocationRetryStatus:
+    Type: AWS::Serverless::Function
+    TestingMetadata:
+      TestDescription:
+        - otel-execution-24
+    Properties:
+      CodeUri: .
+      Handler: software.amazon.lambda.durable.conformance.otel.Otel24InvocationRetryStatus
+      Role: !Ref LambdaExecutionRoleArn
+      Environment:
+        Variables:
+          OTEL_PLUGIN_MODE: execution
+
+  OtelExecution25CaughtCallbackFailureReplay:
+    Type: AWS::Serverless::Function
+    TestingMetadata:
+      TestDescription:
+        - otel-execution-25
+    Properties:
+      CodeUri: .
+      Handler: software.amazon.lambda.durable.conformance.otel.Otel25CaughtCallbackFailureReplay
+      Role: !Ref LambdaExecutionRoleArn
+      Environment:
+        Variables:
+          OTEL_PLUGIN_MODE: execution
+
+  OtelExecution26ExternalCompletionReplay:
+    Type: AWS::Serverless::Function
+    TestingMetadata:
+      TestDescription:
+        - otel-execution-26
+    Properties:
+      CodeUri: .
+      Handler: software.amazon.lambda.durable.conformance.otel.Otel26ExternalCompletionReplay
+      Role: !Ref LambdaExecutionRoleArn
+      Environment:
+        Variables:
+          OTEL_PLUGIN_MODE: execution
diff --git a/docs/advanced/testing.md b/docs/advanced/testing.md
index c87eff9f6..ce0fa3375 100644
--- a/docs/advanced/testing.md
+++ b/docs/advanced/testing.md
@@ -37,6 +37,30 @@ var runner = LocalDurableTestRunner.create(Order.class, (order, ctx) -> {
 });
 ```
 
+### Replay State in Local Tests
+
+The local runner's invocation input and its `GetDurableExecutionState` view omit
+descendants of a `SUCCEEDED` or `FAILED` CONTEXT unless that context closed with
+`ReplayChildren: true`. Every ancestor is checked: a running intermediate context
+or an inner context that retains children does not override a completed ancestor
+that omits them. Root operations and operations with unknown parents remain visible.
+
+Only the closing update determines `ReplayChildren`. `START` does not record the
+option, and a close without it records `false`. A large child-context result can
+use retained children to rebuild its result on replay; already-completed steps
+still consume their stored results.
+
+This filtering applies to the state delivered to the SDK. Test results,
+`runner.getOperation(...)`, history, checkpoint response updates, and
+`UpdatedOperationIds` retain all their operation records or IDs. An updated ID can
+therefore refer to an operation omitted from the invocation input; the ID alone
+does not provide its missing metadata. The local state API returns a single page.
+
+Operation names must still remain deterministic. Pruning can prevent the SDK from
+detecting a changed child name when it consumes a cached parent result. Tests of
+name-mismatch detection should also cover retained children and running contexts,
+where the service still provides the relevant checkpoint metadata.
+
 ### Inspecting Operations
 
 ```java
diff --git a/examples/src/test/java/software/amazon/lambda/durable/examples/parallel/ParallelFailureToleranceExampleTest.java b/examples/src/test/java/software/amazon/lambda/durable/examples/parallel/ParallelFailureToleranceExampleTest.java
index cb23be650..4d2b7825a 100644
--- a/examples/src/test/java/software/amazon/lambda/durable/examples/parallel/ParallelFailureToleranceExampleTest.java
+++ b/examples/src/test/java/software/amazon/lambda/durable/examples/parallel/ParallelFailureToleranceExampleTest.java
@@ -117,6 +117,28 @@ void failsWhenFailuresExceedTolerance(boolean holdHealthyBranch) throws Exceptio
         }
     }
 
+    @Test
+    void failsWhenOnlyFailedBranchesExceedTolerance() {
+        var handler = new ParallelFailureToleranceExample();
+        var runner = LocalDurableTestRunner.create(ParallelFailureToleranceExample.Input.class, handler);
+
+        // Both failures must complete to exceed tolerance. A racing good branch need not finish before that point.
+        var input = new ParallelFailureToleranceExample.Input(List.of("bad-svc-b", "bad-svc-c"), 1, 2);
+        var result = runner.runUntilComplete(input);
+
+        assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+
+        var output = result.getResult(ParallelFailureToleranceExample.Output.class);
+        assertEquals(2, output.failed());
+        assertEquals(0, output.succeeded());
+        var parallel = new JacksonSerDes()
+                .deserialize(
+                        result.getOperation("call-services").getContextDetails().result(),
+                        TypeToken.get(ParallelResult.class));
+        assertEquals(ConcurrencyCompletionStatus.FAILURE_TOLERANCE_EXCEEDED, parallel.completionStatus());
+        assertEquals(2, parallel.failed());
+    }
+
     private static void await(CountDownLatch latch) {
         try {
             assertTrue(latch.await(5, TimeUnit.SECONDS), "Controlled branch scheduling was not released");
diff --git a/otel-plugin/README.md b/otel-plugin/README.md
index e1fe77d58..b9e2dd4e9 100644
--- a/otel-plugin/README.md
+++ b/otel-plugin/README.md
@@ -379,9 +379,15 @@ The supported SDK sampler follows this precedence, highest first:
    Eviction can cause another evaluation. The delegate still receives the canonical trace ID; drop and
    `RECORD_ONLY` decisions, attributes and updated trace state are retained.
 
-A visible plain replacement sampler supplies its root policy for execution-ancestor flags, then keeps its normal
-per-span sampling behavior. It receives no SDK sampling carrier and does not provide the SDK decision-reuse
-or full-result override guarantees above. Opaque providers cannot expose a later sampler replacement to the
+For a visible plain replacement sampler with no explicit upstream or same-trace ambient decision, a fallback anchor
+uses the provider's actual root sampling result for its parent context. It does not spend a preliminary decision before
+creating that root. Descendants still use the provider's own per-span sampling, so a stateful policy can select them
+differently. Explicit and ambient decisions retain their existing context behavior. The legacy complete-remote-parent
+path still evaluates root policy before span creation when sampling is undecided; a stateful replacement can observe
+that additional query. The query resolves the remote parent's otherwise-unknown sampled flag from the configured
+root policy; omitting it can bypass `ParentBased(alwaysOff)`. Supply an explicit upstream decision or retain
+`DurableSampler` when a policy result must be reused authoritatively. A plain replacement receives no SDK sampling carrier and does not provide SDK-wide decision
+reuse or full-result overrides. Opaque providers cannot expose a later sampler replacement to the
 application, so retain the wrapper through the documented customization setup.
 
 For explicit execution-level control, keep `DurableSampler` as the final installed sampler and set `Sampled` upstream,
@@ -396,6 +402,31 @@ can export only the anchor or only its Invocation child. This behavior is covere
 shared decision. Merely delaying anchor creation until terminal completion would not make an arbitrary replacement
 sampler consistent across spans.
 
+### Operation error details
+
+An explicit operation status of `FAILED`, `TIMED_OUT`, or `STOPPED` sets the OTel span to `ERROR`, including when the
+backend error container is absent or fully empty. No exception event is recorded when no details were supplied.
+An explicitly present empty string or stack-trace list still counts as supplied error details.
+Virtual (FLAT) contexts can have no terminal status; a non-null failure still sets `ERROR`, even when its backend
+error container supplies no details. That failure has no exception event unless details are available.
+An exception's own message (including an empty string), cause, suppressed failures,
+or explicit stack trace still supplies diagnostic information and retains `ERROR` and its exception event.
+
+This telemetry decision does not remove the SDK's failure notification: a present `ErrorObject`, including `{}`,
+remains a `DurableOperationException` in operation hooks and snapshots. An absent container retains its existing
+null metadata behavior. Persisted errors, caller failures, replay, and user-function error handling are unchanged.
+
+Execution-view operation spans with a known, nonzero backend end timestamp record the exception event at that
+same timestamp. This path uses the public `exception` event with standard `exception.type`, `exception.message`
+(when present), and `exception.stacktrace` attributes. Java's standard stack-trace text and the provider's ordinary
+event attribute count/value limits apply; native `recordException` resolver behavior is not preserved on this path.
+Invocation-view events and operations without a backend end (including the SDK's epoch-zero clock sentinel) keep
+native `recordException` behavior.
+
+When an Execution-view completion has no observed or backend start timestamp, its known end also supplies the start.
+Existing earliest-known-start selection is unchanged and is not clamped to the backend end, so clock skew can still
+produce an inverted interval. This correction does not add a broader clock or containment policy.
+
 ## Span Attributes
 
 ### Invocation Span
diff --git a/otel-plugin/src/main/java/software/amazon/lambda/durable/otel/ExecutionOtelPlugin.java b/otel-plugin/src/main/java/software/amazon/lambda/durable/otel/ExecutionOtelPlugin.java
index b9eb349e8..e05af4a6b 100644
--- a/otel-plugin/src/main/java/software/amazon/lambda/durable/otel/ExecutionOtelPlugin.java
+++ b/otel-plugin/src/main/java/software/amazon/lambda/durable/otel/ExecutionOtelPlugin.java
@@ -236,8 +236,8 @@ public void onInvocationStart(InvocationInfo info) {
                 canonicalTraceId,
                 workflowSpanName,
                 Attributes.of(DURABLE_EXECUTION_ARN, arn()));
-        // A null decision is unresolved on the agent path: defer to DurableSampler's own delegate (keyed by trace ID),
-        // rather than fabricating a decision that would bypass an installed drop/rate-limit policy.
+        // An unresolved decision is supplied by the actual fallback root or the agent-side sampler. Do not invent
+        // a decision that bypasses an installed drop/rate-limit policy.
         samplingIntent = decision != null
                 ? DurableSamplingDecision.Intent.resolved(decision)
                 : DurableSamplingDecision.Intent.deferred(canonicalTraceId);
@@ -260,8 +260,10 @@ public void onInvocationStart(InvocationInfo info) {
             // Retain the ended root as a flush marker even if an onEnd processor throws during Start.
             executionRootSpan = root;
         }
-        // A visible plain replacement keeps its documented ancestor-flag fallback, without SDK-wide overrides.
-        if (executionRootSpan != null && OtelPluginSupport.usesDurableSamplingBridge(sdkTracerProvider)) {
+        // An unresolved plain fallback uses the real root's decision; explicit/ambient decisions and the
+        // legacy remote-parent path retain their existing behavior. Plain samplers still own each child decision.
+        if (executionRootSpan != null
+                && (OtelPluginSupport.usesDurableSamplingBridge(sdkTracerProvider) || decision == null)) {
             execCtx = new ExecutionTraceContext(executionRootSpan.getSpanContext());
         }
         executionTrace = new ExecutionTrace(canonicalTraceId, execCtx.traceFlags());
@@ -435,6 +437,8 @@ public void onOperationEnd(OperationEndInfo info) {
         // created earlier, at onUserFunctionStart/onOperationStart). onOperationEnd's start timestamp can be a later
         // re-observed value than the start captured at onOperationStart, so take the minimum of the two.
         var startTimestamp = earliest(capturedStart, info.startTimestamp());
+        // Use the known end when no start was observed; retain any existing start even if clocks disagree.
+        if (startTimestamp == null) startTimestamp = info.endTimestamp();
         if (startTimestamp != null) {
             spanBuilder.setStartTimestamp(startTimestamp);
         }
@@ -455,16 +459,7 @@ public void onOperationEnd(OperationEndInfo info) {
         if (info.attempt() != null) {
             span.setAttribute(DURABLE_ATTEMPT_NUMBER, info.attempt().longValue());
         }
-        if (info.error() != null) {
-            span.setStatus(StatusCode.ERROR, info.error().getMessage());
-            span.recordException(info.error());
-        } else if ("SUCCEEDED".equals(info.status()) || info.status() == null) {
-            // Only stamp OK on genuine success. onOperationEnd fires for every terminal status, and
-            // extractErrorFromOperation returns null for CANCELLED (always) and for FAILED/TIMED_OUT/STOPPED with no
-            // attached error object — those carry a non-null, non-SUCCEEDED status and must stay UNSET. A null status
-            // is a successful statusless virtual (FLAT CONTEXT) operation, which is OK.
-            span.setStatus(StatusCode.OK);
-        }
+        OtelPluginSupport.applyOperationStatus(span, info, info.endTimestamp());
 
         endSpan(span, info.endTimestamp());
     }
diff --git a/otel-plugin/src/main/java/software/amazon/lambda/durable/otel/InvocationOtelPlugin.java b/otel-plugin/src/main/java/software/amazon/lambda/durable/otel/InvocationOtelPlugin.java
index 8be19218b..7f614e7c8 100644
--- a/otel-plugin/src/main/java/software/amazon/lambda/durable/otel/InvocationOtelPlugin.java
+++ b/otel-plugin/src/main/java/software/amazon/lambda/durable/otel/InvocationOtelPlugin.java
@@ -229,8 +229,8 @@ public void onInvocationStart(InvocationInfo info) {
                 canonicalTraceId,
                 workflowSpanName,
                 Attributes.of(DURABLE_EXECUTION_ARN, info.durableExecutionArn()));
-        // A null decision is unresolved on the agent path: defer to DurableSampler's own delegate (keyed by trace ID),
-        // rather than fabricating a decision that would bypass an installed drop/rate-limit policy.
+        // An unresolved decision is supplied by the actual fallback root or the agent-side sampler. Do not invent
+        // a decision that bypasses an installed drop/rate-limit policy.
         samplingIntent = decision != null
                 ? DurableSamplingDecision.Intent.resolved(decision)
                 : DurableSamplingDecision.Intent.deferred(canonicalTraceId);
@@ -254,8 +254,10 @@ public void onInvocationStart(InvocationInfo info) {
             // Retain the ended root as a flush marker even if an onEnd processor throws during Start.
             executionRootSpan = root;
         }
-        // A visible plain replacement keeps its documented ancestor-flag fallback, without SDK-wide overrides.
-        if (executionRootSpan != null && OtelPluginSupport.usesDurableSamplingBridge(sdkTracerProvider)) {
+        // An unresolved plain fallback uses the real root's decision; explicit/ambient decisions and the
+        // legacy remote-parent path retain their existing behavior. Plain samplers still own each child decision.
+        if (executionRootSpan != null
+                && (OtelPluginSupport.usesDurableSamplingBridge(sdkTracerProvider) || decision == null)) {
             execCtx = new ExecutionTraceContext(executionRootSpan.getSpanContext());
         }
         executionTrace = new ExecutionTrace(canonicalTraceId, execCtx.traceFlags());
@@ -459,16 +461,7 @@ public void onOperationEnd(OperationEndInfo info) {
             if (info.attempt() != null) {
                 span.setAttribute(DURABLE_ATTEMPT_NUMBER, info.attempt().longValue());
             }
-            if (info.error() != null) {
-                span.setStatus(StatusCode.ERROR, info.error().getMessage());
-                span.recordException(info.error());
-            } else if ("SUCCEEDED".equals(info.status()) || info.status() == null) {
-                // Only stamp OK on genuine success. onOperationEnd fires for every terminal status, and
-                // extractErrorFromOperation returns null for CANCELLED (always) and for FAILED/TIMED_OUT/STOPPED
-                // with no attached error object — those carry a non-null, non-SUCCEEDED status and must stay UNSET.
-                // A null status is a successful statusless virtual (FLAT CONTEXT) operation, which is OK.
-                span.setStatus(StatusCode.OK);
-            }
+            OtelPluginSupport.applyOperationStatus(span, info);
             span.end();
         } else {
             var parentContext = resolveParentContext(info.parentId());
@@ -499,14 +492,7 @@ public void onOperationEnd(OperationEndInfo info) {
                 continuationSpan.setAttribute(
                         DURABLE_ATTEMPT_NUMBER, info.attempt().longValue());
             }
-            if (info.error() != null) {
-                continuationSpan.setStatus(StatusCode.ERROR, info.error().getMessage());
-                continuationSpan.recordException(info.error());
-            } else if ("SUCCEEDED".equals(info.status()) || info.status() == null) {
-                // See onOperationEnd (this-invocation branch): only genuine success (or a successful statusless
-                // virtual operation) is OK; error-less non-success statuses stay UNSET.
-                continuationSpan.setStatus(StatusCode.OK);
-            }
+            OtelPluginSupport.applyOperationStatus(continuationSpan, info);
 
             continuationSpan.end();
         }
diff --git a/otel-plugin/src/main/java/software/amazon/lambda/durable/otel/OtelPluginSupport.java b/otel-plugin/src/main/java/software/amazon/lambda/durable/otel/OtelPluginSupport.java
index 0c011218b..a2f3bd7f3 100644
--- a/otel-plugin/src/main/java/software/amazon/lambda/durable/otel/OtelPluginSupport.java
+++ b/otel-plugin/src/main/java/software/amazon/lambda/durable/otel/OtelPluginSupport.java
@@ -6,18 +6,24 @@
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.Span;
 import io.opentelemetry.api.trace.SpanKind;
+import io.opentelemetry.api.trace.StatusCode;
 import io.opentelemetry.api.trace.Tracer;
 import io.opentelemetry.api.trace.TracerProvider;
 import io.opentelemetry.context.Context;
 import io.opentelemetry.context.Scope;
 import io.opentelemetry.sdk.trace.SdkTracerProvider;
 import io.opentelemetry.sdk.trace.samplers.SamplingResult;
+import java.io.PrintWriter;
+import java.io.StringWriter;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.time.Instant;
 import java.util.Collections;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import software.amazon.lambda.durable.exception.DurableOperationException;
 import software.amazon.lambda.durable.execution.DurableExecutor;
+import software.amazon.lambda.durable.plugin.OperationEndInfo;
 
 /** Shared provider setup, sampling resolution, and invocation cleanup support. */
 final class OtelPluginSupport {
@@ -86,6 +92,67 @@ static boolean usesLocalDurableSampler(SdkTracerProvider provider) {
         return provider != null && provider.getSampler() instanceof DurableSampler;
     }
 
+    /** Terminal backend status and exception details are independent telemetry signals. */
+    static void applyOperationStatus(Span span, OperationEndInfo info) {
+        applyOperationStatus(span, info, null);
+    }
+
+    static void applyOperationStatus(Span span, OperationEndInfo info, Instant endTimestamp) {
+        if (hasOperationErrorDetails(info.error())) {
+            span.setStatus(StatusCode.ERROR, info.error().getMessage());
+            if (endTimestamp == null || endTimestamp.equals(Instant.EPOCH)) {
+                // The SDK treats epoch zero as its current-clock sentinel when ending a span.
+                span.recordException(info.error());
+            } else {
+                recordExceptionAt(span, info.error(), endTimestamp);
+            }
+        } else if (info.error() != null
+                || "FAILED".equals(info.status())
+                || "TIMED_OUT".equals(info.status())
+                || "STOPPED".equals(info.status())) {
+            span.setStatus(StatusCode.ERROR);
+        } else if (info.error() == null && ("SUCCEEDED".equals(info.status()) || info.status() == null)) {
+            // Retain successful statusless virtual operations; unrelated cancellation/nonterminal statuses stay UNSET.
+            span.setStatus(StatusCode.OK);
+        }
+    }
+
+    /** Timestamped public exception event; the provider applies its event attribute limits. */
+    private static void recordExceptionAt(Span span, Throwable error, Instant timestamp) {
+        if (!span.isRecording()) return;
+        var attributes = Attributes.builder();
+        var type = error.getClass().getCanonicalName();
+        if (type != null) attributes.put("exception.type", type);
+        var message = error.getMessage();
+        if (message != null) attributes.put("exception.message", message);
+        var stacktrace = new StringWriter();
+        try (var writer = new PrintWriter(stacktrace)) {
+            error.printStackTrace(writer);
+        }
+        attributes.put("exception.stacktrace", stacktrace.toString());
+        span.addEvent("exception", attributes.build(), timestamp);
+    }
+
+    /** Distinguishes operation telemetry details without changing the SDK's failure notification object. */
+    static boolean hasOperationErrorDetails(Throwable error) {
+        if (error == null) return false;
+        if (error instanceof DurableOperationException failure) {
+            var details = failure.getErrorObject();
+            if (details != null) {
+                return details.errorType() != null
+                        || details.errorMessage() != null
+                        || details.errorData() != null
+                        || details.hasStackTrace()
+                        || error.getMessage() != null
+                        || error.getCause() != null
+                        || error.getSuppressed().length > 0
+                        || error.getStackTrace().length > 0;
+            }
+        }
+        // Preserve ordinary/custom Throwable behavior, including wrappers without an ErrorObject.
+        return true;
+    }
+
     /** Creates a new DeterministicIdGenerator for the application-side state bridge. */
     static DeterministicIdGenerator createDefaultIdGenerator() {
         return new DeterministicIdGenerator();
@@ -137,8 +204,8 @@ static DeterministicIdGenerator createDefaultIdGenerator() {
      * @param canonicalTraceId the canonical execution trace ID (used for the ambient same-trace check and the sampler)
      * @param spanName the span name passed to the sampler
      * @param attributes the attributes the span is started with
-     * @return the resolved {@link SamplingResult}, or {@code null} when the decision is deferred to the agent-side
-     *     {@link DurableSampler}'s own delegate
+     * @return the resolved {@link SamplingResult}, or {@code null} when the first fallback root resolves a visible
+     *     replacement's policy or the agent-side {@link DurableSampler} resolves its own delegate
      */
     static SamplingResult resolveSamplingResult(
             SdkTracerProvider sdkTracerProvider,
@@ -172,8 +239,13 @@ static SamplingResult resolveSamplingResult(
         // 3. Resolve a local durable sampler's full result, or a visible replacement's root policy for ancestor flags.
         // A foreign DurableSampler still resolves in its own loader to retain full attributes and trace state.
         // A plain replacement receives no carrier; the provider keeps its normal per-span sampling behavior.
+        // A visible plain sampler resolves a fallback ancestor through its actual root span below. Probing it
+        // first would consume a stateful policy before any span exists. Preserve the legacy remote-parent path.
         if (sdkTracerProvider != null
-                && (usesLocalDurableSampler(sdkTracerProvider) || !usesDurableSamplingBridge(sdkTracerProvider))) {
+                && (usesLocalDurableSampler(sdkTracerProvider)
+                        || (!usesDurableSamplingBridge(sdkTracerProvider)
+                                && extracted != null
+                                && extracted.hasCompleteRemoteParent()))) {
             return sdkTracerProvider
                     .getSampler()
                     .shouldSample(
@@ -184,7 +256,8 @@ static SamplingResult resolveSamplingResult(
                             attributes,
                             Collections.emptyList());
         }
-        // 4. Agent path (provider not visible from the application class loader): defer. The agent's effective sampler
+        // 4. A plain fallback root, or an agent provider not visible from this loader, resolves at span creation. The
+        // agent's effective sampler
         // is whatever the autoconfiguration pipeline finally installs — a recognized configured sampler can be wrapped
         // or replaced by another extension's customizer, so it cannot be reliably reconstructed from environment
         // settings here. Return null so the agent-installed DurableSampler consults its actual delegate once per
diff --git a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/BackendOperationTimingTest.java b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/BackendOperationTimingTest.java
new file mode 100644
index 000000000..5c91d0413
--- /dev/null
+++ b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/BackendOperationTimingTest.java
@@ -0,0 +1,186 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.otel;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static software.amazon.lambda.durable.otel.SpanAttributes.DURABLE_OPERATION_NAME;
+
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.trace.StatusCode;
+import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
+import java.time.Instant;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Timeout;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import software.amazon.awssdk.services.lambda.model.*;
+import software.amazon.lambda.durable.DurableConfig;
+import software.amazon.lambda.durable.TypeToken;
+import software.amazon.lambda.durable.client.DurableExecutionClient;
+import software.amazon.lambda.durable.exception.DurableOperationException;
+import software.amazon.lambda.durable.execution.DurableExecutor;
+import software.amazon.lambda.durable.execution.OperationIdGenerator;
+import software.amazon.lambda.durable.model.DurableExecutionInput;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.plugin.DurableExecutionPlugin;
+import software.amazon.lambda.durable.plugin.OperationEndInfo;
+
+@Timeout(15)
+class BackendOperationTimingTest {
+    private static final String NAME = "backend-timed-callback";
+    private static final Instant END = Instant.ofEpochSecond(20);
+
+    static Stream<Arguments> paths() {
+        return Stream.of(false, true)
+                .flatMap(execution ->
+                        Stream.of("live", "continuation", "missing-start").map(path -> Arguments.of(execution, path)));
+    }
+
+    @ParameterizedTest
+    @MethodSource("paths")
+    void publicHandlerUsesBackendEndAndCompletedReplaySkipsHooks(boolean executionView, String path) {
+        boolean live = path.equals("live");
+        var details = ErrorObject.builder()
+                .errorType("ExternalFailure")
+                .errorMessage("backend failure")
+                .build();
+        var callback = Operation.builder()
+                .id(OperationIdGenerator.hashOperationId("1"))
+                .name(NAME)
+                .type(OperationType.CALLBACK)
+                .subType("Callback")
+                .status(OperationStatus.FAILED)
+                .startTimestamp(path.equals("missing-start") ? null : Instant.ofEpochSecond(10))
+                .endTimestamp(END)
+                .callbackDetails(CallbackDetails.builder()
+                        .callbackId("callback-id")
+                        .error(details)
+                        .build())
+                .build();
+        var execution = Operation.builder()
+                .id("execution")
+                .type(OperationType.EXECUTION)
+                .status(OperationStatus.STARTED)
+                .startTimestamp(Instant.ofEpochSecond(1))
+                .executionDetails(
+                        ExecutionDetails.builder().inputPayload("\"input\"").build())
+                .build();
+        var calls = new AtomicInteger();
+        var client = new DurableExecutionClient() {
+            public CheckpointDurableExecutionResponse checkpoint(
+                    String arn, String token, List<OperationUpdate> updates) {
+                calls.incrementAndGet();
+                assertEquals(1, updates.size());
+                assertEquals(callback.id(), updates.get(0).id());
+                assertEquals(OperationAction.START, updates.get(0).action());
+                return CheckpointDurableExecutionResponse.builder()
+                        .checkpointToken("next")
+                        .newExecutionState(CheckpointUpdatedExecutionState.builder()
+                                .operations(callback)
+                                .build())
+                        .build();
+            }
+
+            public GetDurableExecutionStateResponse getExecutionState(String arn, String token, String marker) {
+                fail("complete unpaginated state must not require another backend read");
+                return null;
+            }
+        };
+        try (var exporter = InMemorySpanExporter.create()) {
+            var builder = SdkTracerProvider.builder().addSpanProcessor(SimpleSpanProcessor.create(exporter));
+            var settings = OtelPluginConfig.builder()
+                    .enableMdc(false)
+                    .contextExtractor(() -> null)
+                    .build();
+            DurableExecutionPlugin otel = executionView
+                    ? new ExecutionOtelPlugin(builder, settings)
+                    : new InvocationOtelPlugin(builder, settings);
+            var ends = new CopyOnWriteArrayList<OperationEndInfo>();
+            var observer = new DurableExecutionPlugin() {
+                public void onOperationEnd(OperationEndInfo info) {
+                    if (NAME.equals(info.name())) ends.add(info);
+                }
+            };
+            var caught = new AtomicInteger();
+            var config = DurableConfig.builder()
+                    .withDurableExecutionClient(client)
+                    .withPlugins(otel, observer)
+                    .build();
+            for (int invocation = 0; invocation < 2; invocation++) {
+                var firstLive = live && invocation == 0;
+                var input = new DurableExecutionInput(
+                        "arn:timing/execution",
+                        "token",
+                        CheckpointUpdatedExecutionState.builder()
+                                .operations(firstLive ? List.of(execution) : List.of(execution, callback))
+                                .build(),
+                        !live && invocation == 0 ? List.of(callback.id()) : List.of());
+                var result = DurableExecutor.execute(
+                        input,
+                        null,
+                        TypeToken.get(String.class),
+                        (value, context) -> {
+                            try {
+                                context.createCallback(NAME, String.class).get();
+                                fail("backend failure must still reach the handler");
+                            } catch (DurableOperationException failure) {
+                                assertEquals(details, failure.getErrorObject());
+                                caught.incrementAndGet();
+                            }
+                            return "handled";
+                        },
+                        config);
+                assertEquals(ExecutionStatus.SUCCEEDED, result.status());
+                assertEquals("\"handled\"", result.result());
+                assertNull(result.error());
+            }
+            assertEquals(2, caught.get());
+            assertEquals(live ? 1 : 0, calls.get());
+            assertEquals(1, ends.size(), "completed replay must not re-emit the terminal hook");
+            assertEquals(END, ends.get(0).endTimestamp());
+            assertEquals(!live, ends.get(0).isReplay());
+            var spans = exporter.getFinishedSpanItems().stream()
+                    .filter(s -> NAME.equals(s.getAttributes().get(DURABLE_OPERATION_NAME)))
+                    .toList();
+            assertEquals(1, spans.size());
+            var span = spans.get(0);
+            assertEquals(StatusCode.ERROR, span.getStatus().getStatusCode());
+            assertEquals(1, span.getEvents().size());
+            var diagnostic = span.getEvents().get(0);
+            var failure = ends.get(0).error();
+            assertEquals(
+                    failure.getClass().getCanonicalName(),
+                    diagnostic.getAttributes().get(AttributeKey.stringKey("exception.type")));
+            assertEquals(
+                    failure.getMessage(), diagnostic.getAttributes().get(AttributeKey.stringKey("exception.message")));
+            assertTrue(diagnostic
+                    .getAttributes()
+                    .get(AttributeKey.stringKey("exception.stacktrace"))
+                    .contains("backend failure"));
+            long event = diagnostic.getEpochNanos();
+            System.out.printf(
+                    "PUBLIC_BACKEND_TIME execution=%s path=%s backendEnd=%s start=%s end=%s event=%s caught=%s hooks=%s calls=%s%n",
+                    executionView,
+                    path,
+                    END,
+                    span.getStartEpochNanos(),
+                    span.getEndEpochNanos(),
+                    event,
+                    caught,
+                    ends.size(),
+                    calls);
+            if (executionView) {
+                assertEquals(20_000_000_000L, span.getEndEpochNanos());
+                assertEquals(
+                        path.equals("missing-start") ? 20_000_000_000L : 10_000_000_000L, span.getStartEpochNanos());
+                assertEquals(span.getEndEpochNanos(), event, "exception must use the same backend end");
+            } else assertTrue(span.getStartEpochNanos() <= event && event <= span.getEndEpochNanos());
+        }
+    }
+}
diff --git a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/CallbackErrorMetadataTest.java b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/CallbackErrorMetadataTest.java
new file mode 100644
index 000000000..b79d439ed
--- /dev/null
+++ b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/CallbackErrorMetadataTest.java
@@ -0,0 +1,191 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.otel;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static software.amazon.lambda.durable.otel.SpanAttributes.*;
+
+import io.opentelemetry.api.trace.StatusCode;
+import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import software.amazon.awssdk.services.lambda.model.ErrorObject;
+import software.amazon.lambda.durable.DurableConfig;
+import software.amazon.lambda.durable.exception.DurableOperationException;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.plugin.DurableExecutionPlugin;
+import software.amazon.lambda.durable.plugin.InvocationEndInfo;
+import software.amazon.lambda.durable.plugin.InvocationInfo;
+import software.amazon.lambda.durable.plugin.OperationEndInfo;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class CallbackErrorMetadataTest {
+    private static final String CALLBACK = "external-failure-callback";
+
+    static Stream<Arguments> errors() {
+        return Stream.of(false, true)
+                .flatMap(executionView -> Stream.of(
+                        Arguments.of(executionView, "omitted", null, false, false),
+                        Arguments.of(
+                                executionView, "empty", ErrorObject.builder().build(), false, false),
+                        Arguments.of(executionView, "timeout", null, false, true),
+                        Arguments.of(
+                                executionView,
+                                "type",
+                                ErrorObject.builder()
+                                        .errorType("ExternalFailure")
+                                        .build(),
+                                true,
+                                false),
+                        Arguments.of(
+                                executionView,
+                                "empty-type",
+                                ErrorObject.builder().errorType("").build(),
+                                true,
+                                false),
+                        Arguments.of(
+                                executionView,
+                                "message",
+                                ErrorObject.builder()
+                                        .errorMessage("failed externally")
+                                        .build(),
+                                true,
+                                false),
+                        Arguments.of(
+                                executionView,
+                                "empty-message",
+                                ErrorObject.builder().errorMessage("").build(),
+                                true,
+                                false),
+                        Arguments.of(
+                                executionView,
+                                "data",
+                                ErrorObject.builder().errorData("{}").build(),
+                                true,
+                                false),
+                        Arguments.of(
+                                executionView,
+                                "empty-data",
+                                ErrorObject.builder().errorData("").build(),
+                                true,
+                                false),
+                        Arguments.of(
+                                executionView,
+                                "empty-stack",
+                                ErrorObject.builder().stackTrace(List.of()).build(),
+                                true,
+                                false),
+                        Arguments.of(
+                                executionView,
+                                "stack",
+                                ErrorObject.builder()
+                                        .stackTrace("example.Service|call|Service.java|1")
+                                        .build(),
+                                true,
+                                false)));
+    }
+
+    @ParameterizedTest(name = "executionView={0}, error={1}")
+    @MethodSource("errors")
+    void publicCallbackPreservesStoredFailureButReportsOnlyPresentErrorDetails(
+            boolean executionView, String label, ErrorObject error, boolean hasDetails, boolean timeout) {
+        DeterministicIdGenerator.clearSharedStateForTest();
+        DurableSamplingDecision.clearSharedStateForTest();
+        OtelPluginAutoConfigurationState.resetInstalledForTest();
+        try {
+            var exporter = InMemorySpanExporter.create();
+            var provider = SdkTracerProvider.builder().addSpanProcessor(SimpleSpanProcessor.create(exporter));
+            var options = OtelPluginConfig.builder()
+                    .contextExtractor(() -> null)
+                    .enableMdc(false)
+                    .build();
+            DurableExecutionPlugin otel = executionView
+                    ? new ExecutionOtelPlugin(provider, options)
+                    : new InvocationOtelPlugin(provider, options);
+            var starts = new CopyOnWriteArrayList<InvocationInfo>();
+            var ends = new CopyOnWriteArrayList<InvocationEndInfo>();
+            var operationEnds = new CopyOnWriteArrayList<OperationEndInfo>();
+            var observer = new DurableExecutionPlugin() {
+                @Override
+                public void onInvocationStart(InvocationInfo info) {
+                    starts.add(info);
+                }
+
+                @Override
+                public void onInvocationEnd(InvocationEndInfo info) {
+                    ends.add(info);
+                }
+
+                @Override
+                public void onOperationEnd(OperationEndInfo info) {
+                    operationEnds.add(info);
+                }
+            };
+            var submitterCalls = new AtomicInteger();
+            var runner = LocalDurableTestRunner.create(
+                    String.class,
+                    (input, context) -> context.waitForCallback(
+                            "external-failure", String.class, (callbackId, step) -> submitterCalls.incrementAndGet()),
+                    DurableConfig.builder().withPlugins(otel, observer).build());
+            assertEquals(ExecutionStatus.PENDING, runner.run("input").getStatus());
+            var callbackId = runner.getCallbackId(CALLBACK);
+            if (timeout) runner.timeoutCallback(callbackId);
+            else runner.failCallback(callbackId, error);
+
+            var result = runner.run("input");
+            assertEquals(ExecutionStatus.FAILED, result.getStatus());
+            var stored = result.getOperation(CALLBACK);
+            var terminal = timeout ? "TIMED_OUT" : "FAILED";
+            assertEquals(terminal, stored.getStatus().toString());
+            assertEquals(error, stored.getCallbackDetails().error(), "raw checkpoint error must not be normalized");
+            assertEquals(error, result.getError().orElse(null), "caller failure payload must remain unchanged");
+            var callerError = assertInstanceOf(
+                    DurableOperationException.class, ends.get(1).executionError());
+            assertEquals(
+                    timeout ? "CallbackTimeoutException" : "CallbackFailedException",
+                    callerError.getClass().getSimpleName());
+            assertEquals(error, callerError.getErrorObject());
+            assertEquals(
+                    error != null,
+                    starts.get(1).operations().get(stored.getId()).error() != null);
+            assertEquals(
+                    error != null,
+                    starts.get(1).updatedOperations().get(stored.getId()).error() != null);
+            assertEquals(
+                    error != null, ends.get(1).operations().get(stored.getId()).error() != null);
+            var callbackEnds = operationEnds.stream()
+                    .filter(info -> CALLBACK.equals(info.name()))
+                    .toList();
+            assertEquals(1, callbackEnds.size());
+            assertEquals(terminal, callbackEnds.get(0).status());
+            assertEquals(error != null, callbackEnds.get(0).error() != null);
+            var terminalSpans = exporter.getFinishedSpanItems().stream()
+                    .filter(span -> CALLBACK.equals(span.getAttributes().get(DURABLE_OPERATION_NAME)))
+                    .filter(span -> terminal.equals(span.getAttributes().get(DURABLE_OPERATION_STATUS)))
+                    .toList();
+            assertEquals(1, terminalSpans.size());
+            assertEquals(StatusCode.ERROR, terminalSpans.get(0).getStatus().getStatusCode());
+            assertEquals(hasDetails ? 1 : 0, terminalSpans.get(0).getEvents().size());
+            var replay = runner.run("input");
+            assertEquals(ExecutionStatus.FAILED, replay.getStatus());
+            assertEquals(result.getError(), replay.getError());
+            assertEquals(1, submitterCalls.get(), "completed submitter body must not repeat");
+            assertEquals(
+                    1,
+                    operationEnds.stream()
+                            .filter(info -> CALLBACK.equals(info.name()))
+                            .count());
+        } finally {
+            DeterministicIdGenerator.clearSharedStateForTest();
+            DurableSamplingDecision.clearSharedStateForTest();
+            OtelPluginAutoConfigurationState.resetInstalledForTest();
+        }
+    }
+}
diff --git a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/CaughtCallbackFailureStatusTest.java b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/CaughtCallbackFailureStatusTest.java
new file mode 100644
index 000000000..ffdf7c98d
--- /dev/null
+++ b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/CaughtCallbackFailureStatusTest.java
@@ -0,0 +1,153 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.otel;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static software.amazon.lambda.durable.otel.SpanAttributes.*;
+
+import io.opentelemetry.api.trace.StatusCode;
+import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import io.opentelemetry.sdk.trace.data.SpanData;
+import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
+import java.time.Duration;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Timeout;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import software.amazon.awssdk.services.lambda.model.ErrorObject;
+import software.amazon.lambda.durable.DurableConfig;
+import software.amazon.lambda.durable.DurableContext;
+import software.amazon.lambda.durable.exception.DurableOperationException;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.plugin.DurableExecutionPlugin;
+import software.amazon.lambda.durable.plugin.OperationEndInfo;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+@Timeout(15)
+class CaughtCallbackFailureStatusTest {
+    private static final String NAME = "caught-failure-callback";
+
+    static Stream<Arguments> cases() {
+        return Stream.of(false, true)
+                .flatMap(execution -> Stream.of(false, true)
+                        .flatMap(live -> Stream.of("omitted", "empty", "timeout", "rich")
+                                .map(kind -> Arguments.of(execution, live, kind))));
+    }
+
+    @ParameterizedTest
+    @MethodSource("cases")
+    void caughtCallbackFailureIsErrorWhileHandlerSucceedsAndReplaySkipsSavedEffects(
+            boolean executionView, boolean live, String kind) {
+        ErrorObject details = kind.equals("empty")
+                ? ErrorObject.builder().build()
+                : kind.equals("rich")
+                        ? ErrorObject.builder()
+                                .errorType("ExternalFailure")
+                                .errorMessage("backend failure")
+                                .build()
+                        : null;
+        var status = kind.equals("timeout") ? "TIMED_OUT" : "FAILED";
+        try (var exporter = InMemorySpanExporter.create()) {
+            var builder = SdkTracerProvider.builder().addSpanProcessor(SimpleSpanProcessor.create(exporter));
+            var settings = OtelPluginConfig.builder()
+                    .enableMdc(false)
+                    .contextExtractor(() -> null)
+                    .build();
+            DurableExecutionPlugin otel = executionView
+                    ? new ExecutionOtelPlugin(builder, settings)
+                    : new InvocationOtelPlugin(builder, settings);
+            var ends = new CopyOnWriteArrayList<OperationEndInfo>();
+            var observer = new DurableExecutionPlugin() {
+                @Override
+                public void onOperationEnd(OperationEndInfo info) {
+                    if (NAME.equals(info.name())) ends.add(info);
+                }
+            };
+            var runnerRef = new AtomicReference<LocalDurableTestRunner<String, String>>();
+            var submitted = new AtomicInteger();
+            var saved = new AtomicInteger();
+            var caught = new CopyOnWriteArrayList<DurableOperationException>();
+            var runner = LocalDurableTestRunner.create(
+                    String.class,
+                    (String input, DurableContext context) -> {
+                        try {
+                            context.waitForCallback("caught-failure", String.class, (callbackId, step) -> {
+                                submitted.incrementAndGet();
+                                if (live) finish(runnerRef.get(), callbackId, kind, details);
+                            });
+                            fail("failed callback must still throw into the handler");
+                        } catch (DurableOperationException failure) {
+                            caught.add(failure);
+                        }
+                        context.step("saved-effect", String.class, step -> {
+                            saved.incrementAndGet();
+                            return "saved";
+                        });
+                        context.wait("resume-once", Duration.ofSeconds(1));
+                        return "handled";
+                    },
+                    DurableConfig.builder().withPlugins(otel, observer).build());
+            runnerRef.set(runner);
+            assertEquals(ExecutionStatus.PENDING, runner.run("input").getStatus());
+            if (!live) {
+                assertTrue(caught.isEmpty());
+                finish(runner, runner.getCallbackId(NAME), kind, details);
+                assertEquals(ExecutionStatus.PENDING, runner.run("input").getStatus());
+            }
+            assertEquals(1, caught.size());
+            assertEquals(1, ends.size());
+            assertEquals(status, ends.get(0).status());
+            assertEquals(details != null, ends.get(0).error() != null);
+            var firstTerminal = terminal(exporter, status);
+            assertEquals(1, firstTerminal.size());
+            assertEquals(StatusCode.ERROR, firstTerminal.get(0).getStatus().getStatusCode());
+            if (kind.equals("rich")) {
+                var span = firstTerminal.get(0);
+                assertEquals(1, span.getEvents().size());
+                var eventTime = span.getEvents().get(0).getEpochNanos();
+                var backendEnd = ends.get(0).endTimestamp();
+                System.out.printf(
+                        "PUBLIC_OPERATION_TIME execution=%s live=%s backendEnd=%s start=%s end=%s event=%s%n",
+                        executionView, live, backendEnd, span.getStartEpochNanos(), span.getEndEpochNanos(), eventTime);
+                if (executionView && backendEnd != null) assertEquals(span.getEndEpochNanos(), eventTime);
+                else assertTrue(eventTime >= span.getStartEpochNanos() && eventTime <= span.getEndEpochNanos());
+            } else assertTrue(firstTerminal.get(0).getEvents().isEmpty());
+            runner.advanceTime();
+            var result = runner.runUntilComplete("input");
+            assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+            assertEquals("handled", result.getResult(String.class));
+            assertEquals(details, result.getOperation(NAME).getCallbackDetails().error());
+            assertTrue(result.getError().isEmpty(), "caught operation failure is not handler failure");
+            assertEquals(2, caught.size());
+            caught.forEach(failure -> assertEquals(details, failure.getErrorObject()));
+            assertEquals(1, submitted.get());
+            assertEquals(1, saved.get());
+            assertEquals(1, ends.size());
+            assertEquals(1, terminal(exporter, status).size(), "completed callback end is not emitted twice");
+            var workflow = exporter.getFinishedSpanItems().stream()
+                    .filter(s -> s.getName().equals("Workflow"))
+                    .toList();
+            assertEquals(1, workflow.size());
+            assertEquals(StatusCode.OK, workflow.get(0).getStatus().getStatusCode());
+        }
+    }
+
+    private static void finish(
+            LocalDurableTestRunner<String, String> runner, String id, String kind, ErrorObject details) {
+        if (kind.equals("timeout")) runner.timeoutCallback(id);
+        else runner.failCallback(id, details);
+    }
+
+    private static List<SpanData> terminal(InMemorySpanExporter exporter, String status) {
+        return exporter.getFinishedSpanItems().stream()
+                .filter(s -> NAME.equals(s.getAttributes().get(DURABLE_OPERATION_NAME)))
+                .filter(s -> status.equals(s.getAttributes().get(DURABLE_OPERATION_STATUS)))
+                .toList();
+    }
+}
diff --git a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/CaughtFailureConformanceHandlerTest.java b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/CaughtFailureConformanceHandlerTest.java
new file mode 100644
index 000000000..cfbc85c2e
--- /dev/null
+++ b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/CaughtFailureConformanceHandlerTest.java
@@ -0,0 +1,638 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.otel;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static software.amazon.lambda.durable.otel.SpanAttributes.*;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.trace.StatusCode;
+import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import io.opentelemetry.sdk.trace.data.SpanData;
+import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Stream;
+import javax.tools.ToolProvider;
+import org.junit.jupiter.api.Timeout;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import software.amazon.awssdk.core.SdkPojo;
+import software.amazon.awssdk.services.lambda.model.CheckpointUpdatedExecutionState;
+import software.amazon.awssdk.services.lambda.model.ErrorObject;
+import software.amazon.awssdk.services.lambda.model.ExecutionDetails;
+import software.amazon.awssdk.services.lambda.model.Operation;
+import software.amazon.awssdk.services.lambda.model.OperationStatus;
+import software.amazon.awssdk.services.lambda.model.OperationType;
+import software.amazon.lambda.durable.DurableConfig;
+import software.amazon.lambda.durable.DurableHandler;
+import software.amazon.lambda.durable.TypeToken;
+import software.amazon.lambda.durable.exception.CallbackFailedException;
+import software.amazon.lambda.durable.execution.DurableExecutor;
+import software.amazon.lambda.durable.model.DurableExecutionInput;
+import software.amazon.lambda.durable.model.DurableExecutionOutput;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.plugin.*;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+import software.amazon.lambda.durable.testing.TestOperation;
+import software.amazon.lambda.durable.testing.TestResult;
+import software.amazon.lambda.durable.testing.local.LocalMemoryExecutionClient;
+import software.amazon.lambda.durable.testing.local.OperationResult;
+
+@Timeout(20)
+class CaughtFailureConformanceHandlerTest {
+    private static final String FAILED = "otel-failed-callback";
+    private static final String LEAF = FAILED + "-callback";
+    private static final String MARKER = FAILED + "-observed";
+    private static final String ONE = FAILED + "-barrier-one";
+    private static final String TWO = FAILED + "-barrier-two";
+    private static final String CASE25 = "Otel25CaughtCallbackFailureReplay";
+    private static final Map<String, Object> INPUT = Map.of("scenario", "caught-callback-failure-replay");
+
+    @TempDir
+    Path directory;
+
+    static Stream<Arguments> viewsAndErrors() {
+        return Stream.of(false, true).flatMap(view -> Stream.of(false, true).map(empty -> Arguments.of(view, empty)));
+    }
+
+    @ParameterizedTest
+    @MethodSource("viewsAndErrors")
+    void actualCase25CatchesFirstFailureAndTwoCachedReplays(boolean executionView, boolean emptyContainer)
+            throws Exception {
+        try (var fixture = fixture(executionView, CASE25)) {
+            var error = emptyContainer ? ErrorObject.builder().build() : null;
+            var first = fixture.run(INPUT);
+            assertEquals(ExecutionStatus.PENDING, first.getStatus());
+            var failedId = first.getOperation(LEAF).getId();
+            var contextId = first.getOperation(FAILED).getId();
+            assertTrue(fixture.terminal(LEAF, "FAILED").isEmpty());
+            assertEquals(0, fixture.bodies(MARKER));
+            fixture.runner.failCallback(fixture.runner.getCallbackId(LEAF), error);
+
+            var second = fixture.run(INPUT);
+            assertEquals(ExecutionStatus.PENDING, second.getStatus());
+            assertEquals(1, fixture.terminal(LEAF, "FAILED").size(), "publish first terminal failure in invocation2");
+            assertEquals(1, fixture.bodies(MARKER));
+            assertEquals("caught", second.getOperation(MARKER).getStepResult(String.class));
+            var leaf = fixture.terminal(LEAF, "FAILED").get(0);
+            assertEquals(StatusCode.ERROR, leaf.getStatus().getStatusCode());
+            assertTrue(leaf.getEvents().isEmpty(), "omitted/empty backend details must not invent an exception event");
+            assertEquals(failedId, leaf.getAttributes().get(DURABLE_OPERATION_ID));
+            assertEquals("Callback", leaf.getAttributes().get(DURABLE_OPERATION_SUBTYPE));
+            var marker = fixture.exporter.getFinishedSpanItems().stream()
+                    .filter(span -> (MARKER + " attempt 1").equals(span.getName()))
+                    .findFirst()
+                    .orElseThrow();
+            assertTrue(leaf.getEndEpochNanos() <= marker.getStartEpochNanos());
+            fixture.runner.completeCallback(fixture.runner.getCallbackId(ONE + "-callback"), "\"one\"");
+
+            var third = fixture.run(INPUT);
+            assertEquals(ExecutionStatus.PENDING, third.getStatus());
+            assertEquals(failedId, third.getOperation(LEAF).getId());
+            assertEquals(1, fixture.terminal(LEAF, "FAILED").size());
+            assertEquals(1, fixture.bodies(MARKER));
+            fixture.runner.completeCallback(fixture.runner.getCallbackId(TWO + "-callback"), "\"two\"");
+            var fourth = fixture.run(INPUT);
+            fixture.writeEvidence(
+                    (executionView ? "execution" : "invocation") + (emptyContainer ? "-empty" : "-omitted"));
+            assertEquals(ExecutionStatus.SUCCEEDED, fourth.getStatus());
+            assertEquals("caught/one/two", fourth.getResult(String.class));
+            assertTrue(fourth.getError().isEmpty());
+            assertEquals(error, fourth.getOperation(LEAF).getCallbackDetails().error());
+            assertEquals(failedId, fourth.getOperation(LEAF).getId());
+            assertEquals(contextId, fourth.getOperation(FAILED).getId());
+            assertEquals(1, fixture.bodies(MARKER));
+            for (var name : List.of(FAILED, ONE, TWO)) assertEquals(1, fixture.bodies(name + "-submitter"));
+            assertEquals(1, fixture.terminal(LEAF, "FAILED").size(), "raw exports must retain duplicates if present");
+            assertEquals(1, fixture.terminal(ONE + "-callback", "SUCCEEDED").size());
+            assertEquals(1, fixture.terminal(TWO + "-callback", "SUCCEEDED").size());
+            assertEquals(
+                    List.of(
+                            InvocationStatus.PENDING,
+                            InvocationStatus.PENDING,
+                            InvocationStatus.PENDING,
+                            InvocationStatus.SUCCEEDED),
+                    fixture.ends.stream()
+                            .map(InvocationEndInfo::invocationStatus)
+                            .toList());
+            assertEquals(
+                    List.of(true, false, false, false),
+                    fixture.starts.stream()
+                            .map(InvocationInfo::isFirstInvocation)
+                            .toList());
+            assertEquals(List.of(CallbackFailedException.class.getName()), fixture.firstFailureTypes);
+            assertEquals(
+                    2, fixture.bodies(FAILED), "cached failed-child replay must not run its body in invocations3/4");
+            verifyTopology(fixture, executionView, leaf, contextId);
+            verifyLocalHistory(fourth);
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void actualCase25ReplaysFailedParentWhenServiceSnapshotPrunesItsChildren(boolean executionView) throws Exception {
+        try (var fixture = fixture(executionView, CASE25)) {
+            var backend = new LocalMemoryExecutionClient();
+            var checkpointError = ErrorObject.builder().build();
+            assertEquals(
+                    ExecutionStatus.PENDING, fixture.runServiceSnapshot(backend).status());
+            backend.completeCallback(backend.getCallbackId(LEAF), OperationResult.failed(checkpointError));
+            assertEquals(
+                    ExecutionStatus.PENDING, fixture.runServiceSnapshot(backend).status());
+            var failedParent = backend.getOperationByName(FAILED);
+            assertEquals(OperationStatus.FAILED, failedParent.status());
+            assertSame(checkpointError, failedParent.contextDetails().error());
+            assertEquals(1, fixture.terminal(LEAF, "FAILED").size());
+            var failure = fixture.terminal(LEAF, "FAILED").get(0);
+            assertEquals(StatusCode.ERROR, failure.getStatus().getStatusCode());
+            assertTrue(failure.getEvents().isEmpty());
+            assertEquals(1, fixture.bodies(MARKER));
+            backend.completeCallback(backend.getCallbackId(ONE + "-callback"), OperationResult.succeeded("\"one\""));
+
+            var third = fixture.runServiceSnapshot(backend);
+            System.out.println("PRUNED_CASE25 view=" + executionView + " third=" + third.status()
+                    + " error=" + (third.error() == null ? null : third.error().errorMessage())
+                    + " pruned=" + fixture.prunedInputs);
+            assertEquals(
+                    ExecutionStatus.PENDING, third.status(), "cached failed child must reach the documented catch");
+            backend.completeCallback(backend.getCallbackId(TWO + "-callback"), OperationResult.succeeded("\"two\""));
+            var fourth = fixture.runServiceSnapshot(backend);
+            assertEquals(ExecutionStatus.SUCCEEDED, fourth.status());
+            assertEquals("\"caught/one/two\"", fourth.result());
+            assertSame(failedParent, backend.getOperationByName(FAILED));
+            assertSame(checkpointError, failedParent.contextDetails().error());
+            assertEquals(List.of(0, 0, 2, 2), fixture.prunedInputs);
+            assertEquals(
+                    2,
+                    fixture.bodies(FAILED),
+                    "only the initial wait and first failure consumption execute the child body");
+            assertEquals(1, fixture.bodies(MARKER));
+            assertEquals(1, fixture.bodies(FAILED + "-submitter"));
+            assertEquals(1, fixture.terminal(LEAF, "FAILED").size());
+            assertEquals(
+                    1,
+                    fixture.operationEnds.stream()
+                            .filter(info -> LEAF.equals(info.name()))
+                            .count());
+            assertEquals(
+                    1,
+                    fixture.operationEnds.stream()
+                            .filter(info -> MARKER.equals(info.name()))
+                            .count());
+            assertEquals(1, fixture.terminal(ONE + "-callback", "SUCCEEDED").size());
+            assertEquals(1, fixture.terminal(TWO + "-callback", "SUCCEEDED").size());
+            verifyTopology(fixture, executionView, failure, failedParent.id());
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void unexpectedCallbackSuccessFailsBeforeMarker(boolean executionView) throws Exception {
+        try (var fixture = fixture(executionView, CASE25)) {
+            assertEquals(ExecutionStatus.PENDING, fixture.run(INPUT).getStatus());
+            fixture.runner.completeCallback(fixture.runner.getCallbackId(LEAF), "\"unexpected\"");
+            var result = fixture.run(INPUT);
+            assertEquals(ExecutionStatus.FAILED, result.getStatus());
+            assertTrue(result.getError().orElseThrow().errorMessage().contains("Expected the first callback to fail"));
+            assertNull(result.getOperation(MARKER));
+            assertEquals(0, fixture.bodies(MARKER));
+        }
+    }
+
+    static Stream<Arguments> barriers() {
+        return Stream.of(false, true).flatMap(view -> Stream.of(ONE, TWO).map(name -> Arguments.of(view, name)));
+    }
+
+    @ParameterizedTest
+    @MethodSource("barriers")
+    void barrierFailuresRemainOutsideTheExpectedFailureCatch(boolean executionView, String barrier) throws Exception {
+        try (var fixture = fixture(executionView, CASE25)) {
+            assertEquals(ExecutionStatus.PENDING, fixture.run(INPUT).getStatus());
+            fixture.runner.failCallback(fixture.runner.getCallbackId(LEAF), null);
+            assertEquals(ExecutionStatus.PENDING, fixture.run(INPUT).getStatus());
+            if (TWO.equals(barrier)) {
+                fixture.runner.completeCallback(fixture.runner.getCallbackId(ONE + "-callback"), "\"one\"");
+                assertEquals(ExecutionStatus.PENDING, fixture.run(INPUT).getStatus());
+            }
+            var error = ErrorObject.builder()
+                    .errorType("BarrierFailure")
+                    .errorMessage("must escape")
+                    .build();
+            fixture.runner.failCallback(fixture.runner.getCallbackId(barrier + "-callback"), error);
+            var result = fixture.run(INPUT);
+            assertEquals(ExecutionStatus.FAILED, result.getStatus());
+            assertEquals(error, result.getError().orElseThrow());
+            assertEquals(1, fixture.bodies(MARKER));
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void case17StillPropagatesItsSuppliedCallbackFailure(boolean executionView) throws Exception {
+        try (var fixture = fixture(executionView, "Otel17WaitForCallbackFailure")) {
+            var input = Map.<String, Object>of("scenario", "wait-for-callback-failure");
+            assertEquals(ExecutionStatus.PENDING, fixture.run(input).getStatus());
+            var error = ErrorObject.builder()
+                    .errorType("Case17Failure")
+                    .errorMessage("unhandled")
+                    .build();
+            fixture.runner.failCallback(fixture.runner.getCallbackId(LEAF), error);
+            var result = fixture.run(input);
+            assertEquals(ExecutionStatus.FAILED, result.getStatus());
+            assertEquals(error, result.getError().orElseThrow());
+            assertNull(result.getOperation(MARKER));
+            var leaf = fixture.terminal(LEAF, "FAILED").get(0);
+            assertEquals(StatusCode.ERROR, leaf.getStatus().getStatusCode());
+            assertEquals(1, leaf.getEvents().size());
+        }
+    }
+
+    private static void verifyTopology(Fixture fixture, boolean execution, SpanData leaf, String contextId) {
+        var spans = fixture.exporter.getFinishedSpanItems();
+        var invocations =
+                spans.stream().filter(s -> "Invocation".equals(s.getName())).toList();
+        assertEquals(4, invocations.size());
+        assertEquals(
+                List.of(true, false, false, false),
+                invocations.stream()
+                        .map(span -> span.getAttributes().get(DURABLE_FIRST_INVOCATION))
+                        .toList());
+        assertEquals(
+                List.of("PENDING", "PENDING", "PENDING", "SUCCEEDED"),
+                invocations.stream()
+                        .map(span -> span.getAttributes().get(DURABLE_INVOCATION_STATUS))
+                        .toList());
+        for (var span : invocations)
+            assertEquals(StatusCode.OK, span.getStatus().getStatusCode());
+        var workflow =
+                spans.stream().filter(s -> "Workflow".equals(s.getName())).toList();
+        assertEquals(1, workflow.size());
+        assertEquals(StatusCode.OK, workflow.get(0).getStatus().getStatusCode());
+        assertEquals("SUCCEEDED", workflow.get(0).getAttributes().get(DURABLE_EXECUTION_STATUS));
+        assertEquals(1, spans.stream().map(SpanData::getTraceId).distinct().count());
+        var parent = spans.stream()
+                .filter(s -> leaf.getParentSpanId().equals(s.getSpanId()))
+                .findFirst()
+                .orElseThrow();
+        assertEquals(contextId, parent.getAttributes().get(DURABLE_OPERATION_ID));
+        if (execution)
+            assertTrue(leaf.getLinks().stream()
+                    .anyMatch(link -> link.getSpanContext()
+                            .getSpanId()
+                            .equals(invocations.get(1).getSpanId())));
+        else {
+            assertEquals(invocations.get(1).getSpanId(), parent.getParentSpanId());
+            assertTrue(invocations.get(1).getStartEpochNanos() <= parent.getStartEpochNanos());
+            assertTrue(parent.getEndEpochNanos() <= invocations.get(1).getEndEpochNanos());
+        }
+    }
+
+    private static void verifyLocalHistory(TestResult<String> result) {
+        // The local runner does not synthesize execution or invocation boundary history events.
+        assertEquals(
+                List.of(
+                        "ContextStarted",
+                        "CallbackStarted",
+                        "StepStarted",
+                        "StepSucceeded",
+                        "CallbackFailed",
+                        "ContextFailed",
+                        "StepStarted",
+                        "StepSucceeded",
+                        "ContextStarted",
+                        "CallbackStarted",
+                        "StepStarted",
+                        "StepSucceeded",
+                        "CallbackSucceeded",
+                        "ContextSucceeded",
+                        "ContextStarted",
+                        "CallbackStarted",
+                        "StepStarted",
+                        "StepSucceeded",
+                        "CallbackSucceeded",
+                        "ContextSucceeded"),
+                result.getHistoryEvents().stream()
+                        .map(event -> event.eventType().toString())
+                        .toList());
+        var parents = new LinkedHashMap<String, String>();
+        parents.put(MARKER, null);
+        for (var name : List.of(FAILED, ONE, TWO)) {
+            parents.put(name, null);
+            parents.put(name + "-callback", result.getOperation(name).getId());
+            parents.put(name + "-submitter", result.getOperation(name).getId());
+        }
+        for (var event : result.getHistoryEvents()) {
+            assertEquals(result.getOperation(event.name()).getId(), event.id());
+            assertTrue(parents.containsKey(event.name()));
+            assertEquals(parents.get(event.name()), event.parentId());
+        }
+        assertEquals(
+                "\"one\"",
+                result.getOperation(ONE + "-callback").getCallbackDetails().result());
+        assertEquals(
+                "\"two\"",
+                result.getOperation(TWO + "-callback").getCallbackDetails().result());
+    }
+
+    private Fixture fixture(boolean execution, String handlerName) throws Exception {
+        DeterministicIdGenerator.clearSharedStateForTest();
+        DurableSamplingDecision.clearSharedStateForTest();
+        OtelPluginAutoConfigurationState.resetInstalledForTest();
+        return new Fixture(execution, compileHandlers(), handlerName);
+    }
+
+    private Path compileHandlers() throws Exception {
+        var root = Path.of(System.getProperty("user.dir")).toAbsolutePath();
+        while (root != null && !Files.isDirectory(root.resolve("conformance-tests-otel"))) root = root.getParent();
+        assertNotNull(root);
+        var source =
+                root.resolve("conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel");
+        var classes = Files.createDirectories(directory.resolve("classes"));
+        var compiler = ToolProvider.getSystemJavaCompiler();
+        assertNotNull(compiler);
+        assertEquals(
+                0,
+                compiler.run(
+                        null,
+                        null,
+                        null,
+                        "--release",
+                        "17",
+                        "-cp",
+                        System.getProperty("java.class.path"),
+                        "-d",
+                        classes.toString(),
+                        source.resolve("OtelConformanceHandler.java").toString(),
+                        source.resolve(CASE25 + ".java").toString(),
+                        source.resolve("Otel17WaitForCallbackFailure.java").toString()));
+        return classes;
+    }
+
+    private static final class Fixture implements AutoCloseable {
+        private final InMemorySpanExporter exporter = InMemorySpanExporter.create();
+        private final ExecutorService workers = Executors.newFixedThreadPool(4);
+        private final URLClassLoader loader;
+        private final LocalDurableTestRunner<Map<String, Object>, String> runner;
+        private final DurableHandler<Map<String, Object>, String> handler;
+        private final DurableConfig config;
+        private final List<Integer> prunedInputs = new ArrayList<>();
+        private final List<OperationEndInfo> operationEnds = new CopyOnWriteArrayList<>();
+        private final List<InvocationInfo> starts = new CopyOnWriteArrayList<>();
+        private final List<InvocationEndInfo> ends = new CopyOnWriteArrayList<>();
+        private final Map<String, AtomicInteger> bodies = new ConcurrentHashMap<>();
+        private final List<String> firstFailureTypes = new CopyOnWriteArrayList<>();
+        private final List<Map<String, Object>> phases = new ArrayList<>();
+
+        @SuppressWarnings("unchecked")
+        private Fixture(boolean execution, Path classes, String handlerName) throws Exception {
+            loader = new URLClassLoader(
+                    new URL[] {classes.toUri().toURL()}, getClass().getClassLoader());
+            var type = loader.loadClass("software.amazon.lambda.durable.conformance.otel." + handlerName);
+            handler = (DurableHandler<Map<String, Object>, String>)
+                    type.getConstructor().newInstance();
+            var provider = SdkTracerProvider.builder().addSpanProcessor(SimpleSpanProcessor.create(exporter));
+            var options = OtelPluginConfig.builder()
+                    .enableMdc(false)
+                    .contextExtractor(() -> null)
+                    .build();
+            DurableExecutionPlugin otel = execution
+                    ? new ExecutionOtelPlugin(provider, options)
+                    : new InvocationOtelPlugin(provider, options);
+            var observer = new DurableExecutionPlugin() {
+                public void onOperationEnd(OperationEndInfo info) {
+                    operationEnds.add(info);
+                }
+
+                public void onInvocationStart(InvocationInfo info) {
+                    starts.add(info);
+                }
+
+                public void onInvocationEnd(InvocationEndInfo info) {
+                    ends.add(info);
+                }
+
+                public void onUserFunctionStart(UserFunctionStartInfo info) {
+                    if (info.name() != null)
+                        bodies.computeIfAbsent(info.name(), ignored -> new AtomicInteger())
+                                .incrementAndGet();
+                }
+
+                public void onUserFunctionEnd(UserFunctionEndInfo info) {
+                    if (FAILED.equals(info.name()) && info.error() instanceof CallbackFailedException)
+                        firstFailureTypes.add(info.error().getClass().getName());
+                }
+            };
+            config = DurableConfig.builder()
+                    .withExecutorService(workers)
+                    .withPlugins(otel, observer)
+                    .build();
+            runner = LocalDurableTestRunner.create(
+                    new TypeToken<Map<String, Object>>() {}, handler::handleRequest, config);
+        }
+
+        private DurableExecutionOutput runServiceSnapshot(LocalMemoryExecutionClient backend) {
+            // Keep the backend's actual checkpoint/history intact. Only the input snapshot omits children of the
+            // completed failed parent, matching the service replay shape absent from LocalDurableTestRunner.
+            var all = backend.getAllOperations();
+            var parent = backend.getOperationByName(FAILED);
+            var visible = all.stream()
+                    .filter(operation -> parent == null
+                            || parent.status() != OperationStatus.FAILED
+                            || !parent.id().equals(operation.parentId()))
+                    .toList();
+            prunedInputs.add(all.size() - visible.size());
+            if (parent != null) assertTrue(visible.stream().anyMatch(operation -> operation == parent));
+            var execution = Operation.builder()
+                    .id("execution")
+                    .type(OperationType.EXECUTION)
+                    .status(OperationStatus.STARTED)
+                    .startTimestamp(Instant.ofEpochSecond(1))
+                    .executionDetails(ExecutionDetails.builder()
+                            .inputPayload(config.getSerDes().serialize(INPUT))
+                            .build())
+                    .build();
+            var operations = new ArrayList<>(List.of(execution));
+            operations.addAll(visible);
+            var input = new DurableExecutionInput(
+                    "arn:case25-pruned/execution",
+                    "token",
+                    CheckpointUpdatedExecutionState.builder()
+                            .operations(operations)
+                            .build(),
+                    backend.getUpdatedOperationIdsSinceLastInvocation());
+            return DurableExecutor.execute(
+                    input,
+                    null,
+                    new TypeToken<Map<String, Object>>() {},
+                    handler::handleRequest,
+                    config.toBuilder().withDurableExecutionClient(backend).build());
+        }
+
+        private TestResult<String> run(Map<String, Object> input) {
+            var result = runner.run(input);
+            var phase = new LinkedHashMap<String, Object>();
+            phase.put("invocation", phases.size() + 1);
+            phase.put("status", result.getStatus().toString());
+            phase.put(
+                    "operations",
+                    result.getOperations().stream()
+                            .map(CaughtFailureConformanceHandlerTest::operation)
+                            .toList());
+            if (result.isSucceeded()) phase.put("result", result.getResult(String.class));
+            phase.put(
+                    "history",
+                    result.getHistoryEvents().stream()
+                            .map(CaughtFailureConformanceHandlerTest::sdkValue)
+                            .toList());
+            phase.put(
+                    "spans",
+                    exporter.getFinishedSpanItems().stream()
+                            .map(CaughtFailureConformanceHandlerTest::span)
+                            .toList());
+            phase.put("bodyCounts", bodyCounts());
+            phase.put("firstFailureTypes", List.copyOf(firstFailureTypes));
+            phases.add(phase);
+            return result;
+        }
+
+        private int bodies(String name) {
+            return bodies.getOrDefault(name, new AtomicInteger()).get();
+        }
+
+        private Map<String, Integer> bodyCounts() {
+            var counts = new LinkedHashMap<String, Integer>();
+            bodies.forEach((name, count) -> counts.put(name, count.get()));
+            return counts;
+        }
+
+        private List<SpanData> terminal(String name, String status) {
+            return exporter.getFinishedSpanItems().stream()
+                    .filter(s -> name.equals(s.getAttributes().get(DURABLE_OPERATION_NAME)))
+                    .filter(s -> "CALLBACK".equals(s.getAttributes().get(DURABLE_OPERATION_TYPE)))
+                    .filter(s -> status.equals(s.getAttributes().get(DURABLE_OPERATION_STATUS)))
+                    .toList();
+        }
+
+        private void writeEvidence(String label) throws Exception {
+            var output = System.getProperty("java769.case25EvidenceDir");
+            if (output != null) {
+                var dir = Files.createDirectories(Path.of(output));
+                new ObjectMapper()
+                        .writerWithDefaultPrettyPrinter()
+                        .writeValue(dir.resolve(label + ".json").toFile(), phases);
+            }
+            System.out.println("CASE25 " + label + " phases="
+                    + phases.stream().map(p -> p.get("status")).toList() + " bodies=" + bodyCounts() + " exportedSpans="
+                    + exporter.getFinishedSpanItems().size());
+        }
+
+        public void close() throws Exception {
+            workers.shutdownNow();
+            assertTrue(workers.awaitTermination(5, TimeUnit.SECONDS));
+            loader.close();
+            exporter.close();
+            DeterministicIdGenerator.clearSharedStateForTest();
+            DurableSamplingDecision.clearSharedStateForTest();
+            OtelPluginAutoConfigurationState.resetInstalledForTest();
+        }
+    }
+
+    private static Map<String, Object> operation(TestOperation operation) {
+        var out = new LinkedHashMap<String, Object>();
+        out.put("id", operation.getId());
+        out.put("name", operation.getName());
+        out.put("type", operation.getType());
+        out.put("subType", operation.getSubtype());
+        out.put("status", operation.getStatus());
+        out.put("callbackDetails", sdkValue(operation.getCallbackDetails()));
+        out.put("contextDetails", sdkValue(operation.getContextDetails()));
+        out.put("stepDetails", sdkValue(operation.getStepDetails()));
+        return out;
+    }
+
+    private static Object sdkValue(Object value) {
+        if (value instanceof ErrorObject error) {
+            var fields = new LinkedHashMap<String, Object>();
+            if (error.errorType() != null) fields.put("ErrorType", error.errorType());
+            if (error.errorMessage() != null) fields.put("ErrorMessage", error.errorMessage());
+            if (error.errorData() != null) fields.put("ErrorData", error.errorData());
+            if (error.hasStackTrace()) fields.put("StackTrace", error.stackTrace());
+            return fields;
+        }
+        if (value instanceof SdkPojo pojo) {
+            var map = new LinkedHashMap<String, Object>();
+            for (var field : pojo.sdkFields()) {
+                var item = field.getValueOrDefault(pojo);
+                if (item != null) map.put(field.memberName(), sdkValue(item));
+            }
+            return map;
+        }
+        if (value instanceof List<?> list)
+            return list.stream()
+                    .map(CaughtFailureConformanceHandlerTest::sdkValue)
+                    .toList();
+        if (value instanceof Instant instant) return instant.toString();
+        return value;
+    }
+
+    private static Map<String, Object> attributes(Attributes attributes) {
+        var map = new LinkedHashMap<String, Object>();
+        attributes.forEach((key, value) -> map.put(key.getKey(), value));
+        return map;
+    }
+
+    private static Map<String, Object> span(SpanData span) {
+        var out = new LinkedHashMap<String, Object>();
+        out.put("name", span.getName());
+        out.put("traceId", span.getTraceId());
+        out.put("spanId", span.getSpanId());
+        out.put("parentSpanId", span.getParentSpanId());
+        out.put("startEpochNanos", span.getStartEpochNanos());
+        out.put("endEpochNanos", span.getEndEpochNanos());
+        out.put("status", span.getStatus().getStatusCode().toString());
+        out.put("description", span.getStatus().getDescription());
+        out.put("attributes", attributes(span.getAttributes()));
+        out.put(
+                "events",
+                span.getEvents().stream()
+                        .map(e -> Map.of(
+                                "name",
+                                e.getName(),
+                                "epochNanos",
+                                e.getEpochNanos(),
+                                "attributes",
+                                attributes(e.getAttributes())))
+                        .toList());
+        out.put(
+                "links",
+                span.getLinks().stream()
+                        .map(l -> Map.of(
+                                "traceId",
+                                l.getSpanContext().getTraceId(),
+                                "spanId",
+                                l.getSpanContext().getSpanId(),
+                                "attributes",
+                                attributes(l.getAttributes())))
+                        .toList());
+        return out;
+    }
+}
diff --git a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ExecutionOtelPluginTest.java b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ExecutionOtelPluginTest.java
index 9a6bded9a..95817a05e 100644
--- a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ExecutionOtelPluginTest.java
+++ b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ExecutionOtelPluginTest.java
@@ -863,9 +863,7 @@ void operationSuccess_setsOkOnOperationSpan() {
 
     @Test
     void operationEnd_withNonSuccessStatusAndNoError_leavesOperationSpanUnset() {
-        // onOperationEnd fires for every terminal status. A CANCELLED operation (or an error-less
-        // FAILED/TIMED_OUT/STOPPED) carries a non-null, non-SUCCEEDED status with a null error. It must NOT be
-        // stamped OK — the span status stays UNSET.
+        // Cancellation without diagnostic details retains UNSET; it is not blanket-classified as failure.
         plugin.onInvocationStart(new InvocationInfo("req-1", ARN, true, Instant.now()));
         plugin.onOperationStart(
                 new OperationInfo("op-cancel", "step-cancel", "STEP", "Step", null, Instant.now(), null, null, false));
@@ -889,9 +887,8 @@ void operationEnd_withNonSuccessStatusAndNoError_leavesOperationSpanUnset() {
     }
 
     @Test
-    void operationEnd_withoutStart_nonSuccessStatusAndNoError_leavesContinuationSpanUnset() {
-        // Same guard on the continuation-span branch (operation completed between invocations): an error-less
-        // TIMED_OUT terminal status must NOT be stamped OK.
+    void operationEnd_withoutStart_timeoutWithoutError_setsError() {
+        // An explicit timeout remains an error even when the backend supplied no exception details.
         plugin.onInvocationStart(new InvocationInfo("req-2", ARN, false, Instant.now()));
         plugin.onOperationEnd(new OperationEndInfo(
                 "op-cb-timeout",
@@ -909,7 +906,8 @@ void operationEnd_withoutStart_nonSuccessStatusAndNoError_leavesContinuationSpan
         plugin.onInvocationEnd(new InvocationEndInfo("req-2", ARN, false, InvocationStatus.SUCCEEDED, null));
 
         var continuationSpan = spanByName(spanExporter.getFinishedSpanItems(), "my-callback");
-        assertEquals(StatusCode.UNSET, continuationSpan.getStatus().getStatusCode());
+        assertEquals(StatusCode.ERROR, continuationSpan.getStatus().getStatusCode());
+        assertTrue(continuationSpan.getEvents().isEmpty());
     }
 
     @Test
diff --git a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ExecutionRootParityTest.java b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ExecutionRootParityTest.java
index fd4cd4be8..6a556d0c1 100644
--- a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ExecutionRootParityTest.java
+++ b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ExecutionRootParityTest.java
@@ -7,12 +7,14 @@
 import static software.amazon.lambda.durable.otel.SpanAttributes.DURABLE_EXECUTION_SYNTHETIC_ROOT;
 
 import io.opentelemetry.api.GlobalOpenTelemetry;
+import io.opentelemetry.api.OpenTelemetry;
 import io.opentelemetry.api.common.AttributeKey;
 import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.SpanKind;
 import io.opentelemetry.api.trace.TraceState;
+import io.opentelemetry.api.trace.TracerProvider;
 import io.opentelemetry.context.Context;
-import io.opentelemetry.sdk.OpenTelemetrySdk;
+import io.opentelemetry.context.propagation.ContextPropagators;
 import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter;
 import io.opentelemetry.sdk.trace.SdkTracerProvider;
 import io.opentelemetry.sdk.trace.data.LinkData;
@@ -22,6 +24,7 @@
 import io.opentelemetry.sdk.trace.samplers.SamplingDecision;
 import io.opentelemetry.sdk.trace.samplers.SamplingResult;
 import java.time.Instant;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
@@ -135,8 +138,11 @@ void plainReplacementRetainsIndependentPerSpanSampling(boolean executionView, bo
                                 : SamplingResult.drop()))
                         .addSpanProcessor(SimpleSpanProcessor.create(exporter))
                         .build()) {
-            GlobalOpenTelemetry.set(
-                    OpenTelemetrySdk.builder().setTracerProvider(provider).build());
+            GlobalOpenTelemetry.set(visibleProvider(provider));
+            assertSame(
+                    provider,
+                    OtelPluginSupport.tryResolveGlobalProvider("test", "test").sdkTracerProvider());
+            assertFalse(provider.getSampler() instanceof DurableSampler);
             DurableExecutionPlugin plugin =
                     executionView ? new ExecutionOtelPlugin(config()) : new InvocationOtelPlugin(config());
             plugin.onInvocationStart(start(true));
@@ -153,6 +159,92 @@ void plainReplacementRetainsIndependentPerSpanSampling(boolean executionView, bo
         }
     }
 
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void plainFallbackQuotaIsSpentOnlyOnActualSpanCreation(boolean executionView) {
+        GlobalOpenTelemetry.resetForTest();
+        OtelPluginAutoConfigurationState.markInstalled();
+        var calls = new ArrayList<String>();
+        try (var exporter = InMemorySpanExporter.create();
+                var provider = SdkTracerProvider.builder()
+                        .setIdGenerator(new DeterministicIdGenerator())
+                        .setSampler(sampler(name -> {
+                            calls.add(name);
+                            return calls.size() == 1 ? SamplingResult.recordAndSample() : SamplingResult.drop();
+                        }))
+                        .addSpanProcessor(SimpleSpanProcessor.create(exporter))
+                        .build()) {
+            GlobalOpenTelemetry.set(visibleProvider(provider));
+            assertSame(
+                    provider,
+                    OtelPluginSupport.tryResolveGlobalProvider("test", "test").sdkTracerProvider());
+            assertFalse(provider.getSampler() instanceof DurableSampler);
+            DurableExecutionPlugin plugin =
+                    executionView ? new ExecutionOtelPlugin(config()) : new InvocationOtelPlugin(config());
+            plugin.onInvocationStart(start(true));
+            plugin.onInvocationEnd(end(false));
+            assertEquals(List.of("DurableExecutionRoot", "Invocation", "Workflow"), calls);
+            assertEquals(
+                    1, roots(exporter).size(), "The first real span receives the sampler's one available decision");
+        } finally {
+            GlobalOpenTelemetry.resetForTest();
+            OtelPluginAutoConfigurationState.resetInstalledForTest();
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void completeRemoteParentRetainsItsLegacyAncestorPolicy(boolean executionView) {
+        GlobalOpenTelemetry.resetForTest();
+        OtelPluginAutoConfigurationState.markInstalled();
+        var calls = new ArrayList<String>();
+        var traceId = "6955b900123456789012345678901234";
+        var parentId = "1234567890123456";
+        try (var exporter = InMemorySpanExporter.create();
+                var provider = SdkTracerProvider.builder()
+                        .setIdGenerator(new DeterministicIdGenerator())
+                        .setSampler(sampler(name -> {
+                            calls.add(name);
+                            return SamplingResult.recordAndSample();
+                        }))
+                        .addSpanProcessor(SimpleSpanProcessor.create(exporter))
+                        .build()) {
+            GlobalOpenTelemetry.set(visibleProvider(provider));
+            assertSame(
+                    provider,
+                    OtelPluginSupport.tryResolveGlobalProvider("test", "test").sdkTracerProvider());
+            var config = OtelPluginConfig.builder()
+                    .enableMdc(false)
+                    .contextExtractor(() -> new ExtractedContext(traceId, parentId))
+                    .build();
+            DurableExecutionPlugin plugin =
+                    executionView ? new ExecutionOtelPlugin(config) : new InvocationOtelPlugin(config);
+            plugin.onInvocationStart(start(true));
+            plugin.onInvocationEnd(end(false));
+            assertEquals(List.of("Workflow", "Invocation", "Workflow"), calls);
+            assertTrue(roots(exporter).isEmpty(), "The complete remote parent remains externally owned");
+            var spans = exporter.getFinishedSpanItems();
+            assertEquals(2, spans.size());
+            assertTrue(spans.stream().allMatch(span -> traceId.equals(span.getTraceId())));
+            assertTrue(spans.stream().allMatch(span -> parentId.equals(span.getParentSpanId())));
+        } finally {
+            GlobalOpenTelemetry.resetForTest();
+            OtelPluginAutoConfigurationState.resetInstalledForTest();
+        }
+    }
+
+    private static OpenTelemetry visibleProvider(SdkTracerProvider provider) {
+        return new OpenTelemetry() {
+            public TracerProvider getTracerProvider() {
+                return provider;
+            }
+
+            public ContextPropagators getPropagators() {
+                return ContextPropagators.noop();
+            }
+        };
+    }
+
     private static DurableExecutionPlugin plugin(
             boolean executionView, InMemorySpanExporter exporter, Sampler sampler) {
         var builder = SdkTracerProvider.builder()
diff --git a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ExternalCompletionConformanceHandlerTest.java b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ExternalCompletionConformanceHandlerTest.java
new file mode 100644
index 000000000..f373ef3f0
--- /dev/null
+++ b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ExternalCompletionConformanceHandlerTest.java
@@ -0,0 +1,204 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.otel;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static software.amazon.lambda.durable.otel.SpanAttributes.*;
+
+import io.opentelemetry.api.trace.StatusCode;
+import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import io.opentelemetry.sdk.trace.data.SpanData;
+import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import javax.tools.ToolProvider;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import software.amazon.lambda.durable.DurableConfig;
+import software.amazon.lambda.durable.DurableHandler;
+import software.amazon.lambda.durable.TypeToken;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.plugin.DurableExecutionPlugin;
+import software.amazon.lambda.durable.plugin.InvocationEndInfo;
+import software.amazon.lambda.durable.plugin.InvocationStatus;
+import software.amazon.lambda.durable.plugin.UserFunctionEndInfo;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class ExternalCompletionConformanceHandlerTest {
+    private static final String TARGET = "otel-external-target";
+    private static final String MARKER = "otel-external-target-observed";
+
+    @TempDir
+    Path directory;
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    @SuppressWarnings("unchecked")
+    void actualHandlerExportsFirstCompletionBeforeTwoLaterReplays(boolean executionView) throws Exception {
+        DeterministicIdGenerator.clearSharedStateForTest();
+        DurableSamplingDecision.clearSharedStateForTest();
+        OtelPluginAutoConfigurationState.resetInstalledForTest();
+        var classes = compileHandler();
+        var workers = Executors.newFixedThreadPool(4);
+        try (var loader = new URLClassLoader(
+                new URL[] {classes.toUri().toURL()}, getClass().getClassLoader())) {
+            var type =
+                    loader.loadClass("software.amazon.lambda.durable.conformance.otel.Otel26ExternalCompletionReplay");
+            var handler = (DurableHandler<Map<String, Object>, String>)
+                    type.getConstructor().newInstance();
+            var exporter = InMemorySpanExporter.create();
+            var provider = SdkTracerProvider.builder().addSpanProcessor(SimpleSpanProcessor.create(exporter));
+            var options = OtelPluginConfig.builder()
+                    .contextExtractor(() -> null)
+                    .enableMdc(false)
+                    .build();
+            DurableExecutionPlugin otel = executionView
+                    ? new ExecutionOtelPlugin(provider, options)
+                    : new InvocationOtelPlugin(provider, options);
+            var ends = new CopyOnWriteArrayList<InvocationEndInfo>();
+            var markerBodies = new AtomicInteger();
+            var observer = new DurableExecutionPlugin() {
+                @Override
+                public void onInvocationEnd(InvocationEndInfo info) {
+                    ends.add(info);
+                }
+
+                @Override
+                public void onUserFunctionEnd(UserFunctionEndInfo info) {
+                    if (MARKER.equals(info.name())) markerBodies.incrementAndGet();
+                }
+            };
+            var runner = LocalDurableTestRunner.create(
+                    new TypeToken<Map<String, Object>>() {},
+                    handler::handleRequest,
+                    DurableConfig.builder()
+                            .withExecutorService(workers)
+                            .withPlugins(otel, observer)
+                            .build());
+            Map<String, Object> event = Map.of("scenario", "external-callback-completion-replay");
+            var first = runner.run(event);
+            assertEquals(ExecutionStatus.PENDING, first.getStatus());
+            var operationId = first.getOperation(TARGET).getId();
+            assertEquals(0, terminalCallbacks(exporter, TARGET).size());
+            runner.completeCallback(runner.getCallbackId(TARGET), "\"target\"");
+
+            var second = runner.run(event);
+            assertEquals(ExecutionStatus.PENDING, second.getStatus());
+            assertEquals(1, terminalCallbacks(exporter, TARGET).size(), "first external completion is exported now");
+            var terminal = terminalCallbacks(exporter, TARGET).get(0);
+            var marker = exporter.getFinishedSpanItems().stream()
+                    .filter(span -> span.getName().equals(MARKER + " attempt 1"))
+                    .findFirst()
+                    .orElseThrow();
+            assertTrue(
+                    terminal.getEndEpochNanos() <= marker.getStartEpochNanos(),
+                    "first completion precedes the checkpointed observation body");
+            assertEquals(1, markerBodies.get());
+            runner.completeCallback(runner.getCallbackId("otel-external-barrier-one-callback"), "\"one\"");
+
+            var third = runner.run(event);
+            assertEquals(ExecutionStatus.PENDING, third.getStatus());
+            assertEquals(operationId, third.getOperation(TARGET).getId());
+            assertEquals(1, terminalCallbacks(exporter, TARGET).size(), "first later replay must not re-export target");
+            runner.completeCallback(runner.getCallbackId("otel-external-barrier-two-callback"), "\"two\"");
+
+            var fourth = runner.run(event);
+            assertEquals(ExecutionStatus.SUCCEEDED, fourth.getStatus());
+            assertEquals("target/one/two", fourth.getResult(String.class));
+            assertEquals(operationId, fourth.getOperation(TARGET).getId());
+            assertEquals(1, markerBodies.get(), "the completed observation body must not run again");
+            assertEquals(
+                    1, terminalCallbacks(exporter, TARGET).size(), "second later replay must not re-export target");
+            for (var name :
+                    List.of(TARGET, "otel-external-barrier-one-callback", "otel-external-barrier-two-callback")) {
+                var spans = terminalCallbacks(exporter, name);
+                assertEquals(1, spans.size(), "raw exporter records retain duplicate exports if the SDK emits them");
+                assertEquals(StatusCode.OK, spans.get(0).getStatus().getStatusCode());
+            }
+            assertEquals(
+                    List.of(
+                            InvocationStatus.PENDING,
+                            InvocationStatus.PENDING,
+                            InvocationStatus.PENDING,
+                            InvocationStatus.SUCCEEDED),
+                    ends.stream().map(InvocationEndInfo::invocationStatus).toList());
+            var spans = exporter.getFinishedSpanItems();
+            assertEquals(1, spans.stream().map(SpanData::getTraceId).distinct().count());
+            assertEquals(
+                    4,
+                    spans.stream()
+                            .filter(span -> span.getName().equals("Invocation"))
+                            .count());
+            assertEquals(
+                    1,
+                    spans.stream()
+                            .filter(span -> span.getName().equals("Workflow"))
+                            .count());
+            assertEquals(
+                    1,
+                    spans.stream()
+                            .filter(span -> span.getName().equals(MARKER + " attempt 1"))
+                            .count());
+            // The local runner does not synthesize service InvocationCompleted history events. The four
+            // completed SDK invocations above prove local phases; shared cloud validation checks service gates.
+            System.out.println("CASE26 view=" + (executionView ? "execution" : "invocation")
+                    + " targetTerminalExports="
+                    + terminalCallbacks(exporter, TARGET).size()
+                    + " observationBodies=" + markerBodies.get() + " history="
+                    + fourth.getHistoryEvents().stream()
+                            .map(e -> e.eventId() + ":" + e.eventType())
+                            .toList());
+        } finally {
+            workers.shutdownNow();
+            assertTrue(workers.awaitTermination(5, TimeUnit.SECONDS));
+            DeterministicIdGenerator.clearSharedStateForTest();
+            DurableSamplingDecision.clearSharedStateForTest();
+            OtelPluginAutoConfigurationState.resetInstalledForTest();
+        }
+    }
+
+    private List<SpanData> terminalCallbacks(InMemorySpanExporter exporter, String name) {
+        return exporter.getFinishedSpanItems().stream()
+                .filter(span -> name.equals(span.getAttributes().get(DURABLE_OPERATION_NAME)))
+                .filter(span -> "CALLBACK".equals(span.getAttributes().get(DURABLE_OPERATION_TYPE)))
+                .filter(span -> "SUCCEEDED".equals(span.getAttributes().get(DURABLE_OPERATION_STATUS)))
+                .toList();
+    }
+
+    /** Compile the actual standalone deployment sources against this reactor, without copying their handler logic. */
+    private Path compileHandler() throws Exception {
+        var root = Path.of(System.getProperty("user.dir")).toAbsolutePath();
+        while (root != null && !Files.isDirectory(root.resolve("conformance-tests-otel"))) root = root.getParent();
+        assertNotNull(root, "repository root containing deployment handler sources");
+        var source =
+                root.resolve("conformance-tests-otel/src/main/java/software/amazon/lambda/durable/conformance/otel");
+        var classes = Files.createDirectories(directory.resolve("classes"));
+        var compiler = ToolProvider.getSystemJavaCompiler();
+        assertNotNull(compiler, "these tests require the same JDK used to compile the SDK");
+        assertEquals(
+                0,
+                compiler.run(
+                        null,
+                        null,
+                        null,
+                        "--release",
+                        "17",
+                        "-cp",
+                        System.getProperty("java.class.path"),
+                        "-d",
+                        classes.toString(),
+                        source.resolve("OtelConformanceHandler.java").toString(),
+                        source.resolve("Otel26ExternalCompletionReplay.java").toString()));
+        return classes;
+    }
+}
diff --git a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/InvocationOtelPluginTest.java b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/InvocationOtelPluginTest.java
index aad4cbe74..36ac782a8 100644
--- a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/InvocationOtelPluginTest.java
+++ b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/InvocationOtelPluginTest.java
@@ -4,6 +4,8 @@
 
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.CALLS_REAL_METHODS;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -24,9 +26,11 @@
 import io.opentelemetry.sdk.autoconfigure.spi.AutoConfigurationCustomizerProvider;
 import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
 import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter;
+import io.opentelemetry.sdk.testing.time.TestClock;
 import io.opentelemetry.sdk.trace.IdGenerator;
 import io.opentelemetry.sdk.trace.SdkTracerProvider;
 import io.opentelemetry.sdk.trace.SdkTracerProviderBuilder;
+import io.opentelemetry.sdk.trace.SpanProcessor;
 import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
 import java.time.Instant;
 import java.util.List;
@@ -780,9 +784,7 @@ void operationEnd_withSuccess_setsOkOnOperationSpan() {
 
     @Test
     void operationEnd_withNonSuccessStatusAndNoError_leavesOperationSpanUnset() {
-        // onOperationEnd fires for every terminal status. A CANCELLED operation (or an error-less
-        // FAILED/TIMED_OUT/STOPPED) carries a non-null, non-SUCCEEDED status with a null error. It must NOT be
-        // stamped OK — the span status stays UNSET.
+        // Cancellation without diagnostic details retains UNSET; it is not blanket-classified as failure.
         plugin.onInvocationStart(new InvocationInfo("req-1", "arn:exec1", true, Instant.now()));
 
         plugin.onOperationStart(
@@ -811,9 +813,8 @@ void operationEnd_withNonSuccessStatusAndNoError_leavesOperationSpanUnset() {
     }
 
     @Test
-    void operationEnd_withoutMatchingStart_nonSuccessStatusAndNoError_leavesContinuationSpanUnset() {
-        // Same guard on the continuation-span branch (operation completed between invocations): an error-less
-        // TIMED_OUT terminal status must NOT be stamped OK.
+    void operationEnd_withoutMatchingStart_timeoutWithoutError_setsError() {
+        // An explicit timeout remains an error even when the backend supplied no exception details.
         plugin.onInvocationStart(new InvocationInfo("req-1", "arn:exec1", true, Instant.now()));
 
         plugin.onOperationEnd(new OperationEndInfo(
@@ -836,7 +837,8 @@ void operationEnd_withoutMatchingStart_nonSuccessStatusAndNoError_leavesContinua
                 .filter(s -> s.getName().contains("callback"))
                 .findFirst()
                 .orElseThrow();
-        assertEquals(StatusCode.UNSET, continuationSpan.getStatus().getStatusCode());
+        assertEquals(StatusCode.ERROR, continuationSpan.getStatus().getStatusCode());
+        assertTrue(continuationSpan.getEvents().isEmpty());
     }
 
     @Test
@@ -1015,17 +1017,38 @@ void operationStart_withStatus_preservesStatus() {
 
     @Test
     void invocationEnd_closesNestedSpansChildFirst() {
+        var start = Instant.parse("2026-01-01T00:00:00Z");
+        var clock = TestClock.create(start);
+        // Drive time with actual end callbacks; independent real span clock anchors can differ slightly.
+        var clockAdvancer = mock(SpanProcessor.class, CALLS_REAL_METHODS);
+        when(clockAdvancer.isEndRequired()).thenReturn(true);
+        doAnswer(invocation -> {
+                    clock.advance(1, TimeUnit.NANOSECONDS);
+                    return null;
+                })
+                .when(clockAdvancer)
+                .onEnd(any());
+        var timedPlugin = new InvocationOtelPlugin(
+                SdkTracerProvider.builder()
+                        .setClock(clock)
+                        .addSpanProcessor(SimpleSpanProcessor.create(spanExporter))
+                        .addSpanProcessor(clockAdvancer),
+                OtelPluginConfig.builder()
+                        .contextExtractor(() -> null)
+                        .enableMdc(false)
+                        .build());
         var parentId = "op-parent";
         var childId = "op-child";
-        plugin.onInvocationStart(new InvocationInfo("req-1", "arn:exec1", true, Instant.now()));
-        plugin.onOperationStart(new OperationInfo(
-                parentId, "parent-context", "CONTEXT", "RunInChildContext", null, Instant.now(), null, null, false));
-        plugin.onOperationStart(
-                new OperationInfo(childId, "child-step", "STEP", "Step", parentId, Instant.now(), null, null, false));
-        plugin.onUserFunctionStart(
-                new UserFunctionStartInfo(childId, "child-step", "STEP", "Step", parentId, Instant.now(), false, 1));
+        timedPlugin.onInvocationStart(new InvocationInfo("req-1", "arn:exec1", true, start));
+        timedPlugin.onOperationStart(new OperationInfo(
+                parentId, "parent-context", "CONTEXT", "RunInChildContext", null, start, null, null, false));
+        timedPlugin.onOperationStart(
+                new OperationInfo(childId, "child-step", "STEP", "Step", parentId, start, null, null, false));
+        timedPlugin.onUserFunctionStart(
+                new UserFunctionStartInfo(childId, "child-step", "STEP", "Step", parentId, start, false, 1));
 
-        plugin.onInvocationEnd(new InvocationEndInfo("req-1", "arn:exec1", true, InvocationStatus.PENDING, null));
+        clock.advance(1, TimeUnit.SECONDS);
+        timedPlugin.onInvocationEnd(new InvocationEndInfo("req-1", "arn:exec1", true, InvocationStatus.PENDING, null));
 
         var parentSpan = spanByName("parent-context");
         var childSpan = spanByName("child-step");
@@ -1038,10 +1061,10 @@ void invocationEnd_closesNestedSpansChildFirst() {
                 spans.indexOf(childSpan) < spans.indexOf(parentSpan),
                 "Child operation span must be exported before its parent operation span");
         assertTrue(
-                attemptSpan.getEndEpochNanos() <= childSpan.getEndEpochNanos(),
+                attemptSpan.getEndEpochNanos() < childSpan.getEndEpochNanos(),
                 "Attempt span must end before its operation span");
         assertTrue(
-                childSpan.getEndEpochNanos() <= parentSpan.getEndEpochNanos(),
+                childSpan.getEndEpochNanos() < parentSpan.getEndEpochNanos(),
                 "Child operation span must end before its parent operation span");
     }
 
diff --git a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/OperationExceptionEventTest.java b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/OperationExceptionEventTest.java
new file mode 100644
index 000000000..188768cf5
--- /dev/null
+++ b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/OperationExceptionEventTest.java
@@ -0,0 +1,189 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.otel;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.trace.StatusCode;
+import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import io.opentelemetry.sdk.trace.SpanLimits;
+import io.opentelemetry.sdk.trace.data.SpanData;
+import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
+import io.opentelemetry.sdk.trace.samplers.Sampler;
+import io.opentelemetry.sdk.trace.samplers.SamplingResult;
+import java.io.PrintWriter;
+import java.time.Instant;
+import java.util.List;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import software.amazon.lambda.durable.plugin.InvocationEndInfo;
+import software.amazon.lambda.durable.plugin.InvocationInfo;
+import software.amazon.lambda.durable.plugin.InvocationStatus;
+import software.amazon.lambda.durable.plugin.OperationEndInfo;
+
+class OperationExceptionEventTest {
+    private static final String NAME = "backend-diagnostic";
+    private static final AttributeKey<String> TYPE = AttributeKey.stringKey("exception.type");
+    private static final AttributeKey<String> MESSAGE = AttributeKey.stringKey("exception.message");
+    private static final AttributeKey<String> STACK = AttributeKey.stringKey("exception.stacktrace");
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void knownEndRetainsRealExceptionAndWrapperDiagnostics(boolean wrapped) {
+        var cause = new IllegalArgumentException("backend failure");
+        cause.setStackTrace(new StackTraceElement[] {new StackTraceElement("Example", "step", "Workflow.java", 42)});
+        Throwable error = cause;
+        if (wrapped) {
+            error = new CompletionException("transport failure", cause);
+            error.setStackTrace(new StackTraceElement[] {new StackTraceElement("Worker", "run", "Worker.java", 7)});
+            error.addSuppressed(new IllegalStateException("suppressed cleanup"));
+        }
+        var span = operation(error, SpanLimits.getDefault());
+        assertEquals(StatusCode.ERROR, span.getStatus().getStatusCode());
+        assertEquals(error.getMessage(), span.getStatus().getDescription());
+        assertEquals(1, span.getEvents().size());
+        var event = span.getEvents().get(0);
+        assertEquals("exception", event.getName());
+        assertEquals(span.getEndEpochNanos(), event.getEpochNanos());
+        assertEquals(20_000_000_000L, event.getEpochNanos());
+        assertEquals(error.getClass().getCanonicalName(), event.getAttributes().get(TYPE));
+        assertEquals(error.getMessage(), event.getAttributes().get(MESSAGE));
+        var stack = event.getAttributes().get(STACK);
+        assertTrue(stack.startsWith(error.toString()));
+        assertTrue(stack.contains("at Example.step(Workflow.java:42)"));
+        if (wrapped) {
+            assertSame(cause, error.getCause());
+            assertTrue(stack.contains("Caused by: java.lang.IllegalArgumentException: backend failure"));
+            assertTrue(stack.contains("at Worker.run(Worker.java:7)"));
+            assertTrue(stack.contains("Suppressed: java.lang.IllegalStateException: suppressed cleanup"));
+        }
+    }
+
+    @Test
+    void absentMessageIsNotInventedForAnActualThrowable() {
+        var event = operation(new IllegalArgumentException(), SpanLimits.getDefault())
+                .getEvents()
+                .get(0);
+        assertEquals(
+                IllegalArgumentException.class.getCanonicalName(),
+                event.getAttributes().get(TYPE));
+        assertNull(event.getAttributes().get(MESSAGE));
+        assertTrue(event.getAttributes().get(STACK).startsWith("java.lang.IllegalArgumentException"));
+        assertEquals(2, event.getAttributes().size());
+        assertEquals(20_000_000_000L, event.getEpochNanos());
+    }
+
+    @Test
+    void recordingUnsampledSpansStillContainTheTimestampedException() {
+        var sampler = mock(Sampler.class);
+        when(sampler.shouldSample(any(), anyString(), anyString(), any(), any(), anyList()))
+                .thenReturn(SamplingResult.recordOnly());
+        var span = finish(new IllegalStateException("backend failure"), SpanLimits.getDefault(), sampler).stream()
+                .filter(item -> NAME.equals(item.getName()))
+                .findFirst()
+                .orElseThrow();
+        assertFalse(span.getSpanContext().isSampled());
+        assertEquals(StatusCode.ERROR, span.getStatus().getStatusCode());
+        assertEquals(1, span.getEvents().size());
+        assertEquals(20_000_000_000L, span.getEvents().get(0).getEpochNanos());
+        assertEquals("backend failure", span.getEvents().get(0).getAttributes().get(MESSAGE));
+    }
+
+    @Test
+    void timestampedExceptionHonorsPerEventAttributeCountRatherThanSpanAttributeCount() {
+        var limits = SpanLimits.builder()
+                .setMaxNumberOfAttributes(1)
+                .setMaxNumberOfAttributesPerEvent(2)
+                .build();
+        var event = operation(new IllegalStateException("backend failure"), limits)
+                .getEvents()
+                .get(0);
+        assertEquals(2, event.getAttributes().size());
+        assertEquals(3, event.getTotalAttributeCount());
+        assertEquals(20_000_000_000L, event.getEpochNanos());
+    }
+
+    @Test
+    void timestampedExceptionHonorsProviderAttributeValueLimit() {
+        var limits = SpanLimits.builder().setMaxAttributeValueLength(16).build();
+        var event = operation(new IllegalStateException("backend failure with a long message"), limits)
+                .getEvents()
+                .get(0);
+        assertEquals("java.lang.Illega", event.getAttributes().get(TYPE));
+        assertEquals("backend failure ", event.getAttributes().get(MESSAGE));
+        assertEquals("java.lang.Illega", event.getAttributes().get(STACK));
+        assertEquals(3, event.getAttributes().size());
+        assertEquals(20_000_000_000L, event.getEpochNanos());
+    }
+
+    @Test
+    void providerMayDiscardExceptionEventAtItsEventLimit() {
+        var span = operation(
+                new IllegalStateException("backend failure"),
+                SpanLimits.builder().setMaxNumberOfEvents(0).build());
+        assertEquals(StatusCode.ERROR, span.getStatus().getStatusCode());
+        assertTrue(span.getEvents().isEmpty());
+        assertEquals(1, span.getTotalRecordedEvents());
+    }
+
+    @Test
+    void droppedSpansDoNotRenderOrExportExceptionDetails() {
+        var rendered = new AtomicInteger();
+        var error = new IllegalStateException("backend failure") {
+            @Override
+            public void printStackTrace(PrintWriter writer) {
+                rendered.incrementAndGet();
+                super.printStackTrace(writer);
+            }
+        };
+        assertTrue(finish(error, SpanLimits.getDefault(), Sampler.alwaysOff()).isEmpty());
+        assertEquals(0, rendered.get());
+    }
+
+    private static SpanData operation(Throwable error, SpanLimits limits) {
+        return finish(error, limits, Sampler.alwaysOn()).stream()
+                .filter(span -> NAME.equals(span.getName()))
+                .findFirst()
+                .orElseThrow();
+    }
+
+    private static List<SpanData> finish(Throwable error, SpanLimits limits, Sampler sampler) {
+        try (var exporter = InMemorySpanExporter.create()) {
+            var builder = SdkTracerProvider.builder()
+                    .setSpanLimits(limits)
+                    .setSampler(sampler)
+                    .addSpanProcessor(SimpleSpanProcessor.builder(exporter)
+                            .setExportUnsampledSpans(true)
+                            .build());
+            var config = OtelPluginConfig.builder()
+                    .enableMdc(false)
+                    .contextExtractor(() -> null)
+                    .build();
+            var plugin = new ExecutionOtelPlugin(builder, config);
+            plugin.onInvocationStart(new InvocationInfo("request", "arn:diagnostic", true, Instant.ofEpochSecond(1)));
+            plugin.onOperationEnd(new OperationEndInfo(
+                    "op",
+                    NAME,
+                    "CALLBACK",
+                    "Callback",
+                    null,
+                    Instant.ofEpochSecond(10),
+                    Instant.ofEpochSecond(20),
+                    "FAILED",
+                    null,
+                    true,
+                    error,
+                    null));
+            plugin.onInvocationEnd(
+                    new InvocationEndInfo("request", "arn:diagnostic", true, InvocationStatus.SUCCEEDED, null));
+            return List.copyOf(exporter.getFinishedSpanItems());
+        }
+    }
+}
diff --git a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/OperationExceptionTimingTest.java b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/OperationExceptionTimingTest.java
new file mode 100644
index 000000000..c3c32d027
--- /dev/null
+++ b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/OperationExceptionTimingTest.java
@@ -0,0 +1,108 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.otel;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static software.amazon.lambda.durable.otel.SpanAttributes.DURABLE_OPERATION_NAME;
+
+import io.opentelemetry.api.trace.StatusCode;
+import io.opentelemetry.sdk.common.Clock;
+import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
+import java.time.Instant;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import software.amazon.lambda.durable.plugin.DurableExecutionPlugin;
+import software.amazon.lambda.durable.plugin.InvocationEndInfo;
+import software.amazon.lambda.durable.plugin.InvocationInfo;
+import software.amazon.lambda.durable.plugin.InvocationStatus;
+import software.amazon.lambda.durable.plugin.OperationEndInfo;
+import software.amazon.lambda.durable.plugin.OperationInfo;
+
+class OperationExceptionTimingTest {
+    static Stream<Arguments> paths() {
+        return Stream.of(false, true)
+                .flatMap(execution -> Stream.of(
+                                "live", "continuation", "missing-start", "late-start", "no-end", "zero-end")
+                        .map(path -> Arguments.of(execution, path)));
+    }
+
+    @ParameterizedTest
+    @MethodSource("paths")
+    void exceptionUsesOperationEndWithoutChangingViewClockPolicy(boolean executionView, String path) {
+        var nano = new AtomicLong();
+        var clock = new Clock() {
+            public long now() {
+                return 100_000_000_000L;
+            }
+
+            public long nanoTime() {
+                return nano.addAndGet(1_000);
+            }
+        };
+        try (var exporter = InMemorySpanExporter.create()) {
+            var builder =
+                    SdkTracerProvider.builder().setClock(clock).addSpanProcessor(SimpleSpanProcessor.create(exporter));
+            var settings = OtelPluginConfig.builder()
+                    .enableMdc(false)
+                    .contextExtractor(() -> null)
+                    .build();
+            DurableExecutionPlugin plugin = executionView
+                    ? new ExecutionOtelPlugin(builder, settings)
+                    : new InvocationOtelPlugin(builder, settings);
+            var start = path.equals("missing-start") || path.equals("no-end") || path.equals("zero-end")
+                    ? null
+                    : Instant.ofEpochSecond(path.equals("late-start") ? 30 : 10);
+            var end =
+                    path.equals("no-end") ? null : path.equals("zero-end") ? Instant.EPOCH : Instant.ofEpochSecond(20);
+            plugin.onInvocationStart(new InvocationInfo("request", "arn:timing", true, Instant.ofEpochSecond(1)));
+            if (path.equals("live") || path.equals("late-start"))
+                plugin.onOperationStart(new OperationInfo(
+                        "operation", "timing-target", "CALLBACK", "Callback", null, start, null, null, false));
+            plugin.onOperationEnd(new OperationEndInfo(
+                    "operation",
+                    "timing-target",
+                    "CALLBACK",
+                    "Callback",
+                    null,
+                    start,
+                    end,
+                    "FAILED",
+                    null,
+                    path.equals("continuation"),
+                    new IllegalStateException("backend failure"),
+                    null));
+            plugin.onInvocationEnd(
+                    new InvocationEndInfo("request", "arn:timing", true, InvocationStatus.SUCCEEDED, null));
+            var span = exporter.getFinishedSpanItems().stream()
+                    .filter(s -> "timing-target".equals(s.getAttributes().get(DURABLE_OPERATION_NAME)))
+                    .findFirst()
+                    .orElseThrow();
+            assertEquals(StatusCode.ERROR, span.getStatus().getStatusCode());
+            assertEquals(1, span.getEvents().size());
+            long event = span.getEvents().get(0).getEpochNanos();
+            System.out.printf(
+                    "OPERATION_TIME execution=%s path=%s start=%s end=%s event=%s%n",
+                    executionView, path, span.getStartEpochNanos(), span.getEndEpochNanos(), event);
+            if (executionView && end != null && !end.equals(Instant.EPOCH)) {
+                assertEquals(20_000_000_000L, span.getEndEpochNanos(), "retain the known backend end");
+                long expectedStart = start == null ? span.getEndEpochNanos() : start.getEpochSecond() * 1_000_000_000L;
+                assertEquals(expectedStart, span.getStartEpochNanos(), "only a missing start falls back to known end");
+                assertEquals(span.getEndEpochNanos(), event, "exception belongs at the same actual operation end");
+                if (!path.equals("late-start")) assertTrue(event >= span.getStartEpochNanos());
+                else
+                    assertTrue(
+                            span.getStartEpochNanos() > span.getEndEpochNanos(),
+                            "do not introduce clock-skew clamping");
+            } else {
+                assertTrue(span.getStartEpochNanos() >= 100_000_000_000L);
+                assertTrue(span.getEndEpochNanos() < 101_000_000_000L, "retain the configured SDK clock");
+                assertTrue(event >= span.getStartEpochNanos() && event <= span.getEndEpochNanos());
+            }
+        }
+    }
+}
diff --git a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ReplacementSamplerPolicyTest.java b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ReplacementSamplerPolicyTest.java
index 03c601e09..0e782413e 100644
--- a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ReplacementSamplerPolicyTest.java
+++ b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/ReplacementSamplerPolicyTest.java
@@ -37,6 +37,8 @@ class ReplacementSamplerPolicyTest {
         "invocation,true,root,true,plain", "execution,true,root,true,plain",
         "invocation,false,sampled,true,plain", "execution,false,sampled,true,plain",
         "invocation,true,unsampled,false,plain", "execution,true,unsampled,false,plain",
+        "invocation,false,remote,false,plain", "execution,false,remote,false,plain",
+        "invocation,true,remote,true,plain", "execution,true,remote,true,plain",
         "invocation,false,root,false,local", "execution,false,root,false,local",
         "invocation,false,root,false,opaque", "execution,false,root,false,opaque"
     })
@@ -47,6 +49,7 @@ void visibleReplacementParentBasedSamplerKeepsItsRootPolicy(
         var sideEffects = new AtomicInteger();
         var decisions = new CopyOnWriteArrayList<Boolean>();
         var header = "Root=1-6955b900-123456789012345678901234";
+        if (upstream.equals("remote")) header += ";Parent=1234567890123456";
         if (upstream.equals("sampled")) header += ";Sampled=1";
         else if (upstream.equals("unsampled")) header += ";Sampled=0";
         var root = new Sampler() {
@@ -115,11 +118,14 @@ public ContextPropagators getPropagators() {
                     ExecutionStatus.SUCCEEDED, runner.runUntilComplete("input").getStatus());
             assertTrue(decisions.size() >= 2, "Initial invocation and actual replay must both execute the handler");
             assertTrue(decisions.stream().allMatch(decision -> decision == expectedSampled), decisions.toString());
-            assertEquals(
-                    topology.equals("plain")
-                            ? decisions.size() * (upstream.equals("root") ? 2 : 1)
-                            : upstream.equals("root") ? (topology.equals("opaque") ? 1 : decisions.size()) : 0,
-                    evaluations.get());
+            if (!upstream.equals("remote")) {
+                assertEquals(
+                        topology.equals("plain")
+                                ? decisions.size()
+                                : upstream.equals("root") ? (topology.equals("opaque") ? 1 : decisions.size()) : 0,
+                        evaluations.get(),
+                        "A plain provider evaluates its actual fallback root once per invocation");
+            }
             assertEquals(1, sideEffects.get());
         } finally {
             GlobalOpenTelemetry.resetForTest();
diff --git a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/TerminalOperationStatusTest.java b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/TerminalOperationStatusTest.java
new file mode 100644
index 000000000..dd2644932
--- /dev/null
+++ b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/TerminalOperationStatusTest.java
@@ -0,0 +1,107 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.otel;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static software.amazon.lambda.durable.otel.SpanAttributes.*;
+
+import io.opentelemetry.api.trace.StatusCode;
+import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
+import java.time.Instant;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import software.amazon.awssdk.services.lambda.model.ErrorObject;
+import software.amazon.awssdk.services.lambda.model.Operation;
+import software.amazon.awssdk.services.lambda.model.OperationStatus;
+import software.amazon.awssdk.services.lambda.model.OperationType;
+import software.amazon.lambda.durable.exception.DurableOperationException;
+import software.amazon.lambda.durable.plugin.DurableExecutionPlugin;
+import software.amazon.lambda.durable.plugin.InvocationEndInfo;
+import software.amazon.lambda.durable.plugin.InvocationInfo;
+import software.amazon.lambda.durable.plugin.InvocationStatus;
+import software.amazon.lambda.durable.plugin.OperationEndInfo;
+import software.amazon.lambda.durable.plugin.OperationInfo;
+
+class TerminalOperationStatusTest {
+    static Stream<Arguments> failures() {
+        return Stream.of(false, true)
+                .flatMap(execution -> Stream.of(false, true)
+                        .flatMap(start -> Stream.of("FAILED", "TIMED_OUT", "STOPPED")
+                                .flatMap(status -> Stream.of(false, true)
+                                        .map(empty -> Arguments.of(execution, start, status, empty)))));
+    }
+
+    @ParameterizedTest
+    @MethodSource("failures")
+    void explicitTerminalFailureIsErrorWithoutInventedExceptionDetails(
+            boolean executionView, boolean matchingStart, String status, boolean emptyContainer) {
+        var operation = Operation.builder()
+                .id("op")
+                .type(OperationType.CALLBACK)
+                .status(OperationStatus.fromValue(status))
+                .build();
+        Throwable error = emptyContainer
+                ? new DurableOperationException(operation, ErrorObject.builder().build())
+                : null;
+        check(executionView, matchingStart, status, error, StatusCode.ERROR);
+    }
+
+    static Stream<Arguments> controls() {
+        return Stream.of(false, true)
+                .flatMap(execution -> Stream.of("SUCCEEDED", "PENDING", "RETRYING", "CANCELLED")
+                        .map(status -> Arguments.of(execution, status)));
+    }
+
+    @ParameterizedTest
+    @MethodSource("controls")
+    void successAndNonfailureStatusesKeepTheirExistingMeaning(boolean executionView, String status) {
+        check(executionView, true, status, null, status.equals("SUCCEEDED") ? StatusCode.OK : StatusCode.UNSET);
+    }
+
+    private static void check(
+            boolean executionView, boolean matchingStart, String status, Throwable error, StatusCode expected) {
+        try (var exporter = InMemorySpanExporter.create()) {
+            var builder = SdkTracerProvider.builder().addSpanProcessor(SimpleSpanProcessor.create(exporter));
+            var settings = OtelPluginConfig.builder()
+                    .enableMdc(false)
+                    .contextExtractor(() -> null)
+                    .build();
+            DurableExecutionPlugin plugin = executionView
+                    ? new ExecutionOtelPlugin(builder, settings)
+                    : new InvocationOtelPlugin(builder, settings);
+            var start = Instant.parse("2026-10-14T00:00:00Z");
+            plugin.onInvocationStart(new InvocationInfo("request", "arn:status", !matchingStart, start));
+            if (matchingStart)
+                plugin.onOperationStart(new OperationInfo(
+                        "op", "status-target", "CALLBACK", "Callback", null, start, null, null, false));
+            plugin.onOperationEnd(new OperationEndInfo(
+                    "op",
+                    "status-target",
+                    "CALLBACK",
+                    "Callback",
+                    null,
+                    start,
+                    start.plusSeconds(1),
+                    status,
+                    null,
+                    !matchingStart,
+                    error,
+                    null));
+            plugin.onInvocationEnd(
+                    new InvocationEndInfo("request", "arn:status", true, InvocationStatus.SUCCEEDED, null));
+            var spans = exporter.getFinishedSpanItems().stream()
+                    .filter(s -> "status-target".equals(s.getAttributes().get(DURABLE_OPERATION_NAME)))
+                    .toList();
+            assertEquals(1, spans.size());
+            var span = spans.get(0);
+            assertEquals(status, span.getAttributes().get(DURABLE_OPERATION_STATUS));
+            assertEquals(expected, span.getStatus().getStatusCode());
+            assertEquals("", span.getStatus().getDescription(), "missing details do not become synthetic text");
+            assertTrue(span.getEvents().isEmpty(), "filtered/absent details do not become an exception event");
+        }
+    }
+}
diff --git a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/VirtualOperationErrorStatusTest.java b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/VirtualOperationErrorStatusTest.java
new file mode 100644
index 000000000..fa62205d1
--- /dev/null
+++ b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/VirtualOperationErrorStatusTest.java
@@ -0,0 +1,244 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.otel;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static software.amazon.lambda.durable.otel.SpanAttributes.DURABLE_OPERATION_NAME;
+
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.trace.StatusCode;
+import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import io.opentelemetry.sdk.trace.data.EventData;
+import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import software.amazon.awssdk.services.lambda.model.ErrorObject;
+import software.amazon.awssdk.services.lambda.model.Operation;
+import software.amazon.awssdk.services.lambda.model.OperationStatus;
+import software.amazon.awssdk.services.lambda.model.OperationType;
+import software.amazon.lambda.durable.DurableConfig;
+import software.amazon.lambda.durable.config.RunInChildContextConfig;
+import software.amazon.lambda.durable.exception.DurableOperationException;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.plugin.DurableExecutionPlugin;
+import software.amazon.lambda.durable.plugin.InvocationEndInfo;
+import software.amazon.lambda.durable.plugin.InvocationInfo;
+import software.amazon.lambda.durable.plugin.InvocationStatus;
+import software.amazon.lambda.durable.plugin.OperationEndInfo;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class VirtualOperationErrorStatusTest {
+    private static final String NAME = "virtual-child";
+
+    @ParameterizedTest
+    @CsvSource({
+        "false,empty", "true,empty",
+        "false,without-container", "true,without-container",
+        "false,ordinary", "true,ordinary",
+        "false,explicit-message", "true,explicit-message",
+        "false,empty-message", "true,empty-message",
+        "false,explicit-cause", "true,explicit-cause",
+        "false,explicit-suppressed", "true,explicit-suppressed",
+        "false,explicit-stack", "true,explicit-stack",
+        "false,success", "true,success"
+    })
+    void publicVirtualChildKeepsFailureStatusAcrossReplay(boolean executionView, String outcome) {
+        try (var exporter = InMemorySpanExporter.create()) {
+            var plugin = plugin(executionView, exporter);
+            var ends = new CopyOnWriteArrayList<OperationEndInfo>();
+            var listener = new DurableExecutionPlugin() {
+                public void onOperationEnd(OperationEndInfo info) {
+                    if (NAME.equals(info.name())) ends.add(info);
+                }
+            };
+            var failure = failure(outcome);
+            var sideEffects = new AtomicInteger();
+            var callerFailures = new CopyOnWriteArrayList<RuntimeException>();
+            var childResults = new CopyOnWriteArrayList<String>();
+            var runner = LocalDurableTestRunner.create(
+                    String.class,
+                    (input, context) -> {
+                        try {
+                            childResults.add(context.runInChildContext(
+                                    NAME,
+                                    String.class,
+                                    child -> {
+                                        if (failure != null) throw failure;
+                                        return "child result";
+                                    },
+                                    RunInChildContextConfig.builder()
+                                            .isVirtual(true)
+                                            .build()));
+                        } catch (RuntimeException caught) {
+                            callerFailures.add(caught);
+                        }
+                        context.step("once", String.class, step -> {
+                            sideEffects.incrementAndGet();
+                            return "saved";
+                        });
+                        context.wait("pause", Duration.ofSeconds(1));
+                        return "handled";
+                    },
+                    DurableConfig.builder().withPlugins(plugin, listener).build());
+            assertEquals(ExecutionStatus.PENDING, runner.run("input").getStatus());
+            assertEquals(
+                    ExecutionStatus.SUCCEEDED, runner.runUntilComplete("input").getStatus());
+            assertTrue(ends.size() >= 2, "The virtual body runs on initial invocation and replay");
+            if (failure == null) {
+                assertTrue(callerFailures.isEmpty());
+                assertEquals(ends.size(), childResults.size());
+                assertTrue(childResults.stream().allMatch("child result"::equals));
+            } else {
+                assertTrue(childResults.isEmpty());
+                assertEquals(ends.size(), callerFailures.size());
+                callerFailures.forEach(caught -> {
+                    if (failure instanceof DurableOperationException original) {
+                        var translated = assertInstanceOf(DurableOperationException.class, caught);
+                        assertEquals(original.getErrorObject(), translated.getErrorObject());
+                    } else {
+                        assertEquals(failure.getClass(), caught.getClass());
+                        assertEquals(failure.getMessage(), caught.getMessage());
+                    }
+                });
+            }
+
+            ends.forEach(info -> {
+                assertNull(info.status());
+                assertSame(failure, info.error());
+            });
+            var spans = exporter.getFinishedSpanItems().stream()
+                    .filter(span -> NAME.equals(span.getAttributes().get(DURABLE_OPERATION_NAME)))
+                    .toList();
+            assertEquals(ends.size(), spans.size());
+            spans.forEach(span -> {
+                assertEquals(status(outcome), span.getStatus().getStatusCode());
+                assertEquals(
+                        hasExceptionEvent(outcome) ? 1 : 0, span.getEvents().size());
+                if (hasExceptionEvent(outcome))
+                    assertDiagnostics(span.getEvents().get(0), failure, outcome);
+            });
+            assertEquals(1, sideEffects.get(), "Completed durable work is skipped on replay");
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(
+            strings = {
+                "empty",
+                "ordinary",
+                "success",
+                "explicit-message",
+                "empty-message",
+                "explicit-cause",
+                "explicit-suppressed",
+                "explicit-stack"
+            })
+    void missingStartInvocationSegmentRetainsVirtualFailure(String outcome) {
+        try (var exporter = InMemorySpanExporter.create()) {
+            var plugin = plugin(false, exporter);
+            plugin.onInvocationStart(new InvocationInfo("request", "arn:virtual", true, Instant.EPOCH));
+            plugin.onOperationEnd(new OperationEndInfo(
+                    "virtual",
+                    NAME,
+                    "CONTEXT",
+                    "RunInChildContext",
+                    null,
+                    Instant.EPOCH,
+                    Instant.EPOCH,
+                    null,
+                    null,
+                    false,
+                    failure(outcome),
+                    null));
+            plugin.onInvocationEnd(
+                    new InvocationEndInfo("request", "arn:virtual", true, InvocationStatus.SUCCEEDED, null));
+            var spans = exporter.getFinishedSpanItems().stream()
+                    .filter(span -> NAME.equals(span.getAttributes().get(DURABLE_OPERATION_NAME)))
+                    .toList();
+            assertEquals(1, spans.size());
+            assertEquals(status(outcome), spans.get(0).getStatus().getStatusCode());
+            assertEquals(
+                    hasExceptionEvent(outcome) ? 1 : 0, spans.get(0).getEvents().size());
+            if (hasExceptionEvent(outcome))
+                assertDiagnostics(spans.get(0).getEvents().get(0), failure(outcome), outcome);
+        }
+    }
+
+    private static DurableExecutionPlugin plugin(boolean executionView, InMemorySpanExporter exporter) {
+        var provider = SdkTracerProvider.builder().addSpanProcessor(SimpleSpanProcessor.create(exporter));
+        var config = OtelPluginConfig.builder()
+                .enableMdc(false)
+                .contextExtractor(() -> null)
+                .build();
+        return executionView ? new ExecutionOtelPlugin(provider, config) : new InvocationOtelPlugin(provider, config);
+    }
+
+    private static RuntimeException failure(String outcome) {
+        var operation = Operation.builder()
+                .id("external")
+                .type(OperationType.CALLBACK)
+                .status(OperationStatus.FAILED)
+                .build();
+        return switch (outcome) {
+            case "empty" ->
+                new DurableOperationException(operation, ErrorObject.builder().build());
+            case "without-container" -> new DurableOperationException(operation, null, "explicit failure");
+            case "explicit-message" ->
+                new DurableOperationException(operation, ErrorObject.builder().build(), "diagnostic-message");
+            case "empty-message" ->
+                new DurableOperationException(operation, ErrorObject.builder().build(), "");
+            case "explicit-cause" ->
+                new DurableOperationException(
+                        operation,
+                        ErrorObject.builder().build(),
+                        null,
+                        new IllegalArgumentException("diagnostic-cause"));
+            case "explicit-suppressed" -> {
+                var failure = new DurableOperationException(
+                        operation, ErrorObject.builder().build());
+                failure.addSuppressed(new IllegalStateException("diagnostic-suppressed"));
+                yield failure;
+            }
+            case "explicit-stack" ->
+                new DurableOperationException(
+                        operation,
+                        ErrorObject.builder().build(),
+                        null,
+                        new StackTraceElement[] {new StackTraceElement("example.Virtual", "fail", "Virtual.java", 7)},
+                        null);
+            case "ordinary" -> new IllegalStateException("ordinary failure");
+            case "success" -> null;
+            default -> throw new IllegalArgumentException(outcome);
+        };
+    }
+
+    private static void assertDiagnostics(EventData event, RuntimeException failure, String outcome) {
+        if (failure.getMessage() != null) {
+            assertEquals(failure.getMessage(), event.getAttributes().get(AttributeKey.stringKey("exception.message")));
+        }
+        var stack = event.getAttributes().get(AttributeKey.stringKey("exception.stacktrace"));
+        switch (outcome) {
+            case "explicit-cause" -> assertTrue(stack.contains("diagnostic-cause"));
+            case "explicit-suppressed" -> assertTrue(stack.contains("diagnostic-suppressed"));
+            case "explicit-stack" -> assertTrue(stack.contains("example.Virtual.fail(Virtual.java:7)"));
+            default -> {}
+        }
+    }
+
+    private static boolean hasExceptionEvent(String outcome) {
+        return !outcome.equals("empty") && !outcome.equals("success");
+    }
+
+    private static StatusCode status(String outcome) {
+        return switch (outcome) {
+            case "success" -> StatusCode.OK;
+            default -> StatusCode.ERROR;
+        };
+    }
+}
diff --git a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/VisibleReplacementSdkSpanPolicyTest.java b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/VisibleReplacementSdkSpanPolicyTest.java
index d22efaa82..d20e55702 100644
--- a/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/VisibleReplacementSdkSpanPolicyTest.java
+++ b/otel-plugin/src/test/java/software/amazon/lambda/durable/otel/VisibleReplacementSdkSpanPolicyTest.java
@@ -41,6 +41,7 @@ void actualSdkSpansHonorVisibleReplacementRootPolicy(
             String view, boolean rootSamples, String upstream, boolean expectedSampled) {
         var oldHeader = System.getProperty("com.amazonaws.xray.traceHeader");
         var rootPolicySnapshots = new AtomicInteger();
+        var actualRootEvaluations = new AtomicInteger();
         var invocations = new AtomicInteger();
         var sideEffects = new AtomicInteger();
         var header = "Root=1-6955b900-123456789012345678901234";
@@ -55,8 +56,9 @@ public SamplingResult shouldSample(
                     Attributes attributes,
                     List<LinkData> links) {
                 assertFalse(Span.fromContext(parent).getSpanContext().isValid());
-                // Count the SDK's root-policy snapshot, excluding normal provider sampling for a real synthetic-root
-                // export on branches that implement it. No exactly-once promise is made for a plain provider.
+                // A real fallback root performs the provider's root evaluation; no preliminary Workflow probe
+                // should consume a second decision. Descendant policy and explicit header controls stay below.
+                if (name.equals("DurableExecutionRoot")) actualRootEvaluations.incrementAndGet();
                 if (!name.equals("DurableExecutionRoot")
                         && attributes.get(AttributeKey.stringKey("durable.execution.arn")) != null) {
                     rootPolicySnapshots.incrementAndGet();
@@ -116,7 +118,8 @@ public ContextPropagators getPropagators() {
                 assertTrue(
                         sdkSpans.stream().allMatch(span -> span.getSpanContext().isSampled()));
             } else assertTrue(sdkSpans.isEmpty(), sdkSpans.toString());
-            assertEquals(upstream.equals("root") ? invocations.get() : 0, rootPolicySnapshots.get());
+            assertEquals(0, rootPolicySnapshots.get());
+            assertEquals(invocations.get(), actualRootEvaluations.get());
             assertEquals(1, sideEffects.get());
         } finally {
             GlobalOpenTelemetry.resetForTest();
diff --git a/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/MapIntegrationTest.java b/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/MapIntegrationTest.java
index 65dbe2383..22b36814e 100644
--- a/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/MapIntegrationTest.java
+++ b/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/MapIntegrationTest.java
@@ -16,6 +16,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
 import software.amazon.lambda.durable.config.CompletionConfig;
 import software.amazon.lambda.durable.config.MapConfig;
 import software.amazon.lambda.durable.config.NestingType;
@@ -2041,28 +2042,43 @@ void testInvalidItemNameDoesNotConsumeOperationId() {
                 attempted.getOperation("after").getId());
     }
 
-    @Test
-    void testChangedItemNameFailsCachedReplay() {
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void testChangedItemNameChecksServiceVisibleChildren(boolean retainChildren) {
         var suffix = new AtomicReference<>("first");
+        var itemCalls = new AtomicInteger();
         var runner = LocalDurableTestRunner.create(String.class, (input, context) -> {
             var result = context.map(
                     "replay-map",
                     List.of("a", "b"),
                     String.class,
-                    (item, index, ctx) -> item.toUpperCase(),
+                    (item, index, ctx) -> {
+                        itemCalls.incrementAndGet();
+                        return item.toUpperCase().repeat(retainChildren ? 140_000 : 1);
+                    },
                     MapConfig.builder()
                             .itemNamer((item, index) -> item + "-" + suffix.get())
                             .build());
-            return String.join(",", result.results());
+            context.wait("resume-after-map", Duration.ofSeconds(1));
+            return result.results().stream().mapToInt(String::length).sum();
         });
 
-        assertEquals(ExecutionStatus.SUCCEEDED, runner.runUntilComplete("test").getStatus());
+        assertEquals(ExecutionStatus.PENDING, runner.run("test").getStatus());
         suffix.set("second");
+        runner.advanceTime();
 
         var replay = runner.run("test");
 
-        assertEquals(ExecutionStatus.FAILED, replay.getStatus());
-        assertTrue(replay.getError().orElseThrow().errorType().contains("NonDeterministicExecutionException"));
+        if (retainChildren) {
+            assertEquals(ExecutionStatus.FAILED, replay.getStatus());
+            assertTrue(replay.getError().orElseThrow().errorType().contains("NonDeterministicExecutionException"));
+        } else {
+            // The service omits the completed map's children. Their old names cannot be checked from the cached
+            // aggregate alone; this does not relax the caller's requirement to keep names deterministic.
+            assertEquals(ExecutionStatus.SUCCEEDED, replay.getStatus());
+            assertEquals(2, replay.getResult(Integer.class));
+        }
+        assertEquals(2, itemCalls.get(), "Completed item bodies are not repeated");
     }
 
     @Test
@@ -2114,9 +2130,11 @@ void testChangedItemNameFailsStartedMapReplay() {
         assertTrue(replay.getError().orElseThrow().errorType().contains("NonDeterministicExecutionException"));
     }
 
-    @Test
-    void testRemovingItemNamerFailsCachedReplay() {
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void testRemovingItemNamerChecksServiceVisibleChildren(boolean retainChildren) {
         var useItemNamer = new AtomicBoolean(true);
+        var itemCalls = new AtomicInteger();
         var runner = LocalDurableTestRunner.create(String.class, (input, context) -> {
             var configBuilder = MapConfig.builder();
             if (useItemNamer.get()) {
@@ -2126,18 +2144,29 @@ void testRemovingItemNamerFailsCachedReplay() {
                     "removed-namer-map",
                     List.of("a", "b"),
                     String.class,
-                    (item, index, ctx) -> item.toUpperCase(),
+                    (item, index, ctx) -> {
+                        itemCalls.incrementAndGet();
+                        return item.toUpperCase().repeat(retainChildren ? 140_000 : 1);
+                    },
                     configBuilder.build());
-            return String.join(",", result.results());
+            context.wait("resume-after-map", Duration.ofSeconds(1));
+            return result.results().stream().mapToInt(String::length).sum();
         });
 
-        assertEquals(ExecutionStatus.SUCCEEDED, runner.runUntilComplete("test").getStatus());
+        assertEquals(ExecutionStatus.PENDING, runner.run("test").getStatus());
         useItemNamer.set(false);
+        runner.advanceTime();
 
         var replay = runner.run("test");
 
-        assertEquals(ExecutionStatus.FAILED, replay.getStatus());
-        assertTrue(replay.getError().orElseThrow().errorType().contains("NonDeterministicExecutionException"));
+        if (retainChildren) {
+            assertEquals(ExecutionStatus.FAILED, replay.getStatus());
+            assertTrue(replay.getError().orElseThrow().errorType().contains("NonDeterministicExecutionException"));
+        } else {
+            assertEquals(ExecutionStatus.SUCCEEDED, replay.getStatus());
+            assertEquals(2, replay.getResult(Integer.class));
+        }
+        assertEquals(2, itemCalls.get(), "Completed item bodies are not repeated");
     }
 
     @Test
diff --git a/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/PluginErrorContainerCompatibilityTest.java b/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/PluginErrorContainerCompatibilityTest.java
new file mode 100644
index 000000000..2af179229
--- /dev/null
+++ b/sdk-integration-tests/src/test/java/software/amazon/lambda/durable/PluginErrorContainerCompatibilityTest.java
@@ -0,0 +1,105 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import software.amazon.awssdk.services.lambda.model.ErrorObject;
+import software.amazon.lambda.durable.exception.DurableOperationException;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.plugin.DurableExecutionPlugin;
+import software.amazon.lambda.durable.plugin.InvocationEndInfo;
+import software.amazon.lambda.durable.plugin.InvocationInfo;
+import software.amazon.lambda.durable.plugin.OperationEndInfo;
+import software.amazon.lambda.durable.testing.LocalDurableTestRunner;
+
+class PluginErrorContainerCompatibilityTest {
+    static Stream<Arguments> errors() {
+        return Stream.of(
+                Arguments.of("absent", null),
+                Arguments.of("empty", ErrorObject.builder().build()),
+                Arguments.of(
+                        "empty-message", ErrorObject.builder().errorMessage("").build()),
+                Arguments.of(
+                        "message",
+                        ErrorObject.builder().errorMessage("external failure").build()),
+                Arguments.of(
+                        "empty-stack",
+                        ErrorObject.builder().stackTrace(List.of()).build()));
+    }
+
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("errors")
+    void nonOtelPluginRetainsFailureContainersAcrossCallbackResumeAndReplay(String label, ErrorObject error) {
+        var starts = new CopyOnWriteArrayList<InvocationInfo>();
+        var ends = new CopyOnWriteArrayList<InvocationEndInfo>();
+        var operationEnds = new CopyOnWriteArrayList<OperationEndInfo>();
+        var listener = new DurableExecutionPlugin() {
+            public void onInvocationStart(InvocationInfo info) {
+                starts.add(info);
+            }
+
+            public void onInvocationEnd(InvocationEndInfo info) {
+                ends.add(info);
+            }
+
+            public void onOperationEnd(OperationEndInfo info) {
+                operationEnds.add(info);
+            }
+        };
+        var submissions = new AtomicInteger();
+        var runner = LocalDurableTestRunner.create(
+                String.class,
+                (input, context) -> context.waitForCallback(
+                        "listener-error", String.class, (callbackId, step) -> submissions.incrementAndGet()),
+                DurableConfig.builder().withPlugins(listener).build());
+        assertEquals(ExecutionStatus.PENDING, runner.run("input").getStatus());
+        var callbackName = "listener-error-callback";
+        runner.failCallback(runner.getCallbackId(callbackName), error);
+        var failed = runner.run("input");
+        assertEquals(ExecutionStatus.FAILED, failed.getStatus());
+        var operation = failed.getOperation(callbackName);
+        assertEquals(error, operation.getCallbackDetails().error());
+        assertEquals(error, failed.getError().orElse(null));
+        assertContainer(error, starts.get(1).operations().get(operation.getId()).error());
+        assertContainer(
+                error, starts.get(1).updatedOperations().get(operation.getId()).error());
+        assertContainer(error, ends.get(1).operations().get(operation.getId()).error());
+        var callbacks = operationEnds.stream()
+                .filter(info -> callbackName.equals(info.name()))
+                .toList();
+        assertEquals(1, callbacks.size());
+        assertEquals("FAILED", callbacks.get(0).status());
+        assertContainer(error, callbacks.get(0).error());
+        var replay = runner.run("input");
+        assertEquals(ExecutionStatus.FAILED, replay.getStatus());
+        assertEquals(failed.getError(), replay.getError());
+        // The completed failed context omits its children from replay input. Inspection still retains the raw
+        // callback failure, and all of the delivered-container/identity checks above remain required.
+        assertFalse(starts.get(2).operations().containsKey(operation.getId()));
+        assertEquals(
+                error, replay.getOperation(callbackName).getCallbackDetails().error());
+        assertEquals(1, submissions.get(), "Completed submission must not execute again");
+        assertEquals(
+                1,
+                operationEnds.stream()
+                        .filter(info -> callbackName.equals(info.name()))
+                        .count());
+    }
+
+    private static void assertContainer(ErrorObject expected, Throwable actual) {
+        if (expected == null) {
+            assertNull(actual, "An absent container retains the existing null metadata behavior");
+        } else {
+            var failure = assertInstanceOf(DurableOperationException.class, actual);
+            assertEquals(expected, failure.getErrorObject(), "Plugins retain the original failure container");
+        }
+    }
+}
diff --git a/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/LocalDurableTestRunner.java b/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/LocalDurableTestRunner.java
index 0eaf52c11..56f72aa89 100644
--- a/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/LocalDurableTestRunner.java
+++ b/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/LocalDurableTestRunner.java
@@ -421,9 +421,10 @@ private DurableExecutionInput createDurableInput(I input) {
         }
         var executionOp = executionOpBuilder.build();
 
-        // Load previous non-EXECUTION operations; the single merged EXECUTION operation above already represents the
-        // execution's state.
-        var existingOps = storage.getAllOperations().stream()
+        // Invocation input follows the same child-retention rule as GetDurableExecutionState. The inspection store
+        // remains complete; the single merged EXECUTION operation above already represents the execution's state.
+        var checkpointToken = UUID.randomUUID().toString();
+        var existingOps = storage.getExecutionState(executionArn, checkpointToken, null).operations().stream()
                 .filter(op -> op.type() != OperationType.EXECUTION)
                 .toList();
         var allOps = new ArrayList<>(List.of(executionOp));
@@ -435,7 +436,7 @@ private DurableExecutionInput createDurableInput(I input) {
 
         return new DurableExecutionInput(
                 executionArn,
-                UUID.randomUUID().toString(),
+                checkpointToken,
                 CheckpointUpdatedExecutionState.builder().operations(allOps).build(),
                 updatedOperationIds);
     }
diff --git a/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/local/LocalMemoryExecutionClient.java b/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/local/LocalMemoryExecutionClient.java
index 11532d60e..a51e85ac2 100644
--- a/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/local/LocalMemoryExecutionClient.java
+++ b/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/local/LocalMemoryExecutionClient.java
@@ -85,8 +85,10 @@ public boolean isPaused() {
 
     @Override
     public GetDurableExecutionStateResponse getExecutionState(String arn, String checkpointToken, String marker) {
-        // local runner doesn't use this API at all
-        throw new UnsupportedOperationException("getExecutionState is not supported");
+        // A single page of service-visible state. Checkpoint responses and inspection retain the full store.
+        return GetDurableExecutionStateResponse.builder()
+                .operations(ReplayChildrenPruning.visibleOperations(getAllOperations()))
+                .build();
     }
 
     /** Get all operation updates that have been sent to this client. Useful for testing and verification. */
@@ -138,7 +140,9 @@ public Operation getOperationByName(String name) {
 
     /** Returns all operations currently stored. */
     public List<Operation> getAllOperations() {
-        return existingOperations.values().stream().toList();
+        synchronized (existingOperations) {
+            return List.copyOf(existingOperations.values());
+        }
     }
 
     /**
diff --git a/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/local/OperationProcessor.java b/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/local/OperationProcessor.java
index d74448ea8..4fe306e14 100644
--- a/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/local/OperationProcessor.java
+++ b/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/local/OperationProcessor.java
@@ -88,9 +88,10 @@ private static ChainedInvokeDetails buildChainedInvokeDetails(OperationUpdate up
     private static ContextDetails buildContextDetails(OperationUpdate update) {
         var detailsBuilder = ContextDetails.builder().result(update.payload()).error(update.error());
 
-        if (update.contextOptions() != null
-                && Boolean.TRUE.equals(update.contextOptions().replayChildren())) {
-            detailsBuilder.replayChildren(true);
+        if (update.action() == OperationAction.SUCCEED || update.action() == OperationAction.FAIL) {
+            // The service ignores this option on START. Only the closing update determines retention.
+            detailsBuilder.replayChildren(update.contextOptions() != null
+                    && Boolean.TRUE.equals(update.contextOptions().replayChildren()));
         }
 
         return detailsBuilder.build();
diff --git a/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/local/ReplayChildrenPruning.java b/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/local/ReplayChildrenPruning.java
new file mode 100644
index 000000000..e8f414e08
--- /dev/null
+++ b/sdk-testing/src/main/java/software/amazon/lambda/durable/testing/local/ReplayChildrenPruning.java
@@ -0,0 +1,65 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.testing.local;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import software.amazon.awssdk.services.lambda.model.Operation;
+import software.amazon.awssdk.services.lambda.model.OperationStatus;
+import software.amazon.awssdk.services.lambda.model.OperationType;
+
+/** Service visibility for invocation input and GetDurableExecutionState, without changing stored operations. */
+final class ReplayChildrenPruning {
+    private ReplayChildrenPruning() {}
+
+    static List<Operation> visibleOperations(List<Operation> operations) {
+        var byId = new HashMap<String, Operation>();
+        for (var operation : operations) {
+            if (operation.id() != null && !operation.id().isEmpty()) byId.put(operation.id(), operation);
+        }
+        var omitted = new HashMap<String, Boolean>();
+        var visible = new ArrayList<Operation>();
+        for (var operation : operations) {
+            if (!hasPruningAncestor(operation, byId, omitted)) visible.add(operation);
+        }
+        return List.copyOf(visible);
+    }
+
+    private static boolean hasPruningAncestor(
+            Operation operation, Map<String, Operation> byId, Map<String, Boolean> omitted) {
+        var chain = new ArrayList<String>();
+        var visited = new HashSet<String>();
+        var current = operation;
+        var hidden = false;
+        while (current.parentId() != null && !current.parentId().isEmpty()) {
+            if (current.id() != null) {
+                var known = omitted.get(current.id());
+                if (known != null) {
+                    hidden = known;
+                    break;
+                }
+                if (!visited.add(current.id())) break;
+                chain.add(current.id());
+            }
+            var parent = byId.get(current.parentId());
+            if (parent == null) break; // Missing ancestry does not prove that an operation must be omitted.
+            if (prunesChildren(parent)) {
+                hidden = true;
+                break;
+            }
+            current = parent;
+        }
+        for (var id : chain) omitted.put(id, hidden);
+        return hidden;
+    }
+
+    private static boolean prunesChildren(Operation operation) {
+        return operation.type() == OperationType.CONTEXT
+                && (operation.status() == OperationStatus.SUCCEEDED || operation.status() == OperationStatus.FAILED)
+                && (operation.contextDetails() == null
+                        || !Boolean.TRUE.equals(operation.contextDetails().replayChildren()));
+    }
+}
diff --git a/sdk-testing/src/test/java/software/amazon/lambda/durable/testing/ReplayChildrenInputTest.java b/sdk-testing/src/test/java/software/amazon/lambda/durable/testing/ReplayChildrenInputTest.java
new file mode 100644
index 000000000..c6a94a732
--- /dev/null
+++ b/sdk-testing/src/test/java/software/amazon/lambda/durable/testing/ReplayChildrenInputTest.java
@@ -0,0 +1,143 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.testing;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.jupiter.api.Test;
+import software.amazon.lambda.durable.DurableConfig;
+import software.amazon.lambda.durable.DurableContext;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.plugin.DurableExecutionPlugin;
+import software.amazon.lambda.durable.plugin.InvocationInfo;
+
+class ReplayChildrenInputTest {
+    private static final String LEFT = "a".repeat(140_000);
+    private static final String RIGHT = "b".repeat(140_000);
+
+    @Test
+    void completedContextChildrenAreAbsentFromRealResumeInputButRemainInspectable() {
+        var starts = new CopyOnWriteArrayList<InvocationInfo>();
+        var steps = new AtomicInteger();
+        var bodies = new AtomicInteger();
+        var runner = LocalDurableTestRunner.create(
+                String.class,
+                (input, context) -> {
+                    var saved = context.runInChildContext("saved-child", String.class, child -> {
+                        bodies.incrementAndGet();
+                        return child.step("saved-step", String.class, step -> {
+                            steps.incrementAndGet();
+                            return "saved";
+                        });
+                    });
+                    context.wait("pause", Duration.ofSeconds(1));
+                    return saved;
+                },
+                config(starts));
+
+        assertEquals(ExecutionStatus.PENDING, runner.run("input").getStatus());
+        runner.advanceTime();
+        var result = runner.run("input");
+        assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+        assertEquals("saved", result.getResult(String.class));
+        assertEquals(2, starts.size());
+        assertTrue(names(starts.get(1)).containsAll(List.of("saved-child", "pause")));
+        assertFalse(names(starts.get(1)).contains("saved-step"));
+        assertEquals(1, steps.get());
+        assertEquals(1, bodies.get());
+        assertEquals("saved", runner.getOperation("saved-step").getStepResult(String.class));
+    }
+
+    @Test
+    void largeChildResultRetainsItsStepsAndRebuildsWithoutRepeatingThem() {
+        var starts = new CopyOnWriteArrayList<InvocationInfo>();
+        var steps = new AtomicInteger();
+        var bodies = new AtomicInteger();
+        var runner = LocalDurableTestRunner.create(
+                String.class,
+                (input, context) -> {
+                    var saved = context.runInChildContext("retained", String.class, child -> {
+                        bodies.incrementAndGet();
+                        return largeChild(child, steps);
+                    });
+                    context.wait("pause", Duration.ofSeconds(1));
+                    return saved.length(); // Keep the root execution result small.
+                },
+                config(starts));
+
+        assertEquals(ExecutionStatus.PENDING, runner.run("input").getStatus());
+        runner.advanceTime();
+        var result = runner.run("input");
+        assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+        assertEquals(LEFT.length() + RIGHT.length(), result.getResult(Integer.class));
+        assertEquals(2, starts.size());
+        assertTrue(names(starts.get(1)).containsAll(List.of("retained", "left", "right", "pause")));
+        assertEquals(2, bodies.get());
+        assertEquals(2, steps.get());
+    }
+
+    @Test
+    void completedOuterContextPrunesEvenAnInnerContextThatRetainsChildren() {
+        var starts = new CopyOnWriteArrayList<InvocationInfo>();
+        var steps = new AtomicInteger();
+        var bodies = new AtomicInteger();
+        var runner = LocalDurableTestRunner.create(
+                String.class,
+                (input, context) -> {
+                    var length = context.runInChildContext("outer", Integer.class, outer -> {
+                        bodies.incrementAndGet();
+                        return outer.runInChildContext("inner", String.class, inner -> largeChild(inner, steps))
+                                .length();
+                    });
+                    context.wait("pause", Duration.ofSeconds(1));
+                    return length;
+                },
+                config(starts));
+
+        assertEquals(ExecutionStatus.PENDING, runner.run("input").getStatus());
+        runner.advanceTime();
+        var result = runner.run("input");
+        assertEquals(ExecutionStatus.SUCCEEDED, result.getStatus());
+        assertEquals(LEFT.length() + RIGHT.length(), result.getResult(Integer.class));
+        assertEquals(2, starts.size());
+        var delivered = names(starts.get(1));
+        assertTrue(delivered.containsAll(List.of("outer", "pause")));
+        for (var omitted : List.of("inner", "left", "right")) assertFalse(delivered.contains(omitted), omitted);
+        assertEquals(1, bodies.get());
+        assertEquals(2, steps.get());
+        assertEquals(LEFT, runner.getOperation("left").getStepResult(String.class));
+    }
+
+    private static String largeChild(DurableContext child, AtomicInteger calls) {
+        // Each step remains below the service payload limit; only the combined context result exceeds it.
+        var left = child.step("left", String.class, step -> {
+            calls.incrementAndGet();
+            return LEFT;
+        });
+        var right = child.step("right", String.class, step -> {
+            calls.incrementAndGet();
+            return RIGHT;
+        });
+        return left + right;
+    }
+
+    private static DurableConfig config(List<InvocationInfo> starts) {
+        return DurableConfig.builder()
+                .withPlugins(new DurableExecutionPlugin() {
+                    public void onInvocationStart(InvocationInfo info) {
+                        starts.add(info);
+                    }
+                })
+                .build();
+    }
+
+    private static List<String> names(InvocationInfo info) {
+        return info.operations().values().stream()
+                .map(operation -> operation.name())
+                .toList();
+    }
+}
diff --git a/sdk-testing/src/test/java/software/amazon/lambda/durable/testing/local/ContextReplayChildrenOptionsTest.java b/sdk-testing/src/test/java/software/amazon/lambda/durable/testing/local/ContextReplayChildrenOptionsTest.java
new file mode 100644
index 000000000..807ba2467
--- /dev/null
+++ b/sdk-testing/src/test/java/software/amazon/lambda/durable/testing/local/ContextReplayChildrenOptionsTest.java
@@ -0,0 +1,49 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.testing.local;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import software.amazon.awssdk.services.lambda.model.ContextOptions;
+import software.amazon.awssdk.services.lambda.model.OperationAction;
+import software.amazon.awssdk.services.lambda.model.OperationType;
+import software.amazon.awssdk.services.lambda.model.OperationUpdate;
+
+class ContextReplayChildrenOptionsTest {
+    @ParameterizedTest
+    @ValueSource(strings = {"absent", "false", "true"})
+    void startDoesNotRecordReplayChildren(String option) {
+        var started = OperationProcessor.applyUpdate(update(OperationAction.START, option), null);
+        assertNull(started.contextDetails().replayChildren());
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+        "SUCCEED,absent,false",
+        "SUCCEED,false,false",
+        "SUCCEED,true,true",
+        "FAIL,absent,false",
+        "FAIL,false,false",
+        "FAIL,true,true"
+    })
+    void closingUpdateAloneDeterminesReplayChildren(OperationAction action, String option, boolean expected) {
+        var started = OperationProcessor.applyUpdate(update(OperationAction.START, "true"), null);
+        var closed = OperationProcessor.applyUpdate(update(action, option), started);
+        assertEquals(expected, closed.contextDetails().replayChildren());
+    }
+
+    private static OperationUpdate update(OperationAction action, String option) {
+        var builder = OperationUpdate.builder()
+                .id("context")
+                .type(OperationType.CONTEXT)
+                .action(action);
+        if (!option.equals("absent"))
+            builder.contextOptions(ContextOptions.builder()
+                    .replayChildren(Boolean.parseBoolean(option))
+                    .build());
+        return builder.build();
+    }
+}
diff --git a/sdk-testing/src/test/java/software/amazon/lambda/durable/testing/local/ReplayChildrenPruningTest.java b/sdk-testing/src/test/java/software/amazon/lambda/durable/testing/local/ReplayChildrenPruningTest.java
new file mode 100644
index 000000000..f4525abf1
--- /dev/null
+++ b/sdk-testing/src/test/java/software/amazon/lambda/durable/testing/local/ReplayChildrenPruningTest.java
@@ -0,0 +1,139 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.testing.local;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import software.amazon.awssdk.services.lambda.model.ContextDetails;
+import software.amazon.awssdk.services.lambda.model.Operation;
+import software.amazon.awssdk.services.lambda.model.OperationAction;
+import software.amazon.awssdk.services.lambda.model.OperationStatus;
+import software.amazon.awssdk.services.lambda.model.OperationType;
+import software.amazon.awssdk.services.lambda.model.OperationUpdate;
+
+class ReplayChildrenPruningTest {
+    // The service test tree also reproduced by JS PR #1002.
+    private static final List<Operation> TREE = List.of(
+            step("1-step", null),
+            context("2-context", null, OperationStatus.STARTED, null),
+            step("2.1-step", "2-context").toBuilder()
+                    .status(OperationStatus.PENDING)
+                    .build(),
+            step("3-step", "missing-parent"),
+            context("4-context", null, OperationStatus.FAILED, null),
+            context("4.1-context", "4-context", OperationStatus.FAILED, true),
+            step("4.1.1-step", "4.1-context"),
+            step("4.1.2-step", "4.1-context"),
+            context("5-context", null, OperationStatus.SUCCEEDED, true),
+            context("5.1-context", "5-context", OperationStatus.SUCCEEDED, false),
+            step("5.1.1-step", "5.1-context"),
+            step("5.1-step", "5-context"));
+    private static final List<String> VISIBLE =
+            List.of("1-step", "2-context", "2.1-step", "3-step", "4-context", "5-context", "5.1-context", "5.1-step");
+
+    @Test
+    void matchesTheServiceTreeWithoutChangingStoredOperations() {
+        assertEquals(VISIBLE, ids(ReplayChildrenPruning.visibleOperations(TREE)));
+        assertEquals(12, TREE.size());
+        assertEquals(OperationStatus.FAILED, TREE.get(4).status());
+    }
+
+    @Test
+    void descendantsMayAppearBeforeTheirAncestors() {
+        var reversed = new ArrayList<>(TREE);
+        Collections.reverse(reversed);
+        var expected = new ArrayList<>(VISIBLE);
+        Collections.reverse(expected);
+        assertEquals(expected, ids(ReplayChildrenPruning.visibleOperations(reversed)));
+    }
+
+    @Test
+    void startedIntermediateContextDoesNotHideACompletedAncestor() {
+        var operations = List.of(
+                step("leaf", "running"),
+                context("running", "completed", OperationStatus.STARTED, true),
+                context("completed", null, OperationStatus.SUCCEEDED, null));
+        assertEquals(List.of("completed"), ids(ReplayChildrenPruning.visibleOperations(operations)));
+    }
+
+    @Test
+    void runningContextsAndUnknownParentsRemainVisible() {
+        var operations = List.of(
+                step("leaf", "running"),
+                context("running", null, OperationStatus.STARTED, false),
+                step("orphan", "absent"));
+        assertEquals(ids(operations), ids(ReplayChildrenPruning.visibleOperations(operations)));
+    }
+
+    @Test
+    void malformedParentCycleTerminatesWithoutMutatingTheStore() {
+        var operations = List.of(
+                context("a", "b", OperationStatus.STARTED, null), context("b", "a", OperationStatus.STARTED, null));
+        assertEquals(List.of("a", "b"), ids(ReplayChildrenPruning.visibleOperations(operations)));
+    }
+
+    @Test
+    void statePruningDoesNotFilterCheckpointResponsesOrUpdatedIds() {
+        var client = new LocalMemoryExecutionClient();
+        var parent = OperationUpdate.builder().id("parent").name("parent").type(OperationType.CONTEXT);
+        var callback = OperationUpdate.builder()
+                .id("callback")
+                .name("external")
+                .parentId("parent")
+                .type(OperationType.CALLBACK)
+                .action(OperationAction.START)
+                .build();
+        client.checkpoint(
+                "arn", "token", List.of(parent.action(OperationAction.START).build(), callback));
+        client.checkpoint(
+                "arn",
+                "token",
+                List.of(parent.action(OperationAction.SUCCEED)
+                        .payload("\"saved\"")
+                        .build()));
+        client.completeCallback(client.getCallbackId("external"), OperationResult.succeeded("\"done\""));
+
+        var delivered = client.getExecutionState("arn", "token", null);
+        assertEquals(List.of("parent"), ids(delivered.operations()));
+        assertNull(delivered.nextMarker());
+        assertEquals(List.of("callback"), client.getUpdatedOperationIdsSinceLastInvocation());
+        assertEquals(List.of("parent", "callback"), ids(client.getAllOperations()));
+        assertEquals(
+                OperationStatus.SUCCEEDED, client.getOperationByName("external").status());
+        assertEquals(
+                "\"done\"",
+                client.getOperationByName("external").callbackDetails().result());
+        var response = client.checkpoint("arn", "token", List.of());
+        assertEquals(List.of("callback"), ids(response.newExecutionState().operations()));
+        assertEquals(
+                List.of("parent"),
+                ids(client.getExecutionState("arn", "token", null).operations()));
+    }
+
+    private static List<String> ids(List<Operation> operations) {
+        return operations.stream().map(Operation::id).toList();
+    }
+
+    private static Operation step(String id, String parent) {
+        return Operation.builder()
+                .id(id)
+                .parentId(parent)
+                .type(OperationType.STEP)
+                .status(OperationStatus.SUCCEEDED)
+                .build();
+    }
+
+    private static Operation context(String id, String parent, OperationStatus status, Boolean replay) {
+        return Operation.builder()
+                .id(id)
+                .parentId(parent)
+                .type(OperationType.CONTEXT)
+                .status(status)
+                .contextDetails(ContextDetails.builder().replayChildren(replay).build())
+                .build();
+    }
+}
diff --git a/sdk/src/main/java/software/amazon/lambda/durable/DurableContext.java b/sdk/src/main/java/software/amazon/lambda/durable/DurableContext.java
index ce6eb7070..eb35f8be0 100644
--- a/sdk/src/main/java/software/amazon/lambda/durable/DurableContext.java
+++ b/sdk/src/main/java/software/amazon/lambda/durable/DurableContext.java
@@ -18,6 +18,7 @@
 import software.amazon.lambda.durable.config.WaitForConditionConfig;
 import software.amazon.lambda.durable.config.WithRetryConfig;
 import software.amazon.lambda.durable.context.BaseContext;
+import software.amazon.lambda.durable.exception.ChildContextFailedException;
 import software.amazon.lambda.durable.model.MapResult;
 import software.amazon.lambda.durable.model.WaitForConditionResult;
 
@@ -549,6 +550,10 @@ default ParallelDurableFuture parallel(String name) {
      * <p>Combines a step (to run the submitter) and a callback (to receive the external result) in a child context. The
      * submitter receives a callback ID that external systems use to report completion.
      *
+     * <p>If a failed child is replayed without its nested operation details and its original exception cannot be
+     * reconstructed, {@link ChildContextFailedException} carries the stored context failure. The SDK does not guess
+     * whether the missing callback or submitter caused it, and does not rerun the completed child.
+     *
      * @param <T> the result type
      * @param name the unique operation name within this context
      * @param resultType the result class for deserialization
@@ -625,6 +630,9 @@ default <T> DurableFuture<T> waitForCallbackAsync(
      * delegate here. Internally creates a child context containing a callback operation and a step that runs the
      * submitter function.
      *
+     * <p>Retrieving a failed replay's result can report {@link ChildContextFailedException} when nested operation
+     * details are no longer available and the original exception cannot be reconstructed.
+     *
      * @param <T> the result type
      * @param name the unique operation name within this context
      * @param resultType the type token for deserialization of generic result types
diff --git a/sdk/src/main/java/software/amazon/lambda/durable/operation/BaseDurableOperation.java b/sdk/src/main/java/software/amazon/lambda/durable/operation/BaseDurableOperation.java
index 31c992615..ecefc5736 100644
--- a/sdk/src/main/java/software/amazon/lambda/durable/operation/BaseDurableOperation.java
+++ b/sdk/src/main/java/software/amazon/lambda/durable/operation/BaseDurableOperation.java
@@ -573,8 +573,8 @@ protected void fireOnOperationEnd(Operation operation, Throwable error, boolean
     }
 
     /**
-     * Extracts the error from a terminal operation as a Throwable. Returns null if the operation succeeded or has no
-     * error details.
+     * Extracts an error for plugin metadata from a failed, timed-out, or stopped operation. Other statuses and an
+     * absent error container return null. A present container remains represented even when it has no members.
      */
     public static Throwable extractErrorFromOperation(Operation operation) {
         if (operation.status() != OperationStatus.FAILED
diff --git a/sdk/src/main/java/software/amazon/lambda/durable/operation/ChildContextOperation.java b/sdk/src/main/java/software/amazon/lambda/durable/operation/ChildContextOperation.java
index 8c299cfa4..8a16ea758 100644
--- a/sdk/src/main/java/software/amazon/lambda/durable/operation/ChildContextOperation.java
+++ b/sdk/src/main/java/software/amazon/lambda/durable/operation/ChildContextOperation.java
@@ -253,7 +253,7 @@ private Throwable translateException(Operation op, ErrorObject errorObject) {
 
         // throw a general failed exception if a user exception is not reconstructed
         return switch (getSubType()) {
-            case WAIT_FOR_CALLBACK -> handleWaitForCallbackFailure();
+            case WAIT_FOR_CALLBACK -> handleWaitForCallbackFailure(op);
             case MAP_ITERATION -> new MapIterationFailedException(op);
             case PARALLEL_BRANCH -> new ParallelBranchFailedException(op);
             case RUN_IN_CHILD_CONTEXT, WITH_RETRY -> new ChildContextFailedException(op);
@@ -274,7 +274,7 @@ private Operation createVirtualOperation(ErrorObject errorObject) {
                 .build();
     }
 
-    private Throwable handleWaitForCallbackFailure() {
+    private Throwable handleWaitForCallbackFailure(Operation failedContext) {
         var childrenOps = getChildOperations();
         var callbackOp = childrenOps.stream()
                 .filter(o -> o.type() == OperationType.CALLBACK)
@@ -284,32 +284,35 @@ private Throwable handleWaitForCallbackFailure() {
                 .filter(o -> o.type() == OperationType.STEP)
                 .findFirst()
                 .orElse(null);
-        if (callbackOp != null) {
-            // if callback failed
-            if (isTerminalStatus(callbackOp.status())) {
-                switch (callbackOp.status()) {
-                    case FAILED -> {
-                        return new CallbackFailedException(callbackOp);
-                    }
-                    case TIMED_OUT -> {
-                        return new CallbackTimeoutException(callbackOp);
-                    }
-                }
-            }
+        var knownFailure = knownWaitForCallbackFailure(callbackOp, submitterOp);
+        if (knownFailure != null) return knownFailure;
 
-            // if submitter failed
-            if (submitterOp != null
-                    && isTerminalStatus(submitterOp.status())
-                    && submitterOp.status() != OperationStatus.SUCCEEDED) {
-                var stepError = submitterOp.stepDetails().error();
-                if (StepInterruptedException.isStepInterruptedException(stepError)) {
-                    return new CallbackSubmitterException(callbackOp, new StepInterruptedException(submitterOp));
-                } else {
-                    return new CallbackSubmitterException(callbackOp, new StepFailedException(submitterOp));
-                }
-            }
+        // Completed child contexts may replay without their nested operations.
+        // Report the stored context failure without guessing its callback/submitter
+        // category or fabricating the child operation that is no longer available.
+        if (callbackOp == null
+                || callbackOp.callbackDetails() == null
+                || submitterOp == null
+                || submitterOp.stepDetails() == null) {
+            return new ChildContextFailedException(failedContext);
         }
 
         return new IllegalStateException("Unknown waitForCallback status");
     }
+
+    private Throwable knownWaitForCallbackFailure(Operation callbackOp, Operation submitterOp) {
+        if (callbackOp == null || callbackOp.callbackDetails() == null) return null;
+        if (callbackOp.status() == OperationStatus.FAILED) return new CallbackFailedException(callbackOp);
+        if (callbackOp.status() == OperationStatus.TIMED_OUT) return new CallbackTimeoutException(callbackOp);
+        if (submitterOp == null
+                || submitterOp.stepDetails() == null
+                || !isTerminalStatus(submitterOp.status())
+                || submitterOp.status() == OperationStatus.SUCCEEDED) return null;
+
+        var stepError = submitterOp.stepDetails().error();
+        var stepFailure = StepInterruptedException.isStepInterruptedException(stepError)
+                ? new StepInterruptedException(submitterOp)
+                : new StepFailedException(submitterOp);
+        return new CallbackSubmitterException(callbackOp, stepFailure);
+    }
 }
diff --git a/sdk/src/test/java/software/amazon/lambda/durable/operation/WaitForCallbackPrunedReplayTest.java b/sdk/src/test/java/software/amazon/lambda/durable/operation/WaitForCallbackPrunedReplayTest.java
new file mode 100644
index 000000000..343ee8e9a
--- /dev/null
+++ b/sdk/src/test/java/software/amazon/lambda/durable/operation/WaitForCallbackPrunedReplayTest.java
@@ -0,0 +1,236 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.operation;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.jupiter.api.Timeout;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import software.amazon.awssdk.services.lambda.model.*;
+import software.amazon.lambda.durable.DurableConfig;
+import software.amazon.lambda.durable.TypeToken;
+import software.amazon.lambda.durable.client.DurableExecutionClient;
+import software.amazon.lambda.durable.exception.CallbackFailedException;
+import software.amazon.lambda.durable.exception.CallbackSubmitterException;
+import software.amazon.lambda.durable.exception.CallbackTimeoutException;
+import software.amazon.lambda.durable.exception.ChildContextFailedException;
+import software.amazon.lambda.durable.exception.StepFailedException;
+import software.amazon.lambda.durable.execution.DurableExecutor;
+import software.amazon.lambda.durable.execution.OperationIdGenerator;
+import software.amazon.lambda.durable.model.DurableExecutionInput;
+import software.amazon.lambda.durable.model.ExecutionStatus;
+import software.amazon.lambda.durable.serde.JacksonSerDes;
+
+/** Exercises the public wait API with the terminal parent snapshot returned after backend child pruning. */
+@Timeout(15)
+class WaitForCallbackPrunedReplayTest {
+    private static final String NAME = "failed-wait";
+    private static final String PARENT_ID = OperationIdGenerator.hashOperationId("1");
+    private static final ErrorObject CHECKPOINT_ERROR = ErrorObject.builder()
+            .errorType("RemoteFailure")
+            .errorMessage("original parent failure")
+            .errorData("{\"remote\":true}")
+            .build();
+
+    @ParameterizedTest
+    @ValueSource(
+            strings = {
+                "parent-only-null",
+                "parent-only-empty",
+                "parent-only-details",
+                "missing-callback",
+                "missing-callback-details",
+                "missing-submitter-details",
+                "missing-pending-submitter",
+                "failed-callback-without-submitter",
+                "timed-out-callback-without-submitter",
+                "failed-submitter",
+                "reconstructible-original",
+                "complete-unrecognized-state"
+            })
+    void replayPreservesKnownFailureOrActualFailedParentWithoutExecutingBody(String scenario) throws Exception {
+        var state = state(scenario);
+        var checkpointClient = mock(DurableExecutionClient.class);
+        var submitterCalls = new AtomicInteger();
+        var observed = new AtomicReference<RuntimeException>();
+        var workers = Executors.newSingleThreadExecutor();
+        try {
+            var config = DurableConfig.builder()
+                    .withDurableExecutionClient(checkpointClient)
+                    .withExecutorService(workers)
+                    .build();
+            var result = DurableExecutor.execute(
+                    input(state),
+                    null,
+                    TypeToken.get(String.class),
+                    (value, context) -> {
+                        try {
+                            context.waitForCallback(
+                                    NAME, String.class, (callbackId, step) -> submitterCalls.incrementAndGet());
+                            return "unexpected-success";
+                        } catch (CallbackFailedException
+                                | CallbackTimeoutException
+                                | CallbackSubmitterException
+                                | ChildContextFailedException
+                                | IllegalArgumentException expectedPublicFailure) {
+                            observed.set(expectedPublicFailure);
+                            return "caught";
+                        }
+                    },
+                    config);
+            System.out.println("PRUNED_REPLAY scenario=" + scenario + " status=" + result.status()
+                    + " observed="
+                    + (observed.get() == null ? null : observed.get().getClass().getName())
+                    + " error=" + result.error());
+            assertEquals(0, submitterCalls.get());
+            verifyNoInteractions(checkpointClient);
+            if (scenario.equals("complete-unrecognized-state")) {
+                assertEquals(ExecutionStatus.FAILED, result.status());
+                assertEquals(
+                        IllegalStateException.class.getName(), result.error().errorType());
+                assertEquals("Unknown waitForCallback status", result.error().errorMessage());
+                assertNull(observed.get());
+                return;
+            }
+            assertEquals(ExecutionStatus.SUCCEEDED, result.status(), () -> "unexpected API failure: " + result.error());
+            assertEquals("\"caught\"", result.result());
+            assertNull(result.error());
+            checkFailure(scenario, state, observed.get());
+        } finally {
+            workers.shutdown();
+            assertTrue(workers.awaitTermination(5, TimeUnit.SECONDS));
+        }
+    }
+
+    private static void checkFailure(String scenario, Snapshot state, RuntimeException observed) {
+        if (scenario.equals("reconstructible-original")) {
+            assertInstanceOf(IllegalArgumentException.class, observed);
+            assertEquals("saved original", observed.getMessage());
+        } else if (scenario.equals("failed-callback-without-submitter")) {
+            var failure = assertInstanceOf(CallbackFailedException.class, observed);
+            assertSame(state.children().get(0), failure.getOperation());
+            assertSame(CHECKPOINT_ERROR, failure.getErrorObject());
+            assertEquals("callback-id", failure.getCallbackId());
+        } else if (scenario.equals("timed-out-callback-without-submitter")) {
+            var failure = assertInstanceOf(CallbackTimeoutException.class, observed);
+            assertSame(state.children().get(0), failure.getOperation());
+            assertEquals("callback-id", failure.getCallbackId());
+        } else if (scenario.equals("failed-submitter")) {
+            var failure = assertInstanceOf(CallbackSubmitterException.class, observed);
+            assertSame(state.children().get(0), failure.getOperation());
+            var cause = assertInstanceOf(StepFailedException.class, failure.getCause());
+            assertSame(state.children().get(1), cause.getOperation());
+            assertSame(CHECKPOINT_ERROR, cause.getErrorObject());
+        } else {
+            var failure = assertInstanceOf(ChildContextFailedException.class, observed);
+            assertSame(state.parent(), failure.getOperation(), "fallback must identify the actual checkpointed parent");
+            assertSame(
+                    state.parent().contextDetails().error(),
+                    failure.getErrorObject(),
+                    "retain the original checkpoint error");
+            assertEquals(PARENT_ID, failure.getOperationId());
+            assertEquals(OperationStatus.FAILED, failure.getOperationStatus());
+            assertNull(failure.getCause(), "do not invent a callback/submitter category");
+        }
+    }
+
+    private static Snapshot state(String scenario) {
+        var error = scenario.equals("parent-only-null")
+                ? null
+                : scenario.equals("parent-only-empty") ? ErrorObject.builder().build() : CHECKPOINT_ERROR;
+        if (scenario.equals("reconstructible-original")) {
+            var original = new IllegalArgumentException("saved original");
+            error = ErrorObject.builder()
+                    .errorType(original.getClass().getName())
+                    .errorMessage(original.getMessage())
+                    .errorData(new JacksonSerDes().serialize(original))
+                    .build();
+        }
+        var parent = Operation.builder()
+                .id(PARENT_ID)
+                .name(NAME)
+                .type(OperationType.CONTEXT)
+                .subType("WaitForCallback")
+                .status(OperationStatus.FAILED)
+                .startTimestamp(Instant.ofEpochSecond(1))
+                .endTimestamp(Instant.ofEpochSecond(2))
+                .contextDetails(ContextDetails.builder().error(error).build())
+                .build();
+        var children = switch (scenario) {
+            case "missing-callback" -> List.of(submitter(OperationStatus.SUCCEEDED, true));
+            case "missing-callback-details" ->
+                List.of(callback(OperationStatus.FAILED, false), submitter(OperationStatus.SUCCEEDED, true));
+            case "missing-submitter-details" ->
+                List.of(callback(OperationStatus.STARTED, true), submitter(OperationStatus.FAILED, false));
+            case "missing-pending-submitter" -> List.of(callback(OperationStatus.STARTED, true));
+            case "failed-callback-without-submitter" -> List.of(callback(OperationStatus.FAILED, true));
+            case "timed-out-callback-without-submitter" -> List.of(callback(OperationStatus.TIMED_OUT, true));
+            case "failed-submitter" ->
+                List.of(callback(OperationStatus.STARTED, true), submitter(OperationStatus.FAILED, true));
+            case "complete-unrecognized-state" ->
+                List.of(callback(OperationStatus.SUCCEEDED, true), submitter(OperationStatus.SUCCEEDED, true));
+            default -> List.<Operation>of();
+        };
+        return new Snapshot(parent, children);
+    }
+
+    private static Operation callback(OperationStatus status, boolean details) {
+        return Operation.builder()
+                .id("callback")
+                .parentId(PARENT_ID)
+                .name(NAME + "-callback")
+                .type(OperationType.CALLBACK)
+                .subType("Callback")
+                .status(status)
+                .callbackDetails(
+                        details
+                                ? CallbackDetails.builder()
+                                        .callbackId("callback-id")
+                                        .error(CHECKPOINT_ERROR)
+                                        .build()
+                                : null)
+                .build();
+    }
+
+    private static Operation submitter(OperationStatus status, boolean details) {
+        return Operation.builder()
+                .id("submitter")
+                .parentId(PARENT_ID)
+                .name(NAME + "-submitter")
+                .type(OperationType.STEP)
+                .subType("Step")
+                .status(status)
+                .stepDetails(
+                        details ? StepDetails.builder().error(CHECKPOINT_ERROR).build() : null)
+                .build();
+    }
+
+    private static DurableExecutionInput input(Snapshot state) {
+        var execution = Operation.builder()
+                .id("execution")
+                .type(OperationType.EXECUTION)
+                .status(OperationStatus.STARTED)
+                .startTimestamp(Instant.ofEpochSecond(1))
+                .executionDetails(
+                        ExecutionDetails.builder().inputPayload("\"input\"").build())
+                .build();
+        var operations = new ArrayList<>(List.of(execution, state.parent()));
+        operations.addAll(state.children());
+        return new DurableExecutionInput(
+                "arn:pruned/execution",
+                "token",
+                CheckpointUpdatedExecutionState.builder().operations(operations).build(),
+                List.of());
+    }
+
+    private record Snapshot(Operation parent, List<Operation> children) {}
+}
diff --git a/sdk/src/test/java/software/amazon/lambda/durable/plugin/OperationErrorMetadataTest.java b/sdk/src/test/java/software/amazon/lambda/durable/plugin/OperationErrorMetadataTest.java
new file mode 100644
index 000000000..aa02371e0
--- /dev/null
+++ b/sdk/src/test/java/software/amazon/lambda/durable/plugin/OperationErrorMetadataTest.java
@@ -0,0 +1,85 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+package software.amazon.lambda.durable.plugin;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import software.amazon.awssdk.services.lambda.model.CallbackDetails;
+import software.amazon.awssdk.services.lambda.model.ChainedInvokeDetails;
+import software.amazon.awssdk.services.lambda.model.ContextDetails;
+import software.amazon.awssdk.services.lambda.model.ErrorObject;
+import software.amazon.awssdk.services.lambda.model.Operation;
+import software.amazon.awssdk.services.lambda.model.OperationStatus;
+import software.amazon.awssdk.services.lambda.model.OperationType;
+import software.amazon.awssdk.services.lambda.model.StepDetails;
+import software.amazon.lambda.durable.exception.DurableOperationException;
+import software.amazon.lambda.durable.operation.BaseDurableOperation;
+
+class OperationErrorMetadataTest {
+    static Stream<Arguments> terminalErrors() {
+        return Stream.of(
+                        OperationType.STEP, OperationType.CHAINED_INVOKE, OperationType.CALLBACK, OperationType.CONTEXT)
+                .flatMap(type -> Stream.of(OperationStatus.FAILED, OperationStatus.TIMED_OUT, OperationStatus.STOPPED)
+                        .flatMap(status -> Stream.of(
+                                Arguments.of(type, status, "omitted", null, false),
+                                Arguments.of(
+                                        type,
+                                        status,
+                                        "empty",
+                                        ErrorObject.builder().build(),
+                                        true),
+                                Arguments.of(
+                                        type,
+                                        status,
+                                        "details",
+                                        ErrorObject.builder()
+                                                .errorMessage("failure")
+                                                .build(),
+                                        true))));
+    }
+
+    @ParameterizedTest(name = "{0}/{1}/{2}")
+    @MethodSource("terminalErrors")
+    void snapshotMetadataDoesNotMutateStoredFailure(
+            OperationType type, OperationStatus status, String label, ErrorObject error, boolean hasErrorContainer) {
+        var operation = operation(type, status, error);
+        var saved = operation.toBuilder().build();
+        var info = PluginInfoConverter.toOperationItemMap(List.of(operation), Set.of(operation.id()))
+                .get(operation.id());
+        assertEquals(status, info.status());
+        assertTrue(info.isReplay());
+        assertNull(info.result());
+        if (hasErrorContainer) {
+            var failure = assertInstanceOf(DurableOperationException.class, info.error());
+            assertSame(error, failure.getErrorObject());
+            assertSame(operation, failure.getOperation());
+        } else {
+            assertNull(info.error(), "an omitted error container retains the existing null metadata behavior");
+        }
+        assertSame(error, BaseDurableOperation.getErrorObject(operation));
+        assertEquals(saved, operation, "metadata conversion must not rewrite the operation or its persisted error");
+    }
+
+    private static Operation operation(OperationType type, OperationStatus status, ErrorObject error) {
+        var builder =
+                Operation.builder().id("operation").name("operation").type(type).status(status);
+        switch (type) {
+            case STEP -> builder.stepDetails(StepDetails.builder().error(error).build());
+            case CHAINED_INVOKE ->
+                builder.chainedInvokeDetails(
+                        ChainedInvokeDetails.builder().error(error).build());
+            case CALLBACK ->
+                builder.callbackDetails(CallbackDetails.builder().error(error).build());
+            case CONTEXT ->
+                builder.contextDetails(ContextDetails.builder().error(error).build());
+            default -> throw new IllegalArgumentException("Unsupported test operation type: " + type);
+        }
+        return builder.build();
+    }
+}
diff --git a/sdk/src/test/java/software/amazon/lambda/durable/serde/DurableInputOutputSerDesTest.java b/sdk/src/test/java/software/amazon/lambda/durable/serde/DurableInputOutputSerDesTest.java
index d64a88665..35b22b792 100644
--- a/sdk/src/test/java/software/amazon/lambda/durable/serde/DurableInputOutputSerDesTest.java
+++ b/sdk/src/test/java/software/amazon/lambda/durable/serde/DurableInputOutputSerDesTest.java
@@ -22,6 +22,55 @@ void setUp() {
         serDes = new DurableInputOutputSerDes();
     }
 
+    @Test
+    void callbackCheckpointWirePreservesOmittedAndEmptyErrorShapes() {
+        var template = """
+                {"DurableExecutionArn":"arn:aws:lambda:us-east-1:123456789012:function:test:$LATEST/durable-execution/name/id",
+                 "CheckpointToken":"test-token", "UpdatedOperationIds":["callback"],
+                 "InitialExecutionState":{"Operations":[{"Id":"callback","Type":"CALLBACK","Status":"FAILED",
+                 "CallbackDetails":{"CallbackId":"test-only-token"%s}}]}}
+                """;
+        var absent = serDes.deserialize(template.formatted(""), TypeToken.get(DurableExecutionInput.class));
+        var empty =
+                serDes.deserialize(template.formatted(", \"Error\":{}"), TypeToken.get(DurableExecutionInput.class));
+        var explicitNull =
+                serDes.deserialize(template.formatted(", \"Error\":null"), TypeToken.get(DurableExecutionInput.class));
+        var details = serDes.deserialize(
+                template.formatted(", \"Error\":{\"ErrorMessage\":\"failed\"}"),
+                TypeToken.get(DurableExecutionInput.class));
+        assertNull(absent.initialExecutionState()
+                .operations()
+                .get(0)
+                .callbackDetails()
+                .error());
+        assertNull(explicitNull
+                .initialExecutionState()
+                .operations()
+                .get(0)
+                .callbackDetails()
+                .error());
+        var emptyError = empty.initialExecutionState()
+                .operations()
+                .get(0)
+                .callbackDetails()
+                .error();
+        assertNotNull(emptyError);
+        assertNull(emptyError.errorType());
+        assertNull(emptyError.errorMessage());
+        assertNull(emptyError.errorData());
+        assertFalse(emptyError.hasStackTrace());
+        assertEquals(
+                "failed",
+                details.initialExecutionState()
+                        .operations()
+                        .get(0)
+                        .callbackDetails()
+                        .error()
+                        .errorMessage());
+        assertEquals(List.of("callback"), empty.updatedOperationIds());
+        // These legal wire inputs establish decoder behavior, not which shape the live service supplies.
+    }
+
     @Test
     void testObjectMapperSerializesPendingOutput() {
         var output = DurableExecutionOutput.pending();