Design: IRunningAgentChatFactory in Llm.Core; wrap in Phantom.Workspaces for UI tracking #659

// Phantom.Workspaces.Llm.Interfaces/AgentSessionId.cs
public readonly record struct AgentSessionId(string Value)
{
    public override string ToString() => Value;
}

// Phantom.Workspaces.Llm.Core/RunningAgentChatLease.cs
public sealed class RunningAgentChatLease : IAsyncDisposable
{
    private readonly Func<ValueTask> _onDispose;
    private int _disposed;

    public AgentSessionId SessionId { get; }
    public AgentChat AgentChat { get; }

    internal RunningAgentChatLease(AgentSessionId sessionId, AgentChat agentChat, Func<ValueTask> onDispose) { … }

    public ValueTask DisposeAsync()
    {
        if (Interlocked.CompareExchange(ref _disposed, 1, 0) != 0)
            return ValueTask.CompletedTask;
        return _onDispose();
    }
}

// Phantom.Workspaces.Llm.Core/RunningAgentChat.cs
public sealed class RunningAgentChat
{
    private readonly IRunningAgentChatFactory _factory;

    public AgentSessionId SessionId { get; }

    internal RunningAgentChat(AgentSessionId sessionId, IRunningAgentChatFactory factory) { … }

    /// <summary>
    /// Acquires a new ref-counted lease on this session's AgentChat.
    /// Dispose the lease when done.
    /// </summary>
    public Task<RunningAgentChatLease> AcquireLeaseAsync(CancellationToken ct = default)
        => _factory.GetAsync(SessionId, ct);
}

// Phantom.Workspaces.Llm.Core/IRunningAgentChatFactory.cs
public interface IRunningAgentChatFactory
{
    /// <summary>
    /// The live set of sessions currently held by at least one lease.
    /// Mutations are dispatched on the foreground scheduler; UI subscribers need not marshal.
    /// </summary>
    ObservableCollection<RunningAgentChat> RunningSessions { get; }

    /// <summary>
    /// Acquires a ref-counted lease on the AgentChat for <paramref name="sessionId"/>,
    /// loading it from persistence if not already running.
    /// </summary>
    Task<RunningAgentChatLease> GetAsync(AgentSessionId sessionId, CancellationToken ct = default);

    /// <summary>
    /// Creates a new AgentChat from <paramref name="definition"/> + <paramref name="sessionId"/>,
    /// persists it, adds to RunningSessions, and returns a lease.
    /// </summary>
    Task<RunningAgentChatLease> CreateAsync(
        AgentDefinition definition,
        AgentSessionId sessionId,
        AgentServices? services = null,
        CancellationToken ct = default);
}

// Phantom.Workspaces.Llm.Core/AgentChatFactory.cs
internal sealed class AgentChatFactory : IRunningAgentChatFactory, IAsyncDisposable
{
    private readonly IAgentPersistenceStore _store;
    private readonly AgentServices _services;
    private readonly SemaphoreSlim _gate = new(1, 1);
    private readonly Dictionary<AgentSessionId, Entry> _entries = new();
    private readonly ObservableCollection<RunningAgentChat> _runningSessions = new();

    public ObservableCollection<RunningAgentChat> RunningSessions => _runningSessions;

    public Task<RunningAgentChatLease> GetAsync(AgentSessionId sessionId, CancellationToken ct = default) { … }
    public Task<RunningAgentChatLease> CreateAsync(AgentDefinition definition, AgentSessionId sessionId, AgentServices? services = null, CancellationToken ct = default) { … }
}

public IRunningAgentChatFactory? RunningAgentChatFactory { get; init; }

// AgentChat : IServiceProvider
public object? GetService(Type serviceType)
{
    return this.chatClientAgent?.GetService(serviceType)
        ?? this.request.AgentServices?.GetService(serviceType);
}

// AgentServices : IServiceProvider
public object? GetService(Type serviceType)
{
    if (serviceType == typeof(ILoggerFactory))             return LoggerFactory;
    if (serviceType == typeof(IAgentPersistenceStore))     return AgentPersistenceStoreOverride;
    if (serviceType == typeof(IRunningAgentChatFactory))   return RunningAgentChatFactory;
    if (serviceType == typeof(IToolsetFactory))            return ToolsetFactory;
    if (serviceType == typeof(IToolResourceFactory))       return ToolResourceFactory;
    return null;
}

public interface ISubAgentTable
{
    /// <summary>
    /// Registers a newly created sub-agent with this parent.
    /// Adds it to the parent's SubAgents observable collection,
    /// persists the parent→child link, and returns the SubAgent wrapper.
    /// </summary>
    SubAgent Add(AgentChat agentChat);
}

public interface ICopilotSubAgentReceiver
{
    void Push(ChatResponseUpdate update);
    void Complete();
    void Fail(Exception exception);
}

// Phantom.Workspaces.Services/RunningAgentChatWithEntityInfo.cs
public sealed class RunningAgentChatWithEntityInfo
{
    public AgentSessionId SessionId { get; }
    public string EntityName { get; }
    public string? EntityId { get; }

    public Task<RunningAgentChatLease> AcquireLeaseAsync(CancellationToken ct = default) { … }
}

// Phantom.Workspaces.Services/IRunningAgentChatTable.cs
public interface IRunningAgentChatTable
{
    ObservableCollection<RunningAgentChatWithEntityInfo> RunningSessions { get; }

    Task<RunningAgentChatLease> AcquireAsync(
        AgentSessionId sessionId,
        string entityName = "",
        string? entityId = null,
        CancellationToken ct = default);
}