feat(workflow): align history propagation API with go-sdk

Cassie (durabletask-go author) flagged the .NET surface for cross-SDK
divergence post-merge of dotnet-sdk#1802 / #1818. This rewrites the
public history-propagation API to match the go-sdk shape — same one the
python-sdk just adopted (python-sdk#1047). Issue dotnet-sdk#1801 was
closed before her review; this PR delivers what the issue originally
described.

Three concrete gaps closed:

1. Activity-level opt-in (was missing entirely)
   - PropagationScope moved from ChildWorkflowTaskOptions to base
     WorkflowTaskOptions; ChildWorkflowTaskOptions inherits it.
   - WithHistoryPropagation() extension method added on the base record.
   - scheduleTaskAction.HistoryPropagationScope is now wired in
     WorkflowOrchestrationContext.CallActivityInternalAsync so activities
     can opt into propagation, matching CallChildWorkflowInternalAsync.
   - Without this, the Go SDK's reference example (SettlePayment activity
     using PropagateOwnHistory) literally cannot be ported to .NET.

2. Read API rewritten as high-level resolvers (was lossy FilterBy* + a
   PropagatedHistoryEvent record that dropped input/output/failure
   payloads)
   - PropagatedHistory.FilterByAppId/InstanceId/WorkflowName removed.
   - PropagatedHistory now exposes GetWorkflows(), GetWorkflowsByName(),
     GetLastWorkflowByName(), GetAppIds(), GetWorkflowsByAppId(),
     GetWorkflowsByInstanceId().
   - New WorkflowResult class with InstanceId/AppId/Name plus
     GetActivitiesByName(), GetLastActivityByName(),
     GetChildWorkflowsByName(), GetLastChildWorkflowByName() — mirrors
     durabletask-go's GetLastWorkflowByName / GetLastActivityByName /
     GetLastChildWorkflowByName renames from durabletask-go#105.
   - New ActivityResult record carries Name, Started, Completed, Failed,
     Input, Output, FailureDetails — matching the Go/Python equivalents
     so chain-of-custody patterns line up.
   - New ChildWorkflowResult record with the equivalent shape.

3. Event payload preserved internally (was discarded by ConvertChunk)
   - ConvertChunk in WorkflowOrchestrationContext now parses raw events,
     walks them to resolve TaskScheduled <-> TaskCompleted/Failed and
     ChildWorkflowInstanceCreated <-> ChildWorkflowInstanceCompleted/
     Failed by scheduleId, and produces fully-populated ActivityResult /
     ChildWorkflowResult instances. SDK retries reuse TaskExecutionId so
     matching is on scheduleId (matching Go/Python semantics).
   - Public API does not leak the proto HistoryEvent type — resolution
     happens at construction time inside Dapr.Workflow.

Additional surface additions:

- PropagationNotFoundException for missing-name lookups (mirrors
  Python's PropagationNotFoundError / Go's error returns).
- Static WorkflowHistory.PropagateLineage() / PropagateOwnHistory()
  factory helpers for go-sdk call-site parity.

Removed (clean break — 1.18 unreleased): PropagatedHistoryEntry,
PropagatedHistoryEvent, HistoryEventKind, FilterByAppId,
FilterByInstanceId, FilterByWorkflowName.

Tests:

- WorkflowHistoryPropagationTests.cs rewritten end-to-end to cover the
  new resolvers, query helpers, factory helpers, activity-level scope
  wiring, and child-workflow-level scope wiring.
- HistoryPropagationWorkflowTests.cs (integration) updated to use
  GetWorkflows().Count in place of Entries.Count.

Refs: #1801, dapr/durabletask-go#105, dapr/go-sdk#823,
dapr/python-sdk#1047

Signed-off-by: Nelson Parente <nelson_parente@live.com.pt>

Co-authored-by: nelson-parente <20144601+nelson-parente@users.noreply.github.com>

Author: nelson-parente

src/Dapr.Workflow.Abstractions/ActivityResult.cs

