refactor(comm): retire ClusterClient naming after the gRPC cutover

Phase 4 of the ClusterClient -> gRPC migration deleted the Akka transports
but left the naming behind: `ClusterClientSiteAuditClient` was transport-
agnostic and worked unchanged, so it survived the deletion under a name
that now describes a transport the repo no longer has. Same for a scatter
of doc-comments still framing gRPC as "the new transport" beside an Akka
one that is gone.

Renames it to `SiteCommunicationAuditClient` (and its test file) and
rewrites the stale comments to describe the single transport that exists.
Also tightens CLAUDE.md: drops the self-describing directory listing and
the 27-component enumeration in favour of the non-obvious parts only.

Behaviour-neutral: names and prose only. Recorded as the Phase 4
follow-up in docs/plans/2026-07-22-clusterclient-to-grpc-plan.md.

src/ZB.MOM.WW.ScadaBridge.AuditLog/ServiceCollectionExtensions.cs

@@ -144,8 +144,8 @@ public static class ServiceCollectionExtensions
 
         // ISiteStreamAuditClient: NoOp default. This binding remains correct for
         // central/test composition roots that have no SiteCommunicationActor.
-        // The real implementation is ClusterClientSiteAuditClient, which pushes
-        // audit telemetry to central over Akka ClusterClient via the site's
+        // The real implementation is SiteCommunicationAuditClient, which pushes
+        // audit telemetry to central via the site's
         // SiteCommunicationActor — the Host wires it directly into the
         // SiteAuditTelemetryActor's Props.Create call for site roles (it cannot
         // be a DI singleton because it needs the SiteCommunicationActor IActorRef,

src/ZB.MOM.WW.ScadaBridge.AuditLog/Site/Telemetry/CachedCallTelemetryForwarder.cs

@@ -37,7 +37,7 @@ namespace ZB.MOM.WW.ScadaBridge.AuditLog.Site.Telemetry;
 /// <b>Local-write only — the wire push is the drain actor's job.</b> This
 /// forwarder is deliberately synchronous against the two site-local SQLite
 /// stores and never pushes to central itself. The site→central transport is
-/// now live: <c>ClusterClientSiteAuditClient</c> is the production binding of
+/// now live: <c>SiteCommunicationAuditClient</c> is the production binding of
 /// <see cref="ISiteStreamAuditClient"/> on site roles (with
 /// <c>NoOpSiteStreamAuditClient</c> retained only for central/test composition
 /// roots). The push happens out-of-band: <see cref="SiteAuditTelemetryActor"/>

src/ZB.MOM.WW.ScadaBridge.AuditLog/Site/Telemetry/ISiteStreamAuditClient.cs

@@ -6,9 +6,9 @@ namespace ZB.MOM.WW.ScadaBridge.AuditLog.Site.Telemetry;
 /// Mockable abstraction over the central site-audit push surface that
 /// <see cref="SiteAuditTelemetryActor"/> uses to forward <see cref="AuditEventBatch"/>
 /// payloads. The production implementation is
-/// <see cref="ClusterClientSiteAuditClient"/> — a ClusterClient-based client,
-/// wired in the Host for site roles, that forwards batches to central via the
-/// site's <c>SiteCommunicationActor</c>. Unit tests substitute via NSubstitute
+/// <see cref="SiteCommunicationAuditClient"/> — wired in the Host for site
+/// roles, it forwards batches to central via the site's
+/// <c>SiteCommunicationActor</c>. Unit tests substitute via NSubstitute
 /// against this interface so the actor never needs a live transport.
 /// </summary>
 public interface ISiteStreamAuditClient
@@ -36,8 +36,8 @@ public interface ISiteStreamAuditClient
     /// once central has acknowledged them.
     /// </summary>
     /// <remarks>
-    /// The production <see cref="ClusterClientSiteAuditClient"/> forwards over
-    /// the ClusterClient transport; the <see cref="NoOpSiteStreamAuditClient"/>
+    /// The production <see cref="SiteCommunicationAuditClient"/> forwards over
+    /// the site's central transport; the <see cref="NoOpSiteStreamAuditClient"/>
     /// DI default (used by central and test composition roots) returns an empty
     /// ack so no rows are flipped.
     /// </remarks>

src/ZB.MOM.WW.ScadaBridge.AuditLog/Site/Telemetry/NoOpSiteStreamAuditClient.cs

@@ -7,9 +7,8 @@ namespace ZB.MOM.WW.ScadaBridge.AuditLog.Site.Telemetry;
 /// <see cref="ZB.MOM.WW.ScadaBridge.AuditLog.ServiceCollectionExtensions.AddAuditLog"/>.
 /// It is a no-op binding for composition roots that have no
 /// <c>SiteCommunicationActor</c> — central and test roots. Site roles override
-/// it in the Host with the ClusterClient-based
-/// <see cref="ClusterClientSiteAuditClient"/>, which actually forwards audit
-/// telemetry to central.
+/// it in the Host with <see cref="SiteCommunicationAuditClient"/>, which
+/// actually forwards audit telemetry to central.
 /// </summary>
 /// <remarks>
 /// <para>
@@ -33,7 +32,7 @@ public sealed class NoOpSiteStreamAuditClient : ISiteStreamAuditClient
     {
         ArgumentNullException.ThrowIfNull(batch);
         // Empty ack — no EventIds will be flipped to Forwarded, so rows stay
-        // Pending until the real ClusterClientSiteAuditClient (or a test stub)
+        // Pending until the real SiteCommunicationAuditClient (or a test stub)
         // takes over.
         return Task.FromResult(EmptyAck);
     }
@@ -45,7 +44,7 @@ public sealed class NoOpSiteStreamAuditClient : ISiteStreamAuditClient
         // Empty ack — same rationale as IngestAuditEventsAsync. The site still
         // writes the audit + tracking rows to its SQLite stores authoritatively;
         // central-side state only materialises once the real
-        // ClusterClientSiteAuditClient (or a test stub) is wired in.
+        // SiteCommunicationAuditClient (or a test stub) is wired in.
         return Task.FromResult(EmptyAck);
     }
 }

src/ZB.MOM.WW.ScadaBridge.AuditLog/Site/Telemetry/SiteCommunicationAuditClient.cs

@@ -7,11 +7,11 @@ namespace ZB.MOM.WW.ScadaBridge.AuditLog.Site.Telemetry;
 
 /// <summary>
 /// Production <see cref="ISiteStreamAuditClient"/> binding for site composition
-/// roots: pushes audit telemetry to central over Akka <c>ClusterClient</c> via
-/// the site's <c>SiteCommunicationActor</c>. The actor forwards the command to
-/// <c>/user/central-communication</c> and the central
-/// <c>CentralCommunicationActor</c> Asks the <c>AuditLogIngestActor</c> proxy —
-/// the same command/control transport notifications already use. Wired by the
+/// roots: pushes audit telemetry to central via the site's
+/// <c>SiteCommunicationActor</c>, which owns the transport choice (today
+/// <c>GrpcCentralTransport</c>, over the central-hosted <c>CentralControlService</c>).
+/// The central <c>CentralCommunicationActor</c> Asks the <c>AuditLogIngestActor</c>
+/// proxy — the same command/control path notifications already use. Wired by the
 /// Host for site roles; central and test composition roots keep the
 /// <see cref="NoOpSiteStreamAuditClient"/> DI default (they have no
 /// <c>SiteCommunicationActor</c>).
