Fix GAgent durable terminal completion

src/Aevatar.AI.Core/RoleGAgent.cs

@@ -28,7 +28,7 @@
 /// <summary>
 /// Role-based AI GAgent. Receives ChatRequestEvent and streams LLM response.
 /// </summary>
 public class RoleGAgent : AIGAgentBase<RoleGAgentState>, IRoleAgent
 {
     private const string LlmFailureContentPrefix = "[[AEVATAR_LLM_ERROR]]";
     private const int MaxTrackedSessions = 128;
@@ -137,9 +137,10 @@
                     "[{Role}] Approval continuation FAILED. request={RequestId}",
                     RoleName, pending.RequestId);
 
-                // Still clear pending so we don't get stuck
-                try { await PersistDomainEventAsync(new ClearPendingApprovalEvent { RequestId = pending.RequestId }); }
-                catch { /* best effort */ }
+                await TryPersistApprovalTerminalFailureThenClearPendingAsync(
+                    pending,
+                    "approval_continuation_failed",
+                    ex.Message);
 
                 throw; // Re-throw so the SSE endpoint sees the error
             }
@@ -150,7 +151,12 @@
         }
         else
         {
-            await PersistDomainEventAsync(new ClearPendingApprovalEvent { RequestId = pending.RequestId });
+            await PersistApprovalTerminalFailureThenClearPendingAsync(
+                pending,
+                "approval_denied",
+                string.IsNullOrWhiteSpace(evt.Reason)
+                    ? "Tool approval denied."
+                    : evt.Reason);
         }
     }
 
@@ -176,19 +182,23 @@
         {
             Logger.LogWarning("[{Role}] No remote approval handler configured. Clearing pending. request={RequestId}",
                 RoleName, evt.RequestId);
-            await PersistDomainEventAsync(new ClearPendingApprovalEvent { RequestId = pending.RequestId });
+            await PersistApprovalTerminalFailureThenClearPendingAsync(
+                pending,
+                "approval_timeout",
+                "Tool approval timed out and no remote approval handler is configured.");
             return;
         }
 
         // Restore metadata (NyxID access token) for the remote handler
         var prevMetadata = AgentToolRequestContext.CurrentMetadata;
+        ToolApprovalResult? result = null;
         try
         {
             AgentToolRequestContext.CurrentMetadata = pending.Metadata.Count > 0
                 ? new Dictionary<string, string>(pending.Metadata, StringComparer.Ordinal)
                 : null;
 
-            var result = await remoteHandler.RequestApprovalAsync(
+            result = await remoteHandler.RequestApprovalAsync(
                 new ToolApprovalRequest
                 {
                     RequestId = pending.RequestId,
@@ -225,8 +235,13 @@
             AgentToolRequestContext.CurrentMetadata = prevMetadata;
         }
 
-        // Remote failed/denied/timed out → clear pending
-        await PersistDomainEventAsync(new ClearPendingApprovalEvent { RequestId = pending.RequestId });
+        // Remote failed/denied/timed out → persist terminal fact before clearing pending.
+        await PersistApprovalTerminalFailureThenClearPendingAsync(
+            pending,
+            ResolveApprovalTerminalReasonCode(result?.Decision),
+            string.IsNullOrWhiteSpace(result?.Reason)
+                ? "Tool approval timed out or was denied remotely."
+                : result.Reason);
     }
 
     /// <summary>Override in subclasses to provide the NyxID remote approval handler for timeout escalation.</summary>
@@ -703,6 +718,77 @@
         });
     }
 