@@ -0,0 +1,38 @@
+// ------------------------------------------------------------------------
+// Copyright 2026 The Dapr Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//     http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ------------------------------------------------------------------------
+
+namespace Dapr.Workflow;
+
+/// <summary>
+/// A reconstructed view of a single activity invocation from propagated history.
+/// </summary>
+/// <param name="Name">The scheduled name of the activity.</param>
+/// <param name="Started">Whether the activity was scheduled in the propagated chunk.</param>
+/// <param name="Completed">Whether the activity completed successfully.</param>
+/// <param name="Failed">Whether the activity failed.</param>
+/// <param name="Input">The JSON-encoded input payload, or <c>null</c> when unset.</param>
+/// <param name="Output">The JSON-encoded output payload, or <c>null</c> when the activity has not completed.</param>
+/// <param name="FailureDetails">The failure details when <paramref name="Failed"/> is true, otherwise <c>null</c>.</param>
+/// <remarks>
+/// Mirrors the <c>ActivityResult</c> struct in the Go SDK and the
+/// <c>ActivityResult</c> dataclass in the Python SDK so cross-language
+/// quickstarts and chain-of-custody patterns line up.
+/// </remarks>
+public sealed record ActivityResult(
+    string Name,
+    bool Started,
+    bool Completed,
+    bool Failed,
+    string? Input,
+    string? Output,
+    WorkflowTaskFailureDetails? FailureDetails);

src/Dapr.Workflow.Abstractions/ChildWorkflowResult.cs

@@ -0,0 +1,34 @@
+// ------------------------------------------------------------------------
+// Copyright 2026 The Dapr Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//     http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ------------------------------------------------------------------------
+
+namespace Dapr.Workflow;
+
+/// <summary>
+/// A reconstructed view of a single child workflow invocation from propagated history.
+/// </summary>
+/// <param name="Name">The scheduled name of the child workflow.</param>
+/// <param name="Started">Whether the child workflow was scheduled in the propagated chunk.</param>
+/// <param name="Completed">Whether the child workflow completed successfully.</param>
+/// <param name="Failed">Whether the child workflow failed.</param>
+/// <param name="Output">The JSON-encoded output payload, or <c>null</c> when the child workflow has not completed.</param>
+/// <param name="FailureDetails">The failure details when <paramref name="Failed"/> is true, otherwise <c>null</c>.</param>
+/// <remarks>
+/// Mirrors the <c>ChildWorkflowResult</c> type in the Go and Python SDKs.
+/// </remarks>
+public sealed record ChildWorkflowResult(
+    string Name,
+    bool Started,
+    bool Completed,
+    bool Failed,
+    string? Output,
+    WorkflowTaskFailureDetails? FailureDetails);

…w.Abstractions/PropagatedHistoryEvent.cs …ceptions/PropagationNotFoundException.cssrc/Dapr.Workflow.Abstractions/PropagatedHistoryEvent.cs renamed to src/Dapr.Workflow.Abstractions/Exceptions/PropagationNotFoundException.cs src/Dapr.Workflow.Abstractions/PropagatedHistoryEvent.cs renamed to src/Dapr.Workflow.Abstractions/Exceptions/PropagationNotFoundException.cs

@@ -16,9 +16,22 @@ namespace Dapr.Workflow;
 using System;
 
 /// <summary>
-/// Represents a single event in a propagated workflow history segment.
+/// Thrown when a query against propagated workflow history finds no match.
 /// </summary>
-/// <param name="EventId">The unique event ID within the workflow instance history.</param>
-/// <param name="Kind">The kind of history event.</param>
-/// <param name="Timestamp">The UTC timestamp when the event occurred.</param>
-public sealed record PropagatedHistoryEvent(int EventId, HistoryEventKind Kind, DateTimeOffset Timestamp);
+/// <remarks>
+/// Raised by <see cref="PropagatedHistory.GetLastWorkflowByName"/>,
+/// <see cref="WorkflowResult.GetLastActivityByName"/>, and
+/// <see cref="WorkflowResult.GetLastChildWorkflowByName"/> when the requested
+/// name is not present in the propagated history chain. Use the plural
+/// <c>Get*sByName</c> variants if you want an empty-list result instead.
+/// </remarks>
+public sealed class PropagationNotFoundException : Exception
+{
+    /// <summary>
+    /// Initializes a new instance of <see cref="PropagationNotFoundException"/>.
+    /// </summary>
+    /// <param name="message">The exception message.</param>
+    public PropagationNotFoundException(string message) : base(message)
+    {
+    }
+}