@@ -34,12 +34,12 @@ namespace ZB.MOM.WW.ScadaBridge.AuditLog.Site.Telemetry;
 /// <see cref="CachedTelemetryBatch"/>) because the
 /// <see cref="SiteAuditTelemetryActor"/> builds them with
 /// <see cref="AuditEventDtoMapper.ToDto"/>. This client converts them back into
-/// the <see cref="AuditEvent"/> / <see cref="SiteCall"/> entities the Akka
-/// command messages carry — the same DTO→entity translation the
+/// the <see cref="AuditEvent"/> / <see cref="SiteCall"/> entities the command
+/// messages carry — the same DTO→entity translation the
 /// <c>SiteStreamGrpcServer</c> performs for the gRPC reconciliation path.
 /// </para>
 /// </remarks>
-public sealed class ClusterClientSiteAuditClient : ISiteStreamAuditClient
+public sealed class SiteCommunicationAuditClient : ISiteStreamAuditClient
 {
     private readonly IActorRef _siteCommunicationActor;
     private readonly TimeSpan _askTimeout;
@@ -49,15 +49,15 @@ public sealed class ClusterClientSiteAuditClient : ISiteStreamAuditClient
     /// </summary>
     /// <param name="siteCommunicationActor">
     /// The site's <c>SiteCommunicationActor</c> — it forwards the ingest command
-    /// over the registered central ClusterClient and routes the reply back to
-    /// this client's Ask.
+    /// to central over its configured <c>ICentralTransport</c> and routes the
+    /// reply back to this client's Ask.
     /// </param>
     /// <param name="askTimeout">
     /// Ask timeout for the round-trip to central. On expiry the Ask throws
     /// <see cref="Akka.Actor.AskTimeoutException"/>, which the drain loop treats
     /// as transient (rows stay <c>Pending</c>).
     /// </param>
-    public ClusterClientSiteAuditClient(IActorRef siteCommunicationActor, TimeSpan askTimeout)
+    public SiteCommunicationAuditClient(IActorRef siteCommunicationActor, TimeSpan askTimeout)
     {
         ArgumentNullException.ThrowIfNull(siteCommunicationActor);
         _siteCommunicationActor = siteCommunicationActor;

src/ZB.MOM.WW.ScadaBridge.Commons/Entities/Sites/Site.cs

@@ -10,9 +10,9 @@ public class Site
     public string SiteIdentifier { get; set; }
     /// <summary>Optional description of the site.</summary>
     public string? Description { get; set; }
-    /// <summary>Akka remote address for site node A (ClusterClient contact point).</summary>
+    /// <summary>Akka remote address for site node A.</summary>
     public string? NodeAAddress { get; set; }
-    /// <summary>Akka remote address for site node B (ClusterClient contact point).</summary>
+    /// <summary>Akka remote address for site node B.</summary>
     public string? NodeBAddress { get; set; }
     /// <summary>gRPC endpoint for site node A used by the central SiteStreamGrpcClient.</summary>
     public string? GrpcNodeAAddress { get; set; }

src/ZB.MOM.WW.ScadaBridge.Commons/Messages/Audit/SiteCallRelayMessages.cs

@@ -28,7 +28,7 @@ public enum SiteCallRelayOutcome
     NotParked,
 
     /// <summary>
-    /// The owning site could not be reached (offline / no ClusterClient route /
+    /// The owning site could not be reached (offline / no route to the site /
     /// relay timed out). The action was NOT applied; the operator may retry once
     /// the site is back online.
     /// </summary>

src/ZB.MOM.WW.ScadaBridge.Commons/Messages/DebugView/DebugViewSnapshot.cs

@@ -19,8 +19,8 @@ namespace ZB.MOM.WW.ScadaBridge.Commons.Messages.DebugView;
 /// </para>
 /// <para>
 /// A new dedicated message type (<c>DebugViewInstanceNotFound</c>) was
-/// considered but rejected: the ClusterClient / ClusterClientReceptionist
-/// channel is typed on the request side and the bridge actor is already
+/// considered but rejected: the site↔central channel is typed on the request
+/// side and the bridge actor is already
 /// pattern-matching on <c>DebugViewSnapshot</c> for the initial-snapshot TCS
 /// in <c>DebugStreamService</c>.  Introducing a second reply type would require
 /// every consumer to handle an additional <c>Ask</c> result union — more change

src/ZB.MOM.WW.ScadaBridge.Commons/Messages/Deployment/ReconcileSiteRequest.cs

@@ -1,7 +1,7 @@
 namespace ZB.MOM.WW.ScadaBridge.Commons.Messages.Deployment;
 
 /// <summary>
-/// Site→central (over ClusterClient) on node startup: the node's local deployed inventory,
+/// Site→central on node startup: the node's local deployed inventory,
 /// so central can reply with fetch tokens for whatever the node is missing or stale
 /// (self-heal a node that was down during a deploy).
 /// </summary>

src/ZB.MOM.WW.ScadaBridge.Commons/Messages/Health/SiteHealthReport.cs

@@ -108,8 +108,8 @@ public record SiteHealthReport(
 
 /// <summary>
 /// Broadcast wrapper used between central nodes to keep per-node
-/// CentralHealthAggregator state in sync. ClusterClient load-balances each
-/// incoming SiteHealthReport to one central node; that node re-publishes
+/// CentralHealthAggregator state in sync. A site delivers each
+/// SiteHealthReport to ONE central node; that node re-publishes
 /// this wrapper on a DistributedPubSub topic so the peer node's aggregator
 /// also processes the report (idempotently — sequence numbers guard against
 /// double-counting).

src/ZB.MOM.WW.ScadaBridge.Commons/Messages/Instance/WaitForAttribute.cs

@@ -9,7 +9,7 @@ namespace ZB.MOM.WW.ScadaBridge.Commons.Messages.Instance;
 /// <b>Site-local only.</b> The optional <see cref="Predicate"/> is a non-serializable
 /// in-process delegate, so this message MUST flow only within a single site node's
 /// actor system (script execution → Instance Actor). It is never sent across the
-/// ClusterClient / gRPC boundary. The value-equality form (<see cref="TargetValueEncoded"/>)
+/// site↔central gRPC boundary. The value-equality form (<see cref="TargetValueEncoded"/>)
 /// would serialize, but the routed/inbound variant is deliberately out of scope here.
 /// </para>
 /// </summary>

src/ZB.MOM.WW.ScadaBridge.Commons/Messages/Management/ManagementCommandRegistry.cs

@@ -6,7 +6,7 @@ namespace ZB.MOM.WW.ScadaBridge.Commons.Messages.Management;
 /// Bidirectional name registry for management command records. The registry contains
 /// exactly the non-abstract <c>*Command</c> types declared in the
 /// <c>ZB.MOM.WW.ScadaBridge.Commons.Messages.Management</c> namespace; these are the commands that
-/// travel over the HTTP / ClusterClient management boundary.
+/// travel over the HTTP management boundary.
 /// </summary>
 /// <remarks>
 /// <see cref="Resolve"/> and <see cref="GetCommandName"/> are symmetric:

src/ZB.MOM.WW.ScadaBridge.Commons/Messages/Management/SchemaLibraryCommands.cs

@@ -2,7 +2,7 @@ namespace ZB.MOM.WW.ScadaBridge.Commons.Messages.Management;
 
 // Schema-library authoring commands. The reusable named JSON-Schema
 // library (the SharedSchema entity + ISharedSchemaRepository) gains its CRUD
-// surface here. These records travel the same HTTP / ClusterClient management
+// surface here. These records travel the same HTTP management
 // boundary as every other *Command and are auto-discovered by reflection in
 // ManagementCommandRegistry (no manual registry entry needed).
 //

src/ZB.MOM.WW.ScadaBridge.Commons/Messages/RemoteQuery/SiteFailoverRelayMessages.cs

@@ -14,7 +14,7 @@ namespace ZB.MOM.WW.ScadaBridge.Commons.Messages.RemoteQuery;
 /// </para>
 /// <para>
 /// Either site node may receive this: <c>SiteCommunicationActor</c> is registered per node
-/// (not as a singleton), and ClusterClient contact rotation reaches whichever answers. That is
+/// (not as a singleton), and central's gRPC dial reaches whichever node answers. That is
 /// fine — <c>Cluster.Leave(address)</c> is valid from any member, and the target is resolved
 /// from cluster state rather than from who received the message.
 /// </para>

src/ZB.MOM.WW.ScadaBridge.Communication/Actors/CentralCommunicationActor.cs

@@ -89,7 +89,7 @@ public class CentralCommunicationActor : ReceiveActor
     /// Default Ask timeout for routing audit ingest commands to the
     /// Effective Ask timeout for audit ingest routing. Defaults to
     /// <see cref="Grpc.SiteStreamGrpcServer.AuditIngestAskTimeout"/> (30 s) — the two
-    /// audit-ingest transports (gRPC vs ClusterClient) now share one source of truth
+    /// audit-ingest entry points (the site stream server and the control plane) share one source of truth
     /// for the timeout. Overridable via the constructor so tests can exercise the
     /// timeout/fault path without waiting 30 s. When the window is exceeded the Ask
     /// faults and that fault is piped back to the caller as a
@@ -167,8 +167,8 @@ public class CentralCommunicationActor : ReceiveActor
         });
 
         // Notification Outbox ingest: a site forwards a buffered NotificationSubmit to the
-        // central cluster via ClusterClient. Forward to the outbox proxy so the original
-        // Sender (the site's ClusterClient path) is preserved and the NotificationSubmitAck
+        // central cluster. Forward to the outbox proxy so the original
+        // Sender (the site's transport path) is preserved and the NotificationSubmitAck
         // routes straight back to the site.
         Receive<NotificationSubmit>(HandleNotificationSubmit);
 
@@ -186,9 +186,9 @@ public class CentralCommunicationActor : ReceiveActor
         });
 
         // Audit Log site→central ingest: a site forwards a batch of audit