+    private async Task PersistApprovalTerminalFailureThenClearPendingAsync(
+        PendingToolApprovalState pending,
+        string reasonCode,
+        string reasonMessage)
+    {
+        await PersistApprovalTerminalFailureAsync(pending, reasonCode, reasonMessage);
+        await PersistDomainEventAsync(new ClearPendingApprovalEvent { RequestId = pending.RequestId });
+    }
+
+    private async Task TryPersistApprovalTerminalFailureThenClearPendingAsync(
+        PendingToolApprovalState pending,
+        string reasonCode,
+        string reasonMessage)
+    {
+        try
+        {
+            await PersistApprovalTerminalFailureAsync(pending, reasonCode, reasonMessage);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogError(
+                ex,
+                "[{Role}] Failed to persist approval terminal failure. request={RequestId} session={SessionId} reasonCode={ReasonCode}",
+                RoleName,
+                pending.RequestId,
+                pending.SessionId,
+                reasonCode);
+            return;
+        }
+
+        try
+        {
+            await PersistDomainEventAsync(new ClearPendingApprovalEvent { RequestId = pending.RequestId });
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(
+                ex,
+                "[{Role}] Failed to clear pending approval after terminal failure was persisted. request={RequestId} session={SessionId} reasonCode={ReasonCode}",
+                RoleName,
+                pending.RequestId,
+                pending.SessionId,
+                reasonCode);
+        }
+    }
+
+    private Task PersistApprovalTerminalFailureAsync(
+        PendingToolApprovalState pending,
+        string reasonCode,
+        string reasonMessage)
+    {
+        if (string.IsNullOrWhiteSpace(pending.SessionId))
+            return Task.CompletedTask;
+
+        var safeReason = string.IsNullOrWhiteSpace(reasonMessage)
+            ? "Tool approval failed."
+            : reasonMessage.Trim();
+        return PersistDomainEventAsync(new RoleChatSessionCompletedEvent
+        {
+            SessionId = pending.SessionId,
+            Content = BuildLlmFailureContent($"{reasonCode}: {safeReason}"),
+            Prompt = BuildContinuationPrompt(pending, safeReason),
+            ContentEmitted = false,
+        });
+    }
+
+    private static string ResolveApprovalTerminalReasonCode(ToolApprovalDecision? decision) =>
+        decision == ToolApprovalDecision.Denied
+            ? "approval_denied"
+            : "approval_timeout";
+
     private async Task ReplayCompletedSessionAsync(string sessionId, RoleChatSessionState trackedSession)
     {
         await PublishAsync(new TextMessageStartEvent

src/Aevatar.CQRS.Projection.Core.Abstractions/Abstractions/Core/IProjectionSessionScopedMaterializationContext.cs

@@ -0,0 +1,9 @@
+namespace Aevatar.CQRS.Projection.Core.Abstractions;
+
+/// <summary>
+/// Durable materialization scope that is partitioned by an explicit session key.
+/// </summary>
+public interface IProjectionSessionScopedMaterializationContext : IProjectionMaterializationContext
+{
+    string SessionId { get; }
+}

src/Aevatar.CQRS.Projection.Core/DependencyInjection/ProjectionMaterializationRuntimeRegistration.cs

@@ -37,7 +37,8 @@ public static IServiceCollection AddProjectionMaterializationRuntimeCore<TContex
                 request => contextFactory(new ProjectionRuntimeScopeKey(
                     request.RootActorId,
                     request.ProjectionKind,
-                    ProjectionRuntimeMode.DurableMaterialization)),
+                    ProjectionRuntimeMode.DurableMaterialization,
+                    request.SessionId)),
                 (_, context) => leaseFactory(context),
                 sp.GetService<Aevatar.Foundation.Abstractions.TypeSystem.IAgentTypeVerifier>(),
                 sp.GetService<IStreamPubSubMaintenance>(),
@@ -51,7 +52,10 @@ public static IServiceCollection AddProjectionMaterializationRuntimeCore<TContex
                 lease => new ProjectionRuntimeScopeKey(
                     lease.Context.RootActorId,
                     lease.Context.ProjectionKind,
-                    ProjectionRuntimeMode.DurableMaterialization),
+                    ProjectionRuntimeMode.DurableMaterialization,
+                    lease.Context is IProjectionSessionScopedMaterializationContext scopedContext
+                        ? scopedContext.SessionId
+                        : string.Empty),
                 sp.GetService<Aevatar.Foundation.Abstractions.TypeSystem.IAgentTypeVerifier>()));
         return services;
     }

src/platform/Aevatar.GAgentService.Abstractions/ScopeGAgents/GAgentDraftRunModels.cs

@@ -58,7 +58,8 @@ public sealed record GAgentDraftRunAcceptedReceipt(
     string ActorId,
     string ActorTypeName,
     string CommandId,
-    string CorrelationId);
+    string CorrelationId,
+    string SessionId = "");
 
 public sealed record GAgentApprovalCommand(
     string ActorId,
@@ -90,4 +91,5 @@ public enum GAgentApprovalCompletionStatus
 public sealed record GAgentApprovalAcceptedReceipt(
     string ActorId,
     string CommandId,
-    string CorrelationId);
+    string CorrelationId,
+    string SessionId);

src/platform/Aevatar.GAgentService.Abstractions/ScopeGAgents/GAgentRunTerminalModels.cs

@@ -0,0 +1,63 @@
+namespace Aevatar.GAgentService.Abstractions.ScopeGAgents;
+
+public enum GAgentRunTerminalStatus
+{
+    Unknown = 0,
+    TextMessageCompleted = 1,
+    RunFinished = 2,
+    Failed = 3,
+}
+
+public enum GAgentRunTerminalInteractionKind
+{
+    Unknown = 0,
+    DraftRun = 1,
+    Approval = 2,
+}
+
+public sealed record GAgentRunTerminalSnapshot(
+    string ActorId,
+    string SessionId,
+    string CorrelationId,
+    GAgentRunTerminalInteractionKind InteractionKind,
+    GAgentRunTerminalStatus Status,
+    string ReasonCode,
+    string ReasonMessage,
+    long StateVersion,
+    string LastEventId,
+    DateTimeOffset ObservedAt);
+
+public interface IGAgentRunTerminalQueryPort
+{
+    Task<GAgentRunTerminalSnapshot?> GetByCorrelationIdAsync(
+        string actorId,
+        string correlationId,
+        CancellationToken ct = default);
+
+    Task<GAgentRunTerminalSnapshot?> GetBySessionIdAsync(
+        string actorId,
+        string sessionId,
+        CancellationToken ct = default);
+}
+
+public interface IGAgentRunTerminalProjectionLease
+{
+    string ActorId { get; }
+
+    string CorrelationId { get; }
+
+    GAgentRunTerminalInteractionKind InteractionKind { get; }
+}
+
+public interface IGAgentRunTerminalProjectionPort
+{
+    Task<IGAgentRunTerminalProjectionLease?> EnsureProjectionAsync(
+        string actorId,
+        string correlationId,
+        GAgentRunTerminalInteractionKind interactionKind,
+        CancellationToken ct = default);
+
+    Task ReleaseProjectionAsync(
+        IGAgentRunTerminalProjectionLease lease,
+        CancellationToken ct = default);
+}