Merge remote-tracking branch 'origin/main' into codex/epic-12-embedded-runtime

# Conflicts:
#	AGENTS.md
#	Directory.Packages.props
#	DotPilot.Runtime.Host/Features/RuntimeFoundation/EmbeddedRuntimeHostBuilderExtensions.cs
#	DotPilot.Runtime.Host/Features/RuntimeFoundation/EmbeddedRuntimeHostLifecycleService.cs
#	DotPilot.Runtime.Host/Features/RuntimeFoundation/EmbeddedRuntimeHostNames.cs
#	DotPilot.Runtime/Features/RuntimeFoundation/DeterministicAgentRuntimeClient.cs
#	DotPilot.Runtime/Features/RuntimeFoundation/RuntimeFoundationCatalog.cs
#	DotPilot.Tests/Features/RuntimeFoundation/EmbeddedRuntimeHostTests.cs
#	DotPilot.Tests/Features/RuntimeFoundation/RuntimeFoundationCatalogTests.cs
#	DotPilot/App.xaml.cs
#	docs/Architecture.md
#	docs/Features/embedded-orleans-host.md
#	issue-24-embedded-orleans-host.plan.md

Author: KSemenenko

AGENTS.md

@@ -144,6 +144,7 @@ For this app:
 - the repo-root lowercase `.editorconfig` is the source of truth for formatting, naming, style, and analyzer severity
 - local and CI build commands must pass `-warnaserror`; warnings are not an acceptable "green" build state in this repository
 - do not run parallel `dotnet` or `MSBuild` work that shares the same checkout, target outputs, or NuGet package cache; the multi-target Uno app must build serially in CI to avoid `Uno.Resizetizer` file-lock failures
+- do not commit user-specific local paths, usernames, or machine-specific identifiers in tests, docs, snapshots, or fixtures; use neutral synthetic values so the repo stays portable and does not leak personal machine details
 - quality gates should prefer analyzer-backed build failures over separate one-off CI tools; for overloaded methods and maintainability drift, enable build-time analyzers such as `CA1502` instead of adding a formatting-only gate
 - `Directory.Build.props` owns the shared analyzer and warning policy for future projects
 - `Directory.Packages.props` owns centrally managed package versions
@@ -157,6 +158,7 @@ For this app:
 - structure both `DotPilot.Tests` and `DotPilot.UITests` by vertical slice and explicit harness boundaries; do not keep test files in one flat project-root pile
 - the first embedded Orleans runtime cut must use `UseLocalhostClustering` together with in-memory Orleans grain storage and in-memory reminders; do not introduce remote clustering or external durable stores until a later backlog item explicitly requires them, and keep durable resume/replay outside Orleans storage until the cluster topology is intentionally upgraded
 - GitHub is the backlog, not the product: use issues and PRs only to drive task scope and traceability, and never copy GitHub issue text, labels, workflow language, or tracker metadata into production code, runtime snapshots, or user-facing UI
+- never claim an epic is complete until its current GitHub scope is verified against the live issue graph; check which issues are real children versus issues that merely depend on the epic or belong to a different parent epic
 - Desktop responsiveness is a product requirement: avoid synchronous probe, filesystem, network, or process work on UI-facing construction and navigation paths so the app stays fast and immediately reactive
 - Do not invent a repo-specific product framing such as "workbench" unless the active issue or feature spec explicitly uses it; implement the app features described in the backlog instead of turning internal implementation language into the product narrative
 - GitHub Actions workflows must use descriptive names and filenames that reflect their purpose; do not use a generic `ci.yml` catch-all because build validation and release automation are separate operator flows
@@ -311,6 +313,7 @@ Local `AGENTS.md` files may tighten these values, but they must not loosen them
 - Hardcoded values are forbidden.
 - String literals are forbidden in implementation code. Declare them once as named constants, enums, configuration entries, or dedicated value objects, then reuse those symbols.
 - Avoid magic literals. Extract shared values into constants, enums, configuration, or dedicated types.
+- Backlog metadata does not belong in product code: issue numbers, PR numbers, review language, and planning terminology must never appear in production runtime models, diagnostics, or user-facing text unless the feature explicitly exposes source-control metadata.
 - Design boundaries so real behaviour can be tested through public interfaces.
 - For `.NET`, the repo-root `.editorconfig` is the source of truth for formatting, naming, style, and analyzer severity.
 - Use nested `.editorconfig` files when they serve a clear subtree-specific purpose. Do not let IDE defaults, pipeline flags, and repo config disagree.