-        // events to the central cluster via ClusterClient. Ask the ingest proxy
+        // events to the central cluster. Ask the ingest proxy
         // and pipe the IngestAuditEventsReply back to the original Sender (the
-        // site's ClusterClient path) so the site can flip its rows to Forwarded.
+        // site's transport path) so the site can flip its rows to Forwarded.
         Receive<IngestAuditEventsCommand>(HandleIngestAuditEvents);
 
         // Audit Log combined-telemetry ingest: routes to the same proxy
@@ -196,9 +196,9 @@ public class CentralCommunicationActor : ReceiveActor
         Receive<IngestCachedTelemetryCommand>(HandleIngestCachedTelemetry);
 
         // Startup reconciliation: a site node forwards its local deployed inventory on
-        // startup via ClusterClient. Resolve the scoped ReconcileService, diff the
+        // startup. Resolve the scoped ReconcileService, diff the
         // inventory against central's expected set, and pipe the ReconcileSiteResponse
-        // (gap fetch tokens + orphans) straight back to the site node's ClusterClient.
+        // (gap fetch tokens + orphans) straight back to the site node.
         Receive<ReconcileSiteRequest>(HandleReconcileSiteRequest);
     }
 
@@ -254,7 +254,7 @@ public class CentralCommunicationActor : ReceiveActor
         }
 
         // Capture Sender before the async/PipeTo — Akka resets Sender between
-        // dispatches. The reply is piped straight back to the site's ClusterClient.
+        // dispatches. The reply is piped straight back to the calling site node.
         // On an Ask timeout or a faulted reply, PipeTo delivers a Status.Failure to
         // replyTo: the fault propagates to the caller rather than being swallowed.
         // The site's own Ask through this path then faults, and the site drain loop
@@ -285,10 +285,10 @@ public class CentralCommunicationActor : ReceiveActor
     }
 
     /// <summary>
-    /// Startup reconciliation (site→central over ClusterClient): resolve the scoped
+    /// Startup reconciliation (site→central): resolve the scoped
     /// <see cref="ReconcileService"/> in a DI scope, diff the node's reported inventory
     /// against central's expected set, and pipe the <see cref="ReconcileSiteResponse"/>
-    /// back to the site node's ClusterClient path. The actor stays thin — all the diff
+    /// back to the site node's transport path. The actor stays thin — all the diff
     /// and staging logic lives in the service. Mirrors the DB-access pattern used by
     /// <see cref="LoadSiteAddressesFromDb"/> (Task.Run + CreateScope + PipeTo) and the
     /// Sender-preservation pattern of <see cref="HandleIngestAuditEvents"/>.
@@ -331,7 +331,7 @@ public class CentralCommunicationActor : ReceiveActor
         MarkHeartbeatLocally(heartbeat);
 
         // Fan the heartbeat out to the peer central node so BOTH aggregators mark
-        // it, regardless of which central node the site's ClusterClient delivered
+        // it, regardless of which central node the site delivered
         // to. Without this, a heartbeat that only ever reaches one node leaves the
         // other node's aggregator blind to that site's liveness after a failover
         // (arch review 02, Low). MarkHeartbeat is idempotent (timestamp overwrite),
@@ -358,7 +358,7 @@ public class CentralCommunicationActor : ReceiveActor
     }
 
     /// <summary>
-    /// Handles a report delivered directly from a site (via ClusterClient):
+    /// Handles a report delivered directly from a site:
     /// process locally, then fan out to the peer central node so its
     /// aggregator stays in sync.
     /// </summary>
@@ -407,7 +407,7 @@ public class CentralCommunicationActor : ReceiveActor
     // HandleConnectionStateChanged removed — no production
     // caller emitted ConnectionStateChanged, so the workflow ran only in tests.
     // Disconnect detection is owned by the transport layers (gRPC keepalive +