src/Dapr.Workflow.Abstractions/HistoryEventKind.cs

@@ -18,68 +18,112 @@ namespace Dapr.Workflow;
 using System.Linq;
 
 /// <summary>
-/// Contains the workflow history that was propagated from ancestor workflow instances.
-/// Each entry corresponds to a single ancestor's history.
+/// Workflow history propagated from a parent workflow to a child workflow or activity.
 /// </summary>
 /// <remarks>
-/// A workflow receives propagated history when it is scheduled with a
-/// <see cref="HistoryPropagationScope"/> other than <see cref="HistoryPropagationScope.None"/>.
-/// Use <see cref="WorkflowContext.GetPropagatedHistory"/> to retrieve the propagated history
-/// inside a workflow implementation.
+/// A propagated history is composed of one or more chunks, each owned by a distinct
+/// workflow instance. Chunks preserve execution order: index 0 is the oldest ancestor,
+/// the last chunk is the immediate parent.
+/// <para>
+/// Use the <c>Get*</c> methods to walk the chain by app, instance, or workflow name.
+/// Mirrors the <c>PropagatedHistory</c> type in the Go and Python SDKs.
+/// </para>
 /// </remarks>
 public sealed class PropagatedHistory
 {
-    private readonly IReadOnlyList<PropagatedHistoryEntry> _entries;
+    private readonly IReadOnlyList<WorkflowResult> _workflows;
 
     /// <summary>
-    /// Initializes a new instance of <see cref="PropagatedHistory"/> with the given entries.
+    /// Initializes a new <see cref="PropagatedHistory"/> from the given workflow chunks.
     /// </summary>
-    /// <param name="entries">The propagated history entries from ancestor workflows.</param>
-    public PropagatedHistory(IReadOnlyList<PropagatedHistoryEntry> entries)
+    /// <param name="workflows">
+    /// Workflow chunks in execution order (ancestor first, immediate parent last).
+    /// </param>
+    public PropagatedHistory(IReadOnlyList<WorkflowResult> workflows)
     {
-        _entries = entries ?? throw new ArgumentNullException(nameof(entries));
+        _workflows = workflows ?? throw new ArgumentNullException(nameof(workflows));
     }
 
     /// <summary>
-    /// Gets the ordered list of propagated history entries.
-    /// The first entry corresponds to the immediate parent workflow; subsequent entries
-    /// correspond to progressively older ancestors when <see cref="HistoryPropagationScope.Lineage"/> is used.
+    /// Returns every workflow chunk in the chain, in execution order
+    /// (ancestor first, immediate parent last).
     /// </summary>
-    public IReadOnlyList<PropagatedHistoryEntry> Entries => _entries;
+    public IReadOnlyList<WorkflowResult> GetWorkflows() => _workflows;
 
     /// <summary>
-    /// Returns a new <see cref="PropagatedHistory"/> containing only entries from the specified App ID.
+    /// Returns an ordered, deduplicated list of app IDs in the propagated chain.
     /// </summary>
-    /// <param name="appId">The Dapr App ID to filter by.</param>
-    /// <returns>A filtered <see cref="PropagatedHistory"/> instance.</returns>
-    public PropagatedHistory FilterByAppId(string appId)
+    public IReadOnlyList<string> GetAppIds()
     {
-        ArgumentException.ThrowIfNullOrWhiteSpace(appId);
-        return new PropagatedHistory(
-            _entries.Where(e => string.Equals(e.AppId, appId, StringComparison.OrdinalIgnoreCase)).ToList());
+        var seen = new HashSet<string>(StringComparer.Ordinal);
+        var result = new List<string>(_workflows.Count);
+        foreach (var workflow in _workflows)
+        {
+            if (seen.Add(workflow.AppId))
+            {
+                result.Add(workflow.AppId);
+            }
+        }
+
+        return result;
     }
 
     /// <summary>
-    /// Returns a new <see cref="PropagatedHistory"/> containing only the entry with the specified instance ID.
+    /// Returns every workflow whose name matches, in execution order. Useful when the
+    /// chain contains the same name more than once (e.g. recursion or ContinueAsNew).
     /// </summary>
-    /// <param name="instanceId">The workflow instance ID to filter by.</param>
-    /// <returns>A filtered <see cref="PropagatedHistory"/> instance.</returns>
-    public PropagatedHistory FilterByInstanceId(string instanceId)
+    /// <param name="name">The workflow name to filter by.</param>
+    /// <returns>An empty list when no match is found.</returns>
+    public IReadOnlyList<WorkflowResult> GetWorkflowsByName(string name)
     {
-        ArgumentException.ThrowIfNullOrWhiteSpace(instanceId);
-        return new PropagatedHistory(
-            _entries.Where(e => string.Equals(e.InstanceId, instanceId, StringComparison.Ordinal)).ToList());
+        ArgumentException.ThrowIfNullOrWhiteSpace(name);
+        return _workflows
+            .Where(w => string.Equals(w.Name, name, StringComparison.Ordinal))
+            .ToList();
+    }
+
+    /// <summary>
+    /// Returns the most recent workflow in the chain whose name matches.
+    /// </summary>
+    /// <param name="name">The workflow name to look up.</param>
+    /// <returns>The last matching workflow chunk.</returns>
+    /// <exception cref="PropagationNotFoundException">No workflow with the given name is present in the chain.</exception>
+    public WorkflowResult GetLastWorkflowByName(string name)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(name);
+        var matches = GetWorkflowsByName(name);
+        if (matches.Count == 0)
+        {
+            throw new PropagationNotFoundException($"no workflow named '{name}' in propagated history");
+        }
+
+        return matches[^1];
+    }
+
+    /// <summary>
+    /// Returns every workflow chunk produced by the given app, in execution order.
+    /// </summary>
+    /// <param name="appId">The Dapr App ID to filter by.</param>
+    /// <returns>An empty list when no match is found.</returns>
+    public IReadOnlyList<WorkflowResult> GetWorkflowsByAppId(string appId)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(appId);
+        return _workflows
+            .Where(w => string.Equals(w.AppId, appId, StringComparison.Ordinal))
+            .ToList();
     }
 
     /// <summary>
-    /// Returns a new <see cref="PropagatedHistory"/> containing only entries for the specified workflow name.
+    /// Returns every workflow chunk produced by the given instance, in execution order.
+    /// Usually a single entry, except when the same instance reappears via ContinueAsNew.
     /// </summary>
-    /// <param name="workflowName">The workflow name to filter by.</param>
-    /// <returns>A filtered <see cref="PropagatedHistory"/> instance.</returns>
-    public PropagatedHistory FilterByWorkflowName(string workflowName)
+    /// <param name="instanceId">The workflow instance ID to filter by.</param>
+    /// <returns>An empty list when no match is found.</returns>
+    public IReadOnlyList<WorkflowResult> GetWorkflowsByInstanceId(string instanceId)
     {
-        ArgumentException.ThrowIfNullOrWhiteSpace(workflowName);
-        return new PropagatedHistory(
-            _entries.Where(e => string.Equals(e.WorkflowName, workflowName, StringComparison.Ordinal)).ToList());
+        ArgumentException.ThrowIfNullOrWhiteSpace(instanceId);
+        return _workflows
+            .Where(w => string.Equals(w.InstanceId, instanceId, StringComparison.Ordinal))
+            .ToList();
     }
 }