@@ -369,6 +372,8 @@ Ask first:
 - Installing stale, non-canonical, or non-`mcaf-*` skills into the repo-local agent skill directory.
 - Moving root governance out of the repository root.
 - Mixing multiple `.NET` test frameworks in the active solution without a documented migration plan.
+- Creating auxiliary `git worktree` directories for normal PR follow-up when straightforward branch switching in the main checkout is enough.
+- Running build, test, or verification commands for file-only structural reorganizations when the user explicitly asked for folder cleanup without behavior changes.
 - Adding fallback paths or alternate harnesses that only make failures disappear in tests while the primary product path remains broken.
 - Switching desktop Uno pages into stacked or mobile-style responsive layouts during resize work unless the user explicitly asks for a different composition; desktop pages must stay desktop-first and protect geometry through sizing constraints instead.
 - Adding extra UI-test orchestration complexity when the actual goal is simply to run the tests and get an honest pass or fail result.

DotPilot.Core/Features/ToolchainCenter/ToolchainCenterContracts.cs

@@ -4,7 +4,7 @@ namespace DotPilot.Core.Features.ToolchainCenter;
 
 public sealed record ToolchainCenterWorkstreamDescriptor(
     int IssueNumber,
-    string IssueLabel,
+    string SectionLabel,
     string Name,
     string Summary);
 
@@ -37,7 +37,7 @@ public sealed record ToolchainPollingDescriptor(
 
 public sealed record ToolchainProviderSnapshot(
     int IssueNumber,
-    string IssueLabel,
+    string SectionLabel,
     ProviderDescriptor Provider,
     string ExecutablePath,
     string InstalledVersion,

DotPilot.Runtime.Host/Features/RuntimeFoundation/EmbeddedRuntimeHostBuilderExtensions.cs

@@ -44,6 +44,16 @@ internal static void ConfigureSilo(ISiloBuilder siloBuilder, EmbeddedRuntimeHost
             cluster.ClusterId = options.ClusterId;
             cluster.ServiceId = options.ServiceId;
         });
+        siloBuilder.AddStartupTask(
+            static (serviceProvider, _) =>
+            {
+                serviceProvider
+                    .GetRequiredService<EmbeddedRuntimeHostCatalog>()
+                    .SetState(EmbeddedRuntimeHostState.Running);
+
+                return Task.CompletedTask;
+            },
+            ServiceLifecycleStage.Active);
         siloBuilder.AddMemoryGrainStorage(EmbeddedRuntimeHostNames.GrainStorageProviderName);
         siloBuilder.UseInMemoryReminderService();
     }

DotPilot.Runtime.Host/Features/RuntimeFoundation/EmbeddedRuntimeHostLifecycleService.cs