-    // ClusterClient/Ask timeout).
+    // Ask timeout).
 
     private void HandleSiteEnvelope(SiteEnvelope envelope)
     {
@@ -491,8 +491,8 @@ public class CentralCommunicationActor : ReceiveActor
 
     private void HandleSiteAddressCacheLoaded(SiteAddressCacheLoaded msg)
     {
-        // Per-transport per-site resource reconciliation (create/stop ClusterClients, or
-        // build/drop gRPC channel pairs). Runs on the actor thread each refresh tick.
+        // Per-site transport resource reconciliation (build/drop gRPC channel
+        // pairs). Runs on the actor thread each refresh tick.
         _transport.ReconcileSites(msg);
 
         // Self-healing eviction: a site deleted from configuration would otherwise
@@ -525,7 +525,7 @@ public class CentralCommunicationActor : ReceiveActor
 
         // Subscribe to the peer-replication topic so we receive health reports
         // delivered to the other central node and keep our local aggregator
-        // in sync (ClusterClient load-balances reports across nodes).
+        // in sync (a site may deliver its report to either central node).
         // Tolerant of non-clustered hosts (TestKit) where the extension is absent.
         try
         {
@@ -581,7 +581,7 @@ public record RefreshSiteAddresses;
 /// discipline. The producer wraps the constructed buckets with
 /// <c>List&lt;T&gt;.AsReadOnly()</c> before piping to Self.
 /// </summary>
-/// <param name="SiteContacts">Akka ClusterClient contact addresses per site (from NodeA/NodeBAddress).</param>
+/// <param name="SiteContacts">Akka remote addresses per site (from NodeA/NodeBAddress).</param>
 /// <param name="KnownSiteIds">Every configured site id, address-bearing or not, for aggregator pruning.</param>
 /// <param name="GrpcContacts">
 /// gRPC endpoint pairs per site (from GrpcNodeA/GrpcNodeBAddress) — the streaming path's columns,
@@ -603,8 +603,8 @@ public readonly record struct SiteGrpcEndpoints(string? NodeA, string? NodeB);
 /// <summary>
 /// Peer-replication envelope for a site heartbeat, fanned out over the same
 /// DistributedPubSub topic as <see cref="SiteHealthReportReplica"/> so both
-/// central aggregators mark heartbeats regardless of which node the site's
-/// ClusterClient delivered to. Only ever travels central↔central (same assembly
+/// central aggregators mark heartbeats regardless of which node the site
+/// delivered to. Only ever travels central↔central (same assembly
 /// version, rolled together), so the default reflective serializer is safe.
 /// </summary>
 public sealed record SiteHeartbeatReplica(HeartbeatMessage Heartbeat);

src/ZB.MOM.WW.ScadaBridge.Communication/Actors/DebugStreamBridgeActor.cs

@@ -94,10 +94,10 @@ public class DebugStreamBridgeActor : ReceiveActor, IWithTimers
     /// <summary>
     /// Initializes the debug stream bridge actor and registers message handlers.
     /// </summary>
-    /// <param name="siteIdentifier">Site identifier for targeting ClusterClient messages and logging.</param>
+    /// <param name="siteIdentifier">Site identifier for targeting site-addressed messages and logging.</param>
     /// <param name="instanceUniqueName">Unique name of the instance whose debug stream is being bridged.</param>
     /// <param name="correlationId">Correlation id for the debug session.</param>
-    /// <param name="centralCommunicationActor">Actor used to forward ClusterClient messages to the site.</param>
+    /// <param name="centralCommunicationActor">Actor used to forward site-addressed messages to the site.</param>
     /// <param name="onEvent">Callback invoked on each received debug event.</param>
     /// <param name="onTerminated">Callback invoked when the stream terminates.</param>
     /// <param name="grpcFactory">Factory for creating gRPC streaming clients.</param>
@@ -124,7 +124,7 @@ public class DebugStreamBridgeActor : ReceiveActor, IWithTimers
         _grpcNodeAAddress = grpcNodeAAddress;
         _grpcNodeBAddress = grpcNodeBAddress;
 
-        // Initial snapshot response from the site (via ClusterClient).
+        // Initial snapshot response from the site.
         // If the site reports InstanceNotFound=true the instance is not
         // deployed there. Under the stream-first lifecycle the gRPC stream
         // was already opened in PreStart, so the not-found path must tear it down

src/ZB.MOM.WW.ScadaBridge.Communication/Actors/ISiteCommandTransport.cs

@@ -4,13 +4,11 @@ namespace ZB.MOM.WW.ScadaBridge.Communication.Actors;
 
 /// <summary>
 /// The central→site command-send seam, injected into <see cref="CentralCommunicationActor"/>
-/// below the <see cref="SiteEnvelope"/> handler. Exactly one implementation is active per node,
-/// chosen by <c>ScadaBridge:Communication:SiteTransport</c>:
-/// <list type="bullet">
-///   <item><see cref="AkkaSiteTransport"/> — today's per-site <c>ClusterClient</c> path (default).</item>
-///   <item><see cref="ZB.MOM.WW.ScadaBridge.Communication.Grpc.GrpcSiteTransport"/> — the site
-///     <c>SiteCommandService</c> gRPC plane.</item>
-/// </list>
+/// below the <see cref="SiteEnvelope"/> handler. The sole implementation is
+/// <see cref="ZB.MOM.WW.ScadaBridge.Communication.Grpc.GrpcSiteTransport"/>, over the site
+/// <c>SiteCommandService</c> gRPC plane. The seam predates that: it was introduced so the Akka
+/// <c>ClusterClient</c> path and the gRPC plane could run side by side during the migration, and
+/// is kept because it is the natural substitution point for tests.
 /// The producers above the seam (<c>CommunicationService</c>'s 27 commands, <c>SiteCallAuditActor</c>'s
 /// 2 parked relays, and <c>DebugStreamBridgeActor</c>'s subscribe/unsubscribe) are unchanged — they
 /// still <c>Ask</c>/<c>Tell</c> a <see cref="SiteEnvelope"/> to the actor, which delegates here.
@@ -27,14 +25,14 @@ public interface ISiteCommandTransport
     /// delivered to <paramref name="replyTo"/> — for an <c>Ask</c> that is the temporary ask actor
     /// (completing the caller's task); for a <c>Tell</c>-with-sender (the debug bridge) that is the
     /// originating actor. A message with no route (an unknown site) is warned and dropped so the
-    /// caller's <c>Ask</c> times out, exactly as today's ClusterClient path behaves.
+    /// caller's <c>Ask</c> times out — central never buffers for an unreachable site.
     /// </summary>
     /// <param name="envelope">The site-addressed command envelope.</param>
     /// <param name="replyTo">Where a reply (or a <see cref="Status.Failure"/>) is delivered.</param>
     void Send(SiteEnvelope envelope, IActorRef replyTo);
 
     /// <summary>
-    /// Reconciles per-site transport resources (ClusterClients for Akka, channel pairs for gRPC)
+    /// Reconciles per-site transport resources (gRPC channel pairs)
     /// against the freshly loaded site set. Called once per DB refresh tick with the same cache
     /// message the actor already receives — the ONE DB-poll loop feeds both transports.
     /// </summary>

src/ZB.MOM.WW.ScadaBridge.Communication/Actors/SiteAlarmAggregatorActor.cs

@@ -536,7 +536,7 @@ public sealed class SiteAlarmAggregatorActor : ReceiveActor, IWithTimers
         if (_retryCount > MaxRetries)
         {
             // Give up the stream, but do NOT stop the aggregator: the periodic reconcile
-            // still refreshes the cache from ClusterClient snapshots, so the page keeps a
+            // still refreshes the cache from site snapshots, so the page keeps a
             // (slower) live-ish view rather than going dark. A later reconcile-triggered
             // reconnect is not attempted here; the stream is simply left down.
             _log.Error("Site-alarm gRPC stream for {0} exceeded max retries ({1}); leaving stream down, " +

src/ZB.MOM.WW.ScadaBridge.Communication/Actors/SiteCommandDispatcher.cs

@@ -21,8 +21,8 @@ namespace ZB.MOM.WW.ScadaBridge.Communication.Actors;
 /// </summary>
 /// <remarks>
 /// <para>
-/// Two transports call this one unit: the Akka <see cref="SiteCommunicationActor"/>
-/// (ClusterClient) and the new <c>SiteCommandGrpcService</c> (gRPC). Centralising the
+/// Two entry points call this one unit: the site-side <see cref="SiteCommunicationActor"/>
+/// and <c>SiteCommandGrpcService</c>. Centralising the
 /// table means the two can never drift on where a command goes. Each transport keeps
 /// its own send mechanics — the actor <c>Forward</c>s (preserving the Ask sender), the
 /// gRPC service <c>Ask</c>s and encodes the reply — but both read the same
@@ -219,9 +219,9 @@ public sealed class SiteCommandDispatcher
     private static Route Immediate(object reply) => new(RouteDisposition.ImmediateReply, null, reply);
 
     /// <summary>
-    /// The actor's failover path: resolve the standby AND issue the leave in one step (today's
-    /// coupled behaviour over ClusterClient, where <c>Tell</c> merely enqueues the ack so leave
-    /// order is immaterial), then return the ack.
+    /// The actor's failover path: resolve the standby AND issue the leave in one step (coupled,
+    /// because <c>Tell</c> merely enqueues the ack so leave order is immaterial here), then
+    /// return the ack.
     /// </summary>
     /// <param name="msg">The failover command.</param>
     /// <returns>The ack to send back.</returns>
@@ -283,8 +283,8 @@ public sealed class SiteCommandDispatcher
         }
         catch (Exception ex)
         {
-            // A fault must be reported to the operator, never thrown into supervision (over
-            // ClusterClient) or surfaced as a broken stream (over gRPC).
+            // A fault must be reported to the operator, never thrown into supervision or
+            // surfaced as a broken stream (over gRPC).
             return new FailoverOutcome(
                 new SiteFailoverAck(
                     msg.CorrelationId, Accepted: false, TargetAddress: null, ErrorMessage: ex.Message),

src/ZB.MOM.WW.ScadaBridge.Communication/Actors/SiteCommunicationActor.cs

@@ -16,9 +16,10 @@ using ZB.MOM.WW.ScadaBridge.Commons.Messages.RemoteQuery;
 namespace ZB.MOM.WW.ScadaBridge.Communication.Actors;
 
 /// <summary>
-/// Site-side actor that receives messages from central via ClusterClient and routes
-/// them to the appropriate local actors. Also sends heartbeats and health reports
-/// to central via the registered ClusterClient.
+/// Site-side actor that receives messages from central over the site-hosted
+/// <c>SiteCommandService</c> gRPC plane and routes them to the appropriate local actors.
+/// Also sends heartbeats and health reports to central over its
+/// <see cref="ICentralTransport"/> (<see cref="Grpc.GrpcCentralTransport"/> in production).
 ///
 /// Routes all 8 message patterns to local handlers.
 /// </summary>
@@ -157,15 +158,15 @@ public class SiteCommunicationActor : ReceiveActor, IWithTimers
         // the SITE-SPECIFIC role, because that is what site singletons (the Deployment
         // Manager) are placed on. Either node may receive this (the actor is per-node, not a
         // singleton, and contact rotation picks whichever answers); the target is resolved
-        // from cluster state, not from who received the message. Over ClusterClient the ack
-        // Tell merely enqueues, so the dispatcher resolves-and-leaves in one step (the gRPC
-        // transport defers the leave to keep ack-before-Leave — see PrepareFailover).
+        // from cluster state, not from who received the message. The gRPC transport defers the
+        // leave to keep ack-before-Leave — see PrepareFailover. (Under the removed ClusterClient
+        // path the ack Tell merely enqueued, so the dispatcher resolved-and-left in one step.)
         Receive<TriggerSiteFailover>(msg => Sender.Tell(_dispatcher.HandleFailover(msg)));
 
-        // The seven site→central sends now delegate to the injected transport (ClusterClient by
-        // default, gRPC when configured). Each handler captures the current Sender as the reply
-        // target so central's reply routes straight back to the waiting Ask, not through this
-        // actor — the exact sender-forwarding the ClusterClient path relied on. The per-message
+        // The seven site→central sends delegate to the injected transport (GrpcCentralTransport in
+        // production). Each handler captures the current Sender as the reply target so central's
+        // reply routes straight back to the waiting Ask, not through this actor — preserving the
+        // sender-forwarding the original ClusterClient path relied on. The per-message
         // "no transport / not-accepted" fallbacks live inside the transport now.
 
         // Notification Outbox: forward a buffered notification (S&F forwarder's Ask → ack back).
@@ -229,9 +230,9 @@ public class SiteCommunicationActor : ReceiveActor, IWithTimers
     /// Executes a resolved command route within the actor: Forward to the target (preserving the
     /// central Ask sender so the reply routes straight back to the waiting Ask), or — when a
     /// null-guarded handler is unregistered — Tell the caller the dispatcher's synthetic reply.
-    /// The fire-and-forget disposition (UnsubscribeDebugView) is a plain Forward here, exactly as
-    /// before: over ClusterClient the site never acked it, so the synthetic ack is a gRPC-only
-    /// concern.
+    /// The fire-and-forget disposition (UnsubscribeDebugView) is a plain Forward here: the site
+    /// never acked it under the original ClusterClient path either, so the synthetic ack is a
+    /// gRPC-only concern.
     /// </summary>
     /// <param name="command">The migrated central→site command to route.</param>
     private void DispatchCommand(object command)

src/ZB.MOM.WW.ScadaBridge.Communication/CentralControlGrpc/CentralControlGrpc.cs

@@ -13,7 +13,7 @@ namespace ZB.MOM.WW.ScadaBridge.Communication.Grpc {
   ///
   /// Direction: SITE is the client, CENTRAL is the server — the inverse of
   /// SiteStreamService, where central dials the site. That asymmetry is deliberate
-  /// and mirrors the direction the Akka ClusterClient traffic flows today: these
+  /// and mirrors the direction the Akka ClusterClient traffic used to flow: these
   /// seven calls are exactly the seven messages SiteCommunicationActor sends to
   /// /user/central-communication.
   ///

src/ZB.MOM.WW.ScadaBridge.Communication/CommunicationService.cs

@@ -139,7 +139,7 @@ public class CommunicationService
     /// Queries a site for the currently-applied deployment
     /// identity of a single instance. Used by the Deployment Manager before a
     /// re-deploy to reconcile against the site's actual state. Sent over the
-    /// existing ClusterClient command/control transport; the Ask times out (no
+    /// gRPC command/control transport; the Ask times out (no
     /// central buffering) if the site is unreachable, and the caller falls
     /// through to a normal deploy.
     /// </summary>

src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/CentralControlDtoMapper.cs

@@ -16,8 +16,8 @@ namespace ZB.MOM.WW.ScadaBridge.Communication.Grpc;
 /// <para>
 /// The seven pairs mirror, one for one, the seven messages
 /// <c>SiteCommunicationActor</c> forwards to <c>/user/central-communication</c> over
-/// Akka <c>ClusterClient</c> today. Both transports carry the SAME message types
-/// end-to-end — central's handlers are untouched by the migration — so this mapper is
+/// the control plane. The in-process and wire representations carry the SAME message types
+/// end-to-end — central's handlers were untouched by the migration — so this mapper is
 /// the only place the two representations meet, and a field that does not survive a
 /// round-trip here is a field the gRPC transport silently drops.
 /// </para>

src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/CentralControlGrpcService.cs

@@ -14,7 +14,7 @@ namespace ZB.MOM.WW.ScadaBridge.Communication.Grpc;
 /// <summary>
 /// Central-hosted gRPC face of the seven site→central control messages
 /// (<c>Protos/central_control.proto</c>). Decodes each request onto the SAME in-process
-/// message type the Akka <c>ClusterClient</c> path already carries, <c>Ask</c>s
+/// message type the removed Akka <c>ClusterClient</c> path used to carry, <c>Ask</c>s
 /// <see cref="Actors.CentralCommunicationActor"/>, and encodes the reply back.
 /// </summary>
 /// <remarks>
@@ -26,8 +26,8 @@ namespace ZB.MOM.WW.ScadaBridge.Communication.Grpc;
 /// </para>
 /// <para>
 /// <b>Zero handler logic lives here.</b> Every RPC lands on a receive
-/// <c>CentralCommunicationActor</c> already implements for the ClusterClient path, so the two
-/// transports cannot drift in behaviour: the actor is the single implementation, and this class
+/// <c>CentralCommunicationActor</c> already implements, so transport and handler cannot drift
+/// in behaviour: the actor is the single implementation, and this class
 /// is a codec plus an <c>Ask</c>. That is also why the service takes the actor through
 /// <see cref="SetReady"/> rather than resolving anything from DI — the actor is created by the
 /// host's Akka bootstrap, not by the container.
@@ -36,8 +36,8 @@ namespace ZB.MOM.WW.ScadaBridge.Communication.Grpc;
 /// <b>Fault semantics deliberately differ from <see cref="SiteStreamGrpcServer"/>'s ingest
 /// RPCs.</b> That server answers a failed audit ingest with an EMPTY <c>IngestAck</c>; this one
 /// fails the call with a non-OK status. Both leave the site's rows <c>Pending</c> for the next
-/// drain, so the outcome is the same — but this service replaces the ClusterClient path, whose
-/// documented behaviour is to propagate the fault (<c>CentralCommunicationActor</c>'s
+/// drain, so the outcome is the same — but this service replaced the ClusterClient path, whose
+/// documented behaviour was to propagate the fault (<c>CentralCommunicationActor</c>'s
 /// <c>HandleIngestAuditEvents</c> pipes a <c>Status.Failure</c> back), and preserving that keeps
 /// a lost batch visible as a failure rather than as a successful call that acked nothing.
 /// </para>
@@ -94,8 +94,8 @@ public sealed class CentralControlGrpcService : CentralControlService.CentralCon
     /// actor exists and can receive, NOT that every downstream singleton proxy
     /// (<c>notification-outbox</c>, <c>audit-log-ingest</c>) has registered itself yet. Those
     /// register moments later in the same startup path, and the actor already answers a call
-    /// that beats them with the same "not available, retry" reply it gives on the ClusterClient
-    /// path — so gating readiness on them would add nothing but a longer window in which sites
+    /// that beats them with a "not available, retry" reply
+    /// — so gating readiness on them would add nothing but a longer window in which sites
     /// see <see cref="StatusCode.Unavailable"/>.
     /// </remarks>
     /// <param name="centralCommunicationActor">The central communication actor.</param>

src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/GrpcCentralTransport.cs

@@ -11,8 +11,8 @@ using AkkaStatus = Akka.Actor.Status;
 namespace ZB.MOM.WW.ScadaBridge.Communication.Grpc;
 
 /// <summary>
-/// The <see cref="ICentralTransport"/> that carries the seven site→central sends over gRPC — the
-/// migration target for the Akka <c>ClusterClient</c> path. Each method encodes the message with
+/// The <see cref="ICentralTransport"/> that carries the seven site→central sends over gRPC —
+/// the replacement for the removed Akka <c>ClusterClient</c> path. Each method encodes the message with
 /// <see cref="CentralControlDtoMapper"/>, dials <c>CentralControlService</c> through the sticky
 /// <see cref="CentralChannelProvider"/>, and delivers the decoded reply (or a transient-failure
 /// signal) to the waiting Ask.

src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/GrpcSiteTransport.cs

@@ -81,7 +81,7 @@ public sealed class GrpcSiteTransport : ISiteCommandTransport
         }
         catch (SiteChannelUnavailableException)
         {
-            // Parity with the Akka "no ClusterClient for site" path: warn and drop, so the caller's
+            // Parity with the removed Akka "no ClusterClient for site" path: warn and drop, so the caller's
             // Ask times out. Central never buffers.
             _logger.LogWarning(
                 "No gRPC channel for site {SiteId}; dropping {Message} (caller's Ask will time out)",

src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/SiteCommandGrpcService.cs

@@ -22,7 +22,7 @@ namespace ZB.MOM.WW.ScadaBridge.Communication.Grpc;
 /// </para>
 /// <para>
 /// <b>Coexistence — server-side only.</b> This makes the site ALSO listen on gRPC for commands;
-/// nothing central flips to gRPC here (that is T1B.3). Central still dials sites via ClusterClient.
+/// this was the server half, landed before central was flipped to dial it (T1B.3).
 /// </para>
 /// <para>
 /// <b>Fire-and-forget.</b> The Akka path never acks <c>UnsubscribeDebugView</c>, but a unary RPC

src/ZB.MOM.WW.ScadaBridge.Communication/Grpc/SitePairChannelProvider.cs

@@ -9,7 +9,7 @@ namespace ZB.MOM.WW.ScadaBridge.Communication.Grpc;
 /// <summary>
 /// Raised when a site has no usable gRPC channel — an unknown site, or a site with neither
 /// <c>GrpcNodeAAddress</c> nor <c>GrpcNodeBAddress</c> configured. The gRPC transport treats this
-/// the way the Akka path treats "no ClusterClient for site": warn and drop, so the caller's Ask
+/// the way the removed Akka path treated "no ClusterClient for site": warn and drop, so the caller's Ask
 /// times out (central never buffers).
 /// </summary>
 public sealed class SiteChannelUnavailableException(string siteId)

src/ZB.MOM.WW.ScadaBridge.Communication/Protos/central_control.proto

@@ -17,7 +17,7 @@ import "Protos/sitestream.proto";
 //
 // Direction: SITE is the client, CENTRAL is the server — the inverse of
 // SiteStreamService, where central dials the site. That asymmetry is deliberate
-// and mirrors the direction the Akka ClusterClient traffic flows today: these
+// and mirrors the direction the Akka ClusterClient traffic used to flow: these
 // seven calls are exactly the seven messages SiteCommunicationActor sends to
 // /user/central-communication.
 //

src/ZB.MOM.WW.ScadaBridge.Communication/ReconcileService.cs

@@ -8,8 +8,8 @@ namespace ZB.MOM.WW.ScadaBridge.Communication;
 
 /// <summary>
 /// Central-side startup-reconciliation handler. A site node, on startup, reports its
-/// local deployed inventory via <see cref="ReconcileSiteRequest"/> (delivered over
-/// ClusterClient to <see cref="Actors.CentralCommunicationActor"/>); this service diffs
+/// local deployed inventory via <see cref="ReconcileSiteRequest"/> (delivered over the
+/// control plane to <see cref="Actors.CentralCommunicationActor"/>); this service diffs
 /// it against central's expected deployed set and replies with fresh fetch tokens for the
 /// gap — instances the node is missing or has at a stale revision — plus the orphan names
 /// (present locally but no longer deployed centrally, which the node only logs).

src/ZB.MOM.WW.ScadaBridge.HealthMonitoring/IHealthReportTransport.cs

@@ -4,7 +4,7 @@ namespace ZB.MOM.WW.ScadaBridge.HealthMonitoring;
 
 /// <summary>
 /// Abstraction for sending health reports to central.
-/// In production, implemented over Akka ClusterClient with an acked round-trip
+/// In production, implemented over the gRPC central transport with an acked round-trip
 /// (review 01 [Medium]): the transport Asks and awaits a
 /// <see cref="SiteHealthReportAck"/>, so a lost/rejected report surfaces as a
 /// fault the sender can observe (and its per-interval counter-restore fires).

src/ZB.MOM.WW.ScadaBridge.Host/Actors/AkkaHostedService.cs

@@ -556,7 +556,7 @@ akka {{
             _logger);
 
         // Hand the audit-ingest proxy to the CentralCommunicationActor so audit
-        // ingest commands forwarded by sites over ClusterClient are routed to the
+        // ingest commands forwarded by sites are routed to the
         // singleton. Mirrors the RegisterNotificationOutbox wiring above.
         centralCommActor.Tell(new RegisterAuditIngest(auditIngest.Proxy));
 
@@ -628,7 +628,7 @@ akka {{
 
         // Hand the CentralCommunicationActor to the SiteCallAudit
         // actor so it can relay operator Retry/Discard on parked cached calls to
-        // the owning site (over the per-site ClusterClient via SiteEnvelope).
+        // the owning site (over the per-site gRPC transport via SiteEnvelope).
         // Mirrors the RegisterAuditIngest / RegisterNotificationOutbox wiring;
         // the message is sent to the singleton proxy so it reaches whichever
         // central node currently hosts the singleton.
@@ -896,7 +896,7 @@ akka {{
         // Event log handler — cluster singleton so queries always reach the
         // active node. The event log is node-local SQLite and is not
         // replicated; only the active node records events. A per-node handler
-        // would let a ClusterClient query land on the standby and find nothing.
+        // would let a central query land on the standby and find nothing.
         var eventLogQueryService = _serviceProvider.GetService<SiteEventLogging.IEventLogQueryService>();
         if (eventLogQueryService != null)
         {
@@ -1048,23 +1048,23 @@ akka {{
         // collaborators through its constructor, so we resolve them from DI
         // and pass them in via Props.Create rather than relying on a future
         // FactoryProvider. The real site→central client is constructed and
-        // wired immediately below: a ClusterClientSiteAuditClient (ClusterClient
-        // transport, not gRPC) replaces the DI-default NoOpSiteStreamAuditClient
+        // wired immediately below: a SiteCommunicationAuditClient (routing through
+        // the SiteCommunicationActor's central transport) replaces the DI-default NoOpSiteStreamAuditClient
         // for site roles, without disturbing the rest of this wiring.
         var siteAuditOptions = _serviceProvider
             .GetRequiredService<IOptions<ZB.MOM.WW.ScadaBridge.AuditLog.Site.Telemetry.SiteAuditTelemetryOptions>>();
         var siteAuditQueue = _serviceProvider
             .GetRequiredService<ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Services.ISiteAuditQueue>();
         // Audit Log follow-up: the production site→central audit
-        // push uses the ClusterClient transport via the SiteCommunicationActor,
+        // push routes through the SiteCommunicationActor's central transport,
         // not the DI-resolved NoOpSiteStreamAuditClient. The NoOp default stays
         // correct for central/test composition roots (no SiteCommunicationActor);
-        // a site role wires the real ClusterClient-based client here so the
+        // a site role wires the real client here so the
         // SQLite Pending backlog actually drains to central. The forward Ask
         // reuses NotificationForwardTimeout — the same site→central command
         // forward bound notifications already use over this transport.
         ZB.MOM.WW.ScadaBridge.AuditLog.Site.Telemetry.ISiteStreamAuditClient siteAuditClient =
-            new ZB.MOM.WW.ScadaBridge.AuditLog.Site.Telemetry.ClusterClientSiteAuditClient(
+            new ZB.MOM.WW.ScadaBridge.AuditLog.Site.Telemetry.SiteCommunicationAuditClient(
                 siteCommActor,
                 _communicationOptions.NotificationForwardTimeout);
         var siteAuditLogger = _serviceProvider.GetRequiredService<ILoggerFactory>()
@@ -1100,10 +1100,10 @@ akka {{
         // SetReady asserts a deliberately narrow contract. By this point the
         // actor system exists, SiteStreamManager.Initialize has run, and every
         // role actor (SiteCommunicationActor, deployment-manager singleton,
-        // the ClusterClient) has been created with ActorOf —
+        // the central transport) has been created with ActorOf —
         // creation and the registration Tells are synchronous and strictly ordered.
         // What is NOT guaranteed is completion of each actor's PreStart or the
-        // ClusterClient's initial-contact handshake with central: those are
+        // the central transport's initial connection to central: those are
         // intentionally asynchronous. Gating readiness on the central handshake would
         // be wrong — a site must come up and stream locally even while central is
         // briefly unreachable. gRPC readiness therefore guarantees "the site actor

src/ZB.MOM.WW.ScadaBridge.Host/Program.cs

@@ -160,7 +160,7 @@ try
         // which would let DI hand the instance back and bypass Grpc.AspNetCore's own activation
         // path (the shape that once hid a two-public-constructor defect until the rig caught it).
         // CentralControlGrpcService decodes each request onto the same in-process message the
-        // ClusterClient path carries and Asks CentralCommunicationActor — zero handler logic here.
+        // removed ClusterClient path used to carry, and Asks CentralCommunicationActor — zero handler logic here.
         builder.Services.AddGrpc(options =>
         {
             options.Interceptors.Add<CentralControlAuthInterceptor>();
@@ -638,7 +638,7 @@ try
         builder.Services.AddSingleton<ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteStreamGrpcServer>();
         // Site command plane (central→site) — the gRPC peer of SiteStreamGrpcServer. Both share
         // the h2c listener and the ControlPlaneAuthInterceptor PSK gate; both are readiness-gated
-        // (SetReady, below). Central still dials over ClusterClient until T1B.3.
+        // (SetReady, below).
         builder.Services.AddSingleton<ZB.MOM.WW.ScadaBridge.Communication.Grpc.SiteCommandGrpcService>();
 
         // Existing site service registrations (this is also where LocalDb and its

src/ZB.MOM.WW.ScadaBridge.InboundAPI/RouteHelper.cs

@@ -388,7 +388,7 @@ public class RouteTarget
 
     /// <summary>
     /// N3: awaits a routed Ask and TYPES unreachability. AskTimeoutException means
-    /// the site never answered (no ClusterClient contact, site down, partition) —
+    /// the site never answered (no route to the site, site down, partition) —
     /// the communication layer's own typed signal (CentralCommunicationActor drops
     /// envelopes for contactless sites so the Ask expires caller-side) — and
     /// surfaces as SiteUnreachableException so the executor maps it to the spec's

src/ZB.MOM.WW.ScadaBridge.ManagementService/ManagementActor.cs

@@ -38,7 +38,7 @@ using ZB.MOM.WW.ScadaBridge.TemplateEngine.Services;
 namespace ZB.MOM.WW.ScadaBridge.ManagementService;
 
 /// <summary>
-/// Central actor that handles all management commands from the CLI (via ClusterClient).
+/// Central actor that handles all management commands from the CLI (via the HTTP /management endpoint).
 /// Receives ManagementEnvelope messages, authorizes based on roles, then delegates to
 /// the appropriate service or repository using scoped DI.
 /// </summary>
@@ -477,7 +477,7 @@ public class ManagementActor : ReceiveActor
             // NOTE: ResolveRolesCommand is intentionally NOT dispatched. The two-step
             // "ResolveRoles + command" flow is retired — the HTTP endpoint performs LDAP
             // auth and role resolution itself before sending a single envelope. Leaving a
-            // handler would expose role-mapping data to any raw ClusterClient sender with
+            // handler would expose role-mapping data to any raw in-cluster sender with
             // no role requirement; the command now falls through to the default below.
             _ => throw new NotSupportedException($"Unknown command type: {command.GetType().Name}")
         };

src/ZB.MOM.WW.ScadaBridge.SiteCallAudit/SiteCallAuditActor.cs

@@ -164,7 +164,7 @@ public class SiteCallAuditActor : ReceiveActor
     /// <summary>
     /// The central→site command transport — the
     /// <c>CentralCommunicationActor</c>, which owns the per-site
-    /// <c>ClusterClient</c> map and routes a <see cref="SiteEnvelope"/> to the
+    /// transport map and routes a <see cref="SiteEnvelope"/> to the
     /// owning site. Set via <see cref="RegisterCentralCommunication"/> by the
     /// Host after both actors exist (this actor is a cluster singleton; the
     /// transport actor is created separately). Null until registration
@@ -1079,7 +1079,7 @@ public class SiteCallAuditActor : ReceiveActor
     /// <c>SiteCalls</c> mirror row. It wraps a <see cref="RetryParkedOperation"/>
     /// in a <see cref="SiteEnvelope"/> addressed to <c>SourceSite</c>, Asks the
     /// <c>CentralCommunicationActor</c> (which routes it over the per-site
-    /// <c>ClusterClient</c>), and maps the site's
+    /// gRPC transport), and maps the site's
     /// <see cref="ParkedOperationActionAck"/> — or an Ask timeout — onto a
     /// <see cref="RetrySiteCallResponse"/>. A timeout / no-route is reported as
     /// the distinct <see cref="SiteCallRelayOutcome.SiteUnreachable"/> outcome,

src/ZB.MOM.WW.ScadaBridge.SiteCallAudit/SiteCallAuditOptions.cs

@@ -30,7 +30,7 @@ public class SiteCallAuditOptions
     /// Ask timeout for the central→site Retry/Discard relay. When
     /// the owning site does not ack a <c>RetryParkedOperation</c> /
     /// <c>DiscardParkedOperation</c> within this window — site offline, no
-    /// ClusterClient route, or central buffering deliberately absent — the relay
+    /// route to the site, or central buffering deliberately absent — the relay
     /// reports a <c>SiteUnreachable</c> outcome. Default 10 seconds: long enough
     /// to absorb a healthy cross-cluster round-trip, short enough that an
     /// operator clicking Retry on an offline site gets a fast, honest answer.

src/ZB.MOM.WW.ScadaBridge.SiteRuntime/Actors/SiteReconciliationActor.cs

@@ -27,8 +27,8 @@ namespace ZB.MOM.WW.ScadaBridge.SiteRuntime.Actors;
 /// crashes on these failures.
 /// </para>
 /// <para>
-/// The pass runs after a small startup delay (so the central ClusterClient has time to
-/// register) and is driven entirely off the actor thread: the Ask + fetch + write happen in
+/// The pass runs after a small startup delay (so the site's central transport has time to
+/// connect) and is driven entirely off the actor thread: the Ask + fetch + write happen in
 /// an awaited continuation whose summary is captured in an internal message
 /// <see cref="ReconcilePassResult"/> piped back to <c>Self</c>. The actor thread never blocks.
 /// </para>
@@ -60,14 +60,14 @@ public sealed class SiteReconciliationActor : ReceiveActor, IWithTimers
     /// <param name="configFetcher">Fetches a deployment's flattened config JSON from central over HTTP.</param>
     /// <param name="siteCommunicationActor">
     /// The site's <c>SiteCommunicationActor</c>; it forwards the
-    /// <see cref="ReconcileSiteRequest"/> over the registered central ClusterClient and routes
+    /// <see cref="ReconcileSiteRequest"/> over the site's central transport and routes
     /// the <see cref="ReconcileSiteResponse"/> back to this actor's Ask.
     /// </param>
     /// <param name="siteIdentifier">This node's site identifier (resolved by central).</param>
     /// <param name="nodeId">This node's semantic id (e.g. <c>node-a</c>/<c>node-b</c>), for logging/diagnostics.</param>
     /// <param name="logger">Logger.</param>
     /// <param name="initialDelay">
-    /// Delay before the single startup pass, giving the central ClusterClient time to register.
+    /// Delay before the single startup pass, giving the site's central transport time to connect.
     /// Defaults to 5 seconds.
     /// </param>
     /// <param name="askTimeout">Round-trip timeout for the reconcile Ask to central. Defaults to 30 seconds.</param>
@@ -105,7 +105,7 @@ public sealed class SiteReconciliationActor : ReceiveActor, IWithTimers
     protected override void PreStart()
     {
         base.PreStart();
-        // One-shot pass after a small delay so the central ClusterClient can register first.
+        // One-shot pass after a small delay so the site's central transport can connect first.
         // Non-blocking: the timer fires RunReconcile back onto this actor's mailbox.
         Timers.StartSingleTimer(StartupTimerKey, RunReconcile.Instance, _initialDelay);
         _logger.LogInformation(

src/ZB.MOM.WW.ScadaBridge.SiteRuntime/Scripts/ScriptRuntimeContext.cs

@@ -74,7 +74,7 @@ public class ScriptRuntimeContext
 
     /// <summary>
     /// Notification Outbox: the site communication actor that <c>Notify.Status</c>
-    /// queries central through (via the ClusterClient command/control transport).
+    /// queries central through (via the gRPC command/control transport).
     /// </summary>
     private readonly ICanTell? _siteCommunicationActor;
 
@@ -175,7 +175,7 @@ public class ScriptRuntimeContext
     /// <param name="externalSystemClient">Optional client for external system API calls.</param>
     /// <param name="databaseGateway">Optional gateway for database connection and cached write access.</param>
     /// <param name="storeAndForward">Optional store-and-forward service for notification delivery.</param>
-    /// <param name="siteCommunicationActor">Optional actor for site-to-central communication (ClusterClient).</param>
+    /// <param name="siteCommunicationActor">Optional actor for site-to-central communication.</param>
     /// <param name="siteId">Identifier of the site where this instance is running.</param>
     /// <param name="sourceScript">Optional name of the source script for audit trail identification.</param>
     /// <param name="auditWriter">Optional writer for audit log entries.</param>

src/ZB.MOM.WW.ScadaBridge.StoreAndForward/NotificationForwarder.cs

@@ -26,10 +26,10 @@ namespace ZB.MOM.WW.ScadaBridge.StoreAndForward;
 ///   for operator forensics.</description></item>
 /// </list>
 ///
-/// The forward travels over the ClusterClient command/control transport: the handler
+/// The forward travels over the gRPC command/control transport: the handler
 /// <see cref="ActorRefImplicitSenderExtensions.Ask{T}(ICanTell, object, TimeSpan?)">Asks</see>
 /// the site communication actor, which wraps the message in a
-/// <c>ClusterClient.Send("/user/central-communication", …)</c> and routes central's
+/// <c>SubmitNotification</c> call on <c>CentralControlService</c> and routes central's
 /// reply straight back to this Ask.
 /// </summary>
 public sealed class NotificationForwarder
@@ -45,7 +45,7 @@ public sealed class NotificationForwarder
     /// </summary>
     /// <param name="siteCommunicationActor">
     /// The site communication actor. It forwards a <see cref="NotificationSubmit"/> to
-    /// central via the registered ClusterClient and replies with the
+    /// central over the site's central transport and replies with the
     /// <see cref="NotificationSubmitAck"/>.
     /// </param>
     /// <param name="sourceSiteId">This site's identifier, stamped on every submit.</param>