@@ -4,11 +4,7 @@ namespace DotPilot.Runtime.Host.Features.RuntimeFoundation;
 
 internal sealed class EmbeddedRuntimeHostLifecycleService(EmbeddedRuntimeHostCatalog catalog) : IHostedService
 {
-    public Task StartAsync(CancellationToken cancellationToken)
-    {
-        catalog.SetState(DotPilot.Core.Features.RuntimeFoundation.EmbeddedRuntimeHostState.Running);
-        return Task.CompletedTask;
-    }
+    public Task StartAsync(CancellationToken cancellationToken) => Task.CompletedTask;
 
     public Task StopAsync(CancellationToken cancellationToken)
     {

DotPilot.Runtime/Features/RuntimeFoundation/DeterministicAgentRuntimeClient.cs

@@ -1,4 +1,5 @@
 using DotPilot.Core.Features.ControlPlaneDomain;
+using DotPilot.Core.Features.RuntimeCommunication;
 using DotPilot.Core.Features.RuntimeFoundation;
 using ManagedCode.Communication;
 
@@ -21,19 +22,39 @@ internal DeterministicAgentRuntimeClient(TimeProvider timeProvider)
     public ValueTask<Result<AgentTurnResult>> ExecuteAsync(AgentTurnRequest request, CancellationToken cancellationToken)
     {
         cancellationToken.ThrowIfCancellationRequested();
-        return ValueTask.FromResult(_engine.Execute(request));
+        return ValueTask.FromResult(NormalizeArtifacts(_engine.Execute(request)));
     }
 
     public ValueTask<Result<AgentTurnResult>> ResumeAsync(AgentTurnResumeRequest request, CancellationToken cancellationToken)
     {
         cancellationToken.ThrowIfCancellationRequested();
         _ = request;
-        return ValueTask.FromResult(Result<AgentTurnResult>.Fail(DotPilot.Core.Features.RuntimeCommunication.RuntimeCommunicationProblems.OrchestrationUnavailable()));
+        return ValueTask.FromResult(Result<AgentTurnResult>.Fail(RuntimeCommunicationProblems.OrchestrationUnavailable()));
     }
 
     public ValueTask<Result<RuntimeSessionArchive>> GetSessionArchiveAsync(SessionId sessionId, CancellationToken cancellationToken)
     {
         cancellationToken.ThrowIfCancellationRequested();
-        return ValueTask.FromResult(Result<RuntimeSessionArchive>.Fail(DotPilot.Core.Features.RuntimeCommunication.RuntimeCommunicationProblems.SessionArchiveMissing(sessionId)));
+        return ValueTask.FromResult(Result<RuntimeSessionArchive>.Fail(RuntimeCommunicationProblems.SessionArchiveMissing(sessionId)));
+    }
+
+    private static Result<AgentTurnResult> NormalizeArtifacts(Result<AgentTurnResult> result)
+    {
+        if (result.IsFailed || result.Value is null)
+        {
+            return result;
+        }
+
+        var outcome = result.Value;
+        var normalizedArtifacts = outcome.ProducedArtifacts
+            .Select(artifact => artifact with { CreatedAt = RuntimeFoundationDeterministicIdentity.ArtifactCreatedAt })
+            .ToArray();
+
+        return Result<AgentTurnResult>.Succeed(
+            new AgentTurnResult(
+                outcome.Summary,
+                outcome.NextPhase,
+                outcome.ApprovalState,
+                normalizedArtifacts));
     }
 }

DotPilot.Runtime/Features/RuntimeFoundation/ProviderToolchainProbe.cs

@@ -26,7 +26,7 @@ status is ProviderConnectionStatus.Available
 
         return new ProviderDescriptor
         {
-            Id = ProviderId.New(),
+            Id = RuntimeFoundationDeterministicIdentity.CreateProviderId(commandName),
             DisplayName = displayName,
             CommandName = commandName,
             Status = status,

DotPilot.Runtime/Features/RuntimeFoundation/RuntimeFoundationCatalog.cs

@@ -1,25 +1,29 @@
 using DotPilot.Core.Features.ControlPlaneDomain;
 using DotPilot.Core.Features.RuntimeFoundation;
-using DotPilot.Runtime.Features.ToolchainCenter;
 
 namespace DotPilot.Runtime.Features.RuntimeFoundation;
 
 public sealed class RuntimeFoundationCatalog : IRuntimeFoundationCatalog
 {
     private const string EpicSummary =
         "The embedded runtime stays local-first by isolating contracts, host wiring, orchestration, policy, and durable session archives away from the Uno presentation layer.";
+    private const string EpicLabelValue = "LOCAL RUNTIME READINESS";
     private const string DeterministicProbePrompt =
         "Summarize the runtime foundation readiness for a local-first session that may require approval.";
     private const string DeterministicClientStatusSummary = "Always available for in-repo and CI validation.";
+    private const string DomainModelLabel = "DOMAIN";
     private const string DomainModelName = "Domain contracts";
     private const string DomainModelSummary =
         "Typed identifiers and durable agent, session, fleet, provider, and runtime contracts live outside the Uno app.";
+    private const string CommunicationLabel = "CONTRACTS";
     private const string CommunicationName = "Communication contracts";
     private const string CommunicationSummary =
         "Public result and problem boundaries are isolated so later provider and orchestration slices share one contract language.";
+    private const string HostLabel = "HOST";
     private const string HostName = "Embedded host";
     private const string HostSummary =
         "The Orleans host integration point is sequenced behind dedicated runtime contracts instead of being baked into page code.";
+    private const string OrchestrationLabel = "ORCHESTRATION";
     private const string OrchestrationName = "Orchestration runtime";
     private const string OrchestrationSummary =
         "Agent Framework orchestrates local runs, approvals, and checkpoints without moving execution logic into the Uno app.";
@@ -29,16 +33,19 @@ public sealed class RuntimeFoundationCatalog : IRuntimeFoundationCatalog
     private const string SessionPersistenceName = "Session persistence";
     private const string SessionPersistenceSummary =
         "Checkpoint, replay, and resume data survive host restarts in local session archives without changing the Orleans storage topology.";
+    private readonly IReadOnlyList<ProviderDescriptor> _providers;
+
+    public RuntimeFoundationCatalog() => _providers = Array.AsReadOnly(CreateProviders());
 
     public RuntimeFoundationSnapshot GetSnapshot()
     {
         return new(
-            RuntimeFoundationIssues.FormatIssueLabel(RuntimeFoundationIssues.EmbeddedAgentRuntimeHostEpic),
+            EpicLabelValue,
             EpicSummary,
             ProviderToolchainNames.DeterministicClientDisplayName,
             DeterministicProbePrompt,
             CreateSlices(),
-            CreateProviders());
+            _providers);
     }
 
     private static IReadOnlyList<RuntimeSliceDescriptor> CreateSlices()
@@ -47,25 +54,25 @@ private static IReadOnlyList<RuntimeSliceDescriptor> CreateSlices()
         [
             new(
                 RuntimeFoundationIssues.DomainModel,
-                RuntimeFoundationIssues.FormatIssueLabel(RuntimeFoundationIssues.DomainModel),
+                DomainModelLabel,
                 DomainModelName,
                 DomainModelSummary,
                 RuntimeSliceState.ReadyForImplementation),
             new(
                 RuntimeFoundationIssues.CommunicationContracts,
-                RuntimeFoundationIssues.FormatIssueLabel(RuntimeFoundationIssues.CommunicationContracts),
+                CommunicationLabel,
                 CommunicationName,
                 CommunicationSummary,
                 RuntimeSliceState.Sequenced),
             new(
                 RuntimeFoundationIssues.EmbeddedOrleansHost,
-                RuntimeFoundationIssues.FormatIssueLabel(RuntimeFoundationIssues.EmbeddedOrleansHost),
+                HostLabel,
                 HostName,
                 HostSummary,
                 RuntimeSliceState.Sequenced),
             new(
                 RuntimeFoundationIssues.AgentFrameworkRuntime,
-                RuntimeFoundationIssues.FormatIssueLabel(RuntimeFoundationIssues.AgentFrameworkRuntime),
+                OrchestrationLabel,
                 OrchestrationName,
                 OrchestrationSummary,
                 RuntimeSliceState.Sequenced),
@@ -84,21 +91,19 @@ private static IReadOnlyList<RuntimeSliceDescriptor> CreateSlices()
         ];
     }
 
-    private static IReadOnlyList<ProviderDescriptor> CreateProviders()
+    private static ProviderDescriptor[] CreateProviders()
     {
         return
         [
             new ProviderDescriptor
             {
-                Id = ProviderId.New(),
+                Id = RuntimeFoundationDeterministicIdentity.CreateProviderId(ProviderToolchainNames.DeterministicClientCommandName),
                 DisplayName = ProviderToolchainNames.DeterministicClientDisplayName,
                 CommandName = ProviderToolchainNames.DeterministicClientCommandName,
                 Status = ProviderConnectionStatus.Available,
                 StatusSummary = DeterministicClientStatusSummary,
                 RequiresExternalToolchain = false,
             },
-            .. ToolchainProviderSnapshotFactory.Create(TimeProvider.System.GetUtcNow())
-                .Select(snapshot => snapshot.Provider),
         ];
     }
 }

DotPilot.Runtime/Features/RuntimeFoundation/RuntimeFoundationDeterministicIdentity.cs

@@ -0,0 +1,34 @@
+using System.Security.Cryptography;
+using System.Text;
+using DotPilot.Core.Features.ControlPlaneDomain;
+
+namespace DotPilot.Runtime.Features.RuntimeFoundation;
+
+internal static class RuntimeFoundationDeterministicIdentity
+{
+    private const string ArtifactSeedPrefix = "runtime-foundation-artifact";
+    private const string ProviderSeedPrefix = "runtime-foundation-provider";
+    private const string SeedSeparator = "|";
+
+    public static DateTimeOffset ArtifactCreatedAt { get; } = new(2026, 3, 13, 0, 0, 0, TimeSpan.Zero);
+
+    public static ArtifactId CreateArtifactId(SessionId sessionId, string artifactName)
+    {
+        return new(CreateGuid(string.Concat(ArtifactSeedPrefix, SeedSeparator, sessionId, SeedSeparator, artifactName)));
+    }
+
+    public static ProviderId CreateProviderId(string commandName)
+    {
+        return new(CreateGuid(string.Concat(ProviderSeedPrefix, SeedSeparator, commandName)));
+    }
+
+    private static Guid CreateGuid(string seed)
+    {
+        var hash = SHA256.HashData(Encoding.UTF8.GetBytes(seed));
+        Span<byte> guidBytes = stackalloc byte[16];
+        hash[..guidBytes.Length].CopyTo(guidBytes);
+        guidBytes[7] = (byte)((guidBytes[7] & 0x0F) | 0x80);
+        guidBytes[8] = (byte)((guidBytes[8] & 0x3F) | 0x80);
+        return new Guid(guidBytes);
+    }
+}