From 2561ba593bad3d527506a6a0f654452f3f099840 Mon Sep 17 00:00:00 2001
From: Argus Li <argus@argusli.dev>
Date: Thu, 18 Jun 2026 14:17:37 -0700
Subject: [PATCH 01/10] Rename connectionId to nodeId if not containing db.

Signed-off-by: Argus Li <argus@argusli.dev>
---
 .../activity-view/command-log-table.tsx          |  8 ++++----
 .../activity-view/hotkeys/hot-keys-banners.tsx   |  8 ++++----
 .../activity-view/hotkeys/hot-keys.tsx           |  2 +-
 .../commandlogs/commandLogsSlice.ts              |  2 +-
 .../valkey-features/hotkeys/hotKeysSlice.ts      |  2 +-
 apps/metrics/src/index.js                        | 16 ++++++++--------
 apps/server/src/actions/commandLogs.ts           |  6 +++---
 7 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/apps/frontend/src/components/activity-view/command-log-table.tsx b/apps/frontend/src/components/activity-view/command-log-table.tsx
index da5133a2..73886613 100644
--- a/apps/frontend/src/components/activity-view/command-log-table.tsx
+++ b/apps/frontend/src/components/activity-view/command-log-table.tsx
@@ -44,7 +44,7 @@ type LogType = "slow" | "large-request" | "large-reply"
 interface CommandLogTableProps {
   data: LogGroup[] | null
   logType: LogType
-  nodeErrors?: { connectionId: string; error: string }[]
+  nodeErrors?: { nodeId: string; error: string }[]
   isCluster?: boolean
 }
 
@@ -102,10 +102,10 @@ export function CommandLogTable({ data, logType, nodeErrors, isCluster }: Comman
       {nodeErrorsExpanded && (
         <ul className="absolute z-50 left-0 mt-0.5 right-0 p-3 max-h-40 overflow-y-auto space-y-0.5
            rounded-md border bg-accent shadow-sm">
-          {nodeErrors.map(({ connectionId, error }) => (
-            <li key={connectionId}>
+          {nodeErrors.map(({ nodeId, error }) => (
+            <li key={nodeId}>
               <Typography variant="bodySm">
-                <span className="font-mono">{connectionId}</span>: {error}
+                <span className="font-mono">{nodeId}</span>: {error}
               </Typography>
             </li>
           ))}
diff --git a/apps/frontend/src/components/activity-view/hotkeys/hot-keys-banners.tsx b/apps/frontend/src/components/activity-view/hotkeys/hot-keys-banners.tsx
index 2d02333d..b43f66a3 100644
--- a/apps/frontend/src/components/activity-view/hotkeys/hot-keys-banners.tsx
+++ b/apps/frontend/src/components/activity-view/hotkeys/hot-keys-banners.tsx
@@ -4,7 +4,7 @@ import { Alert, AlertDescription } from "../../ui/alert"
 import { Typography } from "../../ui/typography"
 
 interface NodeErrorsBannerProps {
-  nodeErrors: { connectionId: string; error: string }[]
+  nodeErrors: { nodeId: string; error: string }[]
 }
 
 export function NodeErrorsBanner({ nodeErrors }: NodeErrorsBannerProps) {
@@ -44,10 +44,10 @@ export function NodeErrorsBanner({ nodeErrors }: NodeErrorsBannerProps) {
       {expanded && (
         <ul className="absolute z-50 left-0 right-0 mt-0.5 p-3 max-h-40 overflow-y-auto space-y-0.5
            rounded-md border bg-accent shadow-sm">
-          {nodeErrors.map(({ connectionId, error }) => (
-            <li key={connectionId}>
+          {nodeErrors.map(({ nodeId, error }) => (
+            <li key={nodeId}>
               <Typography variant="bodySm">
-                <span className="font-mono">{connectionId}</span>: {error}
+                <span className="font-mono">{nodeId}</span>: {error}
               </Typography>
             </li>
           ))}
diff --git a/apps/frontend/src/components/activity-view/hotkeys/hot-keys.tsx b/apps/frontend/src/components/activity-view/hotkeys/hot-keys.tsx
index 4aa31927..9c3ce129 100644
--- a/apps/frontend/src/components/activity-view/hotkeys/hot-keys.tsx
+++ b/apps/frontend/src/components/activity-view/hotkeys/hot-keys.tsx
@@ -17,7 +17,7 @@ interface HotKeysProps {
   errorMessage: string | null
   status?: string
   monitorRunning?: boolean
-  nodeErrors?: { connectionId: string; error: string }[]
+  nodeErrors?: { nodeId: string; error: string }[]
   isCluster?: boolean
   onKeyClick?: (keyName: string) => void
   onStartMonitoring?: () => void
diff --git a/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.ts b/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.ts
index d93a254f..3889dd20 100644
--- a/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.ts
+++ b/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.ts
@@ -55,7 +55,7 @@ interface CommandLogState {
     count: number
     error?: JSONObject | null
     loading?: boolean
-    nodeErrors?: { connectionId: string; error: string }[]
+    nodeErrors?: { nodeId: string; error: string }[]
   }
 }
 
diff --git a/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.ts b/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.ts
index 4c16e4de..3a015d41 100644
--- a/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.ts
+++ b/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.ts
@@ -29,7 +29,7 @@ interface HotKeysState {
     nodeId: string | null,
     lastCollectedAt?: number | null,
     error?: JSONObject | null,
-    nodeErrors?: { connectionId: string; error: string }[],
+    nodeErrors?: { nodeId: string; error: string }[],
     status: HotKeysStatus,
   }
 }
diff --git a/apps/metrics/src/index.js b/apps/metrics/src/index.js
index ba90fdd3..f600ca42 100644
--- a/apps/metrics/src/index.js
+++ b/apps/metrics/src/index.js
@@ -28,7 +28,7 @@ async function main() {
   }
 
   const client = await createValkeyClient(cfg)
-  const ownConnectionId = sanitizeUrl(`${process.env.VALKEY_HOST}-${process.env.VALKEY_PORT}`)
+  const ownNodeId = sanitizeUrl(`${process.env.VALKEY_HOST}-${process.env.VALKEY_PORT}`)
 
   await setupNdjsonCleaner(cfg)
   await setupCollectors(client, cfg)
@@ -70,7 +70,7 @@ async function main() {
     }
   })
 
-  app.get("/commandlog", (req, res) => getCommandLogs(req, res, ownConnectionId))
+  app.get("/commandlog", (req, res) => getCommandLogs(req, res, ownNodeId))
 
   app.get("/slowlog_len", async (req, res) => {
     try {
@@ -90,9 +90,9 @@ async function main() {
   app.get("/hot-keys", async (req, res) => {
     if (req.query.useHotSlots === "true") {
       const hotKeys = await calculateHotKeysFromHotSlots(client, { count: Number(req.query.count) || 50 }).then(enrichHotKeys(client))
-      return res.json({ hotKeys, nodeId: ownConnectionId })
+      return res.json({ hotKeys, nodeId: ownNodeId })
     }
-    else useMonitor(res, client, ownConnectionId, Number(req.query.count) || 50)
+    else useMonitor(res, client, ownNodeId, Number(req.query.count) || 50)
   })
 
   app.post("/update-config", async (req, res) => {
@@ -121,7 +121,7 @@ async function main() {
   app.post("/connection/close", async (req, res) => {
     try {
       const { connectionId } = req.body
-      if (connectionId !== ownConnectionId) {
+      if (connectionId !== ownNodeId) {
         return res.status(400).json({
           ok: false,
           error: "Invalid connectionId",
@@ -166,7 +166,7 @@ async function main() {
               body: JSON.stringify({
                 metricsServerUri: `http://${metricsAdvertiseHost}:${metricsAdvertisePort}`,
                 pid: process.pid,
-                nodeId: ownConnectionId,
+                nodeId: ownNodeId,
               }),
             },
           )
@@ -211,7 +211,7 @@ async function main() {
         const response = await fetch(`http://${backendServerHost}:${backendServerPort}/orchestrator/ping`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ nodeId: ownConnectionId }),
+          body: JSON.stringify({ nodeId: ownNodeId }),
         })
 
         if (!response.ok) {
@@ -221,7 +221,7 @@ async function main() {
             await registerWithServer()
           }
         } else {
-          console.debug(`Ping successful for node: ${ownConnectionId}`)
+          console.debug(`Ping successful for node: ${ownNodeId}`)
         }
       } catch (err) {
         console.debug("Ping request error:", err)
diff --git a/apps/server/src/actions/commandLogs.ts b/apps/server/src/actions/commandLogs.ts
index 466eefcb..89da773c 100644
--- a/apps/server/src/actions/commandLogs.ts
+++ b/apps/server/src/actions/commandLogs.ts
@@ -42,7 +42,7 @@ type CommandLogsLargeResponse = {
 
 type CommandLogResponse = (CommandLogsLargeResponse | CommandLogsSlowResponse) & { nodeId?: string }
 
-type NodeError = { connectionId: string; error: string }
+type NodeError = { nodeId: string; error: string }
 
 const sendCommandLogsFulfilled = (
   ws: WebSocket,
@@ -109,14 +109,14 @@ export const commandLogsRequested = withDeps<Deps, void>(
       const metricsServerURI = metricsServerMap.get(toMetricsNodeId(nodeId))?.metricsURI
       if (!metricsServerURI) {
         if (!nodes) sendCommandLogsError(ws, nodeId, new Error("Metrics server URI not found"))
-        return { connectionId: nodeId, error: "Metrics server not started" } as NodeError
+        return { nodeId, error: "Metrics server not started" } as NodeError
       }
       try {
         console.debug(`[Command Logs ${commandLogType}] Fetching from:`, metricsServerURI)
         return await fetchCommandLogs(metricsServerURI, commandLogType)
       } catch (error) {
         if (!nodes) sendCommandLogsError(ws, nodeId, error)
-        return { connectionId: nodeId, error: error instanceof Error ? error.message : String(error) } as NodeError
+        return { nodeId, error: error instanceof Error ? error.message : String(error) } as NodeError
       }
     })
 

From 514581b3b9068f26980ae3d438dd9b2e8f37dfbb Mon Sep 17 00:00:00 2001
From: Argus Li <argus@argusli.dev>
Date: Fri, 19 Jun 2026 12:37:28 -0700
Subject: [PATCH 02/10] Split into explicit cluster/standalone branches and
 replies.

Signed-off-by: Argus Li <argus@argusli.dev>
---
 apps/server/src/actions/commandLogs.ts   |  22 +++--
 apps/server/src/actions/config.ts        | 101 ++++++++++++-----------
 apps/server/src/actions/hotkeys.ts       |  42 +++++-----
 apps/server/src/actions/monitorAction.ts |  92 ++++++++++++---------
 common/src/index.ts                      |   1 +
 common/src/reply-id.ts                   |  28 +++++++
 6 files changed, 163 insertions(+), 123 deletions(-)
 create mode 100644 common/src/reply-id.ts

diff --git a/apps/server/src/actions/commandLogs.ts b/apps/server/src/actions/commandLogs.ts
index 89da773c..7ece84bf 100644
--- a/apps/server/src/actions/commandLogs.ts
+++ b/apps/server/src/actions/commandLogs.ts
@@ -1,5 +1,5 @@
 import { type WebSocket } from "ws"
-import { VALKEY, COMMANDLOG_TYPE } from "valkey-common"
+import { VALKEY, COMMANDLOG_TYPE, type AggregateReplyId } from "valkey-common"
 import * as R from "ramda"
 import { withDeps, Deps } from "./utils"
 import { toMetricsNodeId } from "../metrics-orchestrator"
@@ -46,7 +46,7 @@ type NodeError = { nodeId: string; error: string }
 
 const sendCommandLogsFulfilled = (
   ws: WebSocket,
-  connectionId: string,
+  replyId: AggregateReplyId, // Commandlogs aggregates all cluster nodes into one result
   parsedResponse: CommandLogsSlowResponse | CommandLogsLargeResponse,
   commandLogType: CommandLogType,
   nodeErrors?: NodeError[],
@@ -55,7 +55,7 @@ const sendCommandLogsFulfilled = (
     JSON.stringify({
       type: VALKEY.COMMANDLOGS.commandLogsFulfilled,
       payload: {
-        connectionId,
+        ...replyId,
         parsedResponse,
         commandLogType,
         ...(nodeErrors?.length ? { nodeErrors } : {}),
@@ -101,21 +101,19 @@ export const commandLogsRequested = withDeps<Deps, void>(
     const commandLogType: CommandLogType = action.payload.commandLogType as CommandLogType
 
     const nodes = typeof clusterId === "string" ? clusterNodesRegistry[clusterId] : undefined
-    const connectionIds = nodes ? Object.keys(nodes) : [connectionId]
+    const nodeIds = nodes ? Object.keys(nodes) : [toMetricsNodeId(connectionId)]
 
-    const promises = connectionIds.map(async (nodeId: string) => {
-      // metricsServerMap is keyed by metrics-node-id; map at the boundary.
-      // Idempotent on the cluster-fan-out path where ids already lack `-db`.
-      const metricsServerURI = metricsServerMap.get(toMetricsNodeId(nodeId))?.metricsURI
+    const promises = nodeIds.map(async (nodeId: string) => {
+      const metricsServerURI = metricsServerMap.get(nodeId)?.metricsURI
       if (!metricsServerURI) {
-        if (!nodes) sendCommandLogsError(ws, nodeId, new Error("Metrics server URI not found"))
+        if (!nodes) sendCommandLogsError(ws, connectionId, new Error("Metrics server URI not found"))
         return { nodeId, error: "Metrics server not started" } as NodeError
       }
       try {
         console.debug(`[Command Logs ${commandLogType}] Fetching from:`, metricsServerURI)
         return await fetchCommandLogs(metricsServerURI, commandLogType)
       } catch (error) {
-        if (!nodes) sendCommandLogsError(ws, nodeId, error)
+        if (!nodes) sendCommandLogsError(ws, connectionId, error)
         return { nodeId, error: error instanceof Error ? error.message : String(error) } as NodeError
       }
     })
@@ -125,7 +123,7 @@ export const commandLogsRequested = withDeps<Deps, void>(
     const nodeErrors = nodes ? settled.filter((r): r is NodeError => !!r && "error" in r) : []
 
     if (!nodes) {
-      if (results[0]) sendCommandLogsFulfilled(ws, connectionId, results[0], commandLogType)
+      if (results[0]) sendCommandLogsFulfilled(ws, { connectionId }, results[0], commandLogType)
       return
     }
 
@@ -145,7 +143,7 @@ export const commandLogsRequested = withDeps<Deps, void>(
     const count = results[0]?.count ?? 0
     sendCommandLogsFulfilled(
       ws,
-      clusterId as string,
+      { clusterId: clusterId as string },
       { rows: [{ ts: Date.now(), metric: commandLogType, values: limitedValues }], count, checkAt: 0 } as CommandLogResponse,
       commandLogType,
       nodeErrors,
diff --git a/apps/server/src/actions/config.ts b/apps/server/src/actions/config.ts
index ec386f47..d686604c 100644
--- a/apps/server/src/actions/config.ts
+++ b/apps/server/src/actions/config.ts
@@ -1,5 +1,5 @@
 import { type WebSocket } from "ws"
-import { VALKEY } from "valkey-common"
+import { VALKEY, type AggregateReplyId } from "valkey-common"
 import { Deps, withDeps, fetchWithTimeout } from "./utils"
 import { toMetricsNodeId } from "../metrics-orchestrator"
 
@@ -10,56 +10,59 @@ interface ParsedResponse  {
   data: object
 }
 
+/**
+ * POST the config to a single node's metrics process and return its parsed result.
+ */
+async function postConfigToNode(
+  metricsServerURI: string | undefined,
+  config: unknown,
+): Promise<ParsedResponse> {
+  if (!metricsServerURI) {
+    return { success: false, message: "Metrics server URI not found", data: {} }
+  }
+  try {
+    const url = new URL("/update-config", metricsServerURI)
+    const response = await fetchWithTimeout(url.toString(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(config),
+    })
+    return await response.json() as ParsedResponse
+  } catch (error) {
+    return {
+      success: false,
+      message: error instanceof Error ? error.message : String(error),
+      data: error as object,
+    }
+  }
+}
+
 export const updateConfig = withDeps<Deps, void>(
   async ({ ws, metricsServerMap, action, clusterNodesRegistry }) => {
     const { connectionId, clusterId, config } = action.payload
-    const connectionIds = clusterId 
-      ? Object.keys(clusterNodesRegistry[clusterId as string] ?? {}).filter((id) => metricsServerMap.has(id))
-      : [connectionId]
 
-    const promises = connectionIds.map(async (connectionId: string) => {
-      // metricsServerMap is keyed by metrics-node-id; map at the boundary.
-      // Idempotent on the cluster-fan-out path where ids already lack `-db`.
-      const metricsServerURI = metricsServerMap.get(toMetricsNodeId(connectionId))?.metricsURI
-
-      if (!metricsServerURI) {
-        const normalizedError = {
-          success: false,
-          message: "Metrics server URI not found",
-          data: {},
-        }
-        sendUpdateError(ws, connectionId, normalizedError)
-        return
+    if (typeof clusterId === "string") {
+      const nodeIds = Object.keys(clusterNodesRegistry[clusterId] ?? {}).filter((id) => metricsServerMap.has(id))
+      const responses = await Promise.all(
+        nodeIds.map((nodeId) => postConfigToNode(metricsServerMap.get(nodeId)?.metricsURI, config)),
+      )
+      const firstFailure = responses.find((r) => !r.success)
+      if (firstFailure) {
+        sendUpdateError(ws, { clusterId }, firstFailure)
+      } else {
+        // All nodes responses are the same so we use the first.
+        sendUpdateFulfilled(ws, { clusterId }, responses[0] ?? { success: true, message: "", data: {} })
       }
+      return
+    }
 
-      try {
-        const url = new URL("/update-config", metricsServerURI)
-        const response = await fetchWithTimeout(url.toString(), {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify(config),
-        })
-
-        const parsedResponse = await response.json() as ParsedResponse
-        if (response.ok) {
-          sendUpdateFulfilled(ws, connectionId, parsedResponse)
-        } else {
-          sendUpdateError(ws, connectionId, parsedResponse)
-        }
-
-      } catch (error) {
-        const normalizedError = {
-          success: false,
-          message: error instanceof Error ? error.message : String(error),
-          data: error as object,
-        }
-        sendUpdateError(ws, connectionId, normalizedError)
-      }
-    })
-    await Promise.all(promises)
-
+    const nodeId = toMetricsNodeId(connectionId)
+    const response = await postConfigToNode(metricsServerMap.get(nodeId)?.metricsURI, config)
+    if (response.success) {
+      sendUpdateFulfilled(ws, { connectionId }, response)
+    } else {
+      sendUpdateError(ws, { connectionId }, response)
+    }
   },  
 )
 
@@ -79,14 +82,14 @@ export const enableClusterSlotStats = withDeps<Deps, void>(
 
 const sendUpdateFulfilled = (
   ws: WebSocket,
-  connectionId: string,
+  replyId: AggregateReplyId,
   parsedResponse: ParsedResponse,
 ) => {
   ws.send(
     JSON.stringify({
       type: VALKEY.CONFIG.updateConfigFulfilled,
       payload: {
-        connectionId,
+        ...replyId,
         response: parsedResponse,
       },
     }),
@@ -95,14 +98,14 @@ const sendUpdateFulfilled = (
 
 const sendUpdateError = (
   ws: WebSocket,
-  connectionId: string,
+  replyId: AggregateReplyId,
   parsedResponse: ParsedResponse,
 ) => {
   ws.send(
     JSON.stringify({
       type: VALKEY.CONFIG.updateConfigFailed,
       payload: {
-        connectionId,
+        ...replyId,
         response: parsedResponse,
       },
     }),
diff --git a/apps/server/src/actions/hotkeys.ts b/apps/server/src/actions/hotkeys.ts
index e98b4131..3bc62b6d 100644
--- a/apps/server/src/actions/hotkeys.ts
+++ b/apps/server/src/actions/hotkeys.ts
@@ -1,5 +1,5 @@
 import { type WebSocket } from "ws"
-import { VALKEY } from "valkey-common"
+import { VALKEY, type AggregateReplyId } from "valkey-common"
 import * as R from "ramda"
 import { withDeps, Deps } from "./utils"
 import { toMetricsNodeId } from "../metrics-orchestrator"
@@ -13,13 +13,13 @@ type HotKeysResponse = {
 }
 
 type NodeError = {
-  connectionId: string
+  nodeId: string
   error: string
 }
 
 const sendHotKeysFulfilled = (
   ws: WebSocket,
-  connectionId: string,
+  replyId: AggregateReplyId, // Hotkeys aggregates all cluster nodes into one result
   parsedResponse: HotKeysResponse,
   nodeErrors?: NodeError[],
 ) => {
@@ -27,7 +27,7 @@ const sendHotKeysFulfilled = (
     JSON.stringify({
       type: VALKEY.HOTKEYS.hotKeysFulfilled,
       payload: {
-        connectionId,
+        ...replyId,
         parsedResponse,
         ...(nodeErrors?.length ? { nodeErrors } : {}),
       },
@@ -55,26 +55,22 @@ const sendHotKeysError = (
 export const hotKeysRequested = withDeps<Deps, void>(
   async ({ ws, metricsServerMap, action, clusterNodesRegistry }) => {
     const { connectionId, clusterId, lfuEnabled, clusterSlotStatsEnabled } = action.payload
-    
+
     const nodes =
-      typeof clusterId === "string"
-        ? clusterNodesRegistry[clusterId]
-        : undefined
+      typeof clusterId === "string" 
+      ? clusterNodesRegistry[clusterId] 
+      : undefined
+
+    const nodeIds = nodes ? Object.keys(nodes) : [toMetricsNodeId(connectionId)]
 
-    const connectionIds = nodes
-      ? Object.keys(nodes)
-      : [connectionId]
-    
-    const promises = connectionIds.map(async (connectionId: string) => {
-      // metricsServerMap is keyed by metrics-node-id; map at the boundary.
-      // Idempotent on the cluster-fan-out path where ids already lack `-db`.
-      const metricsServerURI = metricsServerMap.get(toMetricsNodeId(connectionId))?.metricsURI
+    const promises = nodeIds.map(async (nodeId: string) => {
+      const metricsServerURI = metricsServerMap.get(nodeId)?.metricsURI
       if (!metricsServerURI) {
         if (!nodes) {
-          console.warn("Metrics server not started for node: ", connectionId)
+          console.warn("Metrics server not started for node: ", nodeId)
           return
         }
-        return { connectionId, error: "Metrics server not started" } as NodeError
+        return { nodeId, error: "Metrics server not started" } as NodeError
       }
       const url = new URL("/hot-keys", metricsServerURI)
       if (clusterSlotStatsEnabled && lfuEnabled) url.searchParams.set("useHotSlots", "true")
@@ -88,7 +84,7 @@ export const hotKeysRequested = withDeps<Deps, void>(
             sendHotKeysError(ws, connectionId, errorBody.error ?? `HTTP ${initialResponse.status}`)
             return
           }
-          return { connectionId, error: errorBody.error ?? `HTTP ${initialResponse.status}` } as NodeError
+          return { nodeId, error: errorBody.error ?? `HTTP ${initialResponse.status}` } as NodeError
         }
         const initialParsedResponse: HotKeysResponse = await initialResponse.json() as HotKeysResponse
         // Reads monitor data and returns when to fetch results (`checkAt`).
@@ -106,7 +102,7 @@ export const hotKeysRequested = withDeps<Deps, void>(
           sendHotKeysError(ws, connectionId, error)
           return
         }
-        return { connectionId, error: error instanceof Error ? error.message : String(error) } as NodeError
+        return { nodeId, error: error instanceof Error ? error.message : String(error) } as NodeError
       }
     })
 
@@ -117,13 +113,13 @@ export const hotKeysRequested = withDeps<Deps, void>(
     if (results.length === 0) {
       if (nodes) {
         const emptyResponse = { hotKeys: [], monitorRunning: false, checkAt: 0, nodeId: "" } as unknown as HotKeysResponse
-        sendHotKeysFulfilled(ws, clusterId as string, emptyResponse, nodeErrors)
+        sendHotKeysFulfilled(ws, { clusterId: clusterId as string }, emptyResponse, nodeErrors)
       }
       return
     }
 
     if (!nodes) {
-      sendHotKeysFulfilled(ws, connectionId, results[0])
+      sendHotKeysFulfilled(ws, { connectionId }, results[0])
       return
     }
 
@@ -146,5 +142,5 @@ export const hotKeysRequested = withDeps<Deps, void>(
     const monitorRunning = results.every((r) => r.monitorRunning)
     const lastCollectedAt = results.reduce((max, r) => Math.max(max, r.lastCollectedAt ?? 0), 0) || null
     const aggregatedResponse = { hotKeys: aggregatedHotKeys, monitorRunning, checkAt, nodeId, lastCollectedAt } as unknown as HotKeysResponse
-    sendHotKeysFulfilled(ws, clusterId as string, aggregatedResponse, nodeErrors)
+    sendHotKeysFulfilled(ws, { clusterId: clusterId as string }, aggregatedResponse, nodeErrors)
   })
diff --git a/apps/server/src/actions/monitorAction.ts b/apps/server/src/actions/monitorAction.ts
index e8e15e48..4e88daf4 100644
--- a/apps/server/src/actions/monitorAction.ts
+++ b/apps/server/src/actions/monitorAction.ts
@@ -1,5 +1,5 @@
 import { type WebSocket } from "ws"
-import { VALKEY, type MonitorAction } from "valkey-common"
+import { VALKEY, type MonitorAction, type NodeReplyId } from "valkey-common"
 import { withDeps, type Deps, fetchWithTimeout, type ReduxAction } from "./utils"
 import { updateConfig } from "./config"
 import { getOtherWatchers } from "../node-watchers"
@@ -14,14 +14,14 @@ type MonitorResponse = {
 
 const sendMonitorFulfilled = (
   ws: WebSocket,
-  connectionId: string,
+  replyId: NodeReplyId, // Monitor stores state PER NODE.
   parsedResponse: MonitorResponse,
 ) => {
   ws.send(
     JSON.stringify({
       type: VALKEY.MONITOR.monitorFulfilled,
       payload: {
-        connectionId,
+        ...replyId,
         parsedResponse,
       },
     }),
@@ -30,7 +30,7 @@ const sendMonitorFulfilled = (
 
 const sendMonitorError = (
   ws: WebSocket,
-  connectionId: string,
+  replyId: NodeReplyId,
   error: unknown,
 ) => {
   console.error(error)
@@ -38,7 +38,7 @@ const sendMonitorError = (
     JSON.stringify({
       type: VALKEY.MONITOR.monitorError,
       payload: {
-        connectionId,
+        ...replyId,
         error: error instanceof Error ? error.message : String(error),
       },
     }),
@@ -49,46 +49,60 @@ export const monitorRequested = withDeps<Deps, void>(
   async ({ ws, metricsServerMap, action, clusterNodesRegistry }) => {
     const { connectionId, clusterId, monitorAction } = action.payload
 
-    const connectionIds = clusterId
-      ? Object.keys(clusterNodesRegistry[clusterId as string] ?? {}).filter((id) => metricsServerMap.has(id))
-      : [connectionId]
-
-    const promises = connectionIds.map(async (connectionId: string) => {
-      // metricsServerMap is keyed by metrics-node-id; map at the boundary.
-      // Idempotent on the cluster-fan-out path where ids already lack `-db`.
-      const metricsServerURI = metricsServerMap.get(toMetricsNodeId(connectionId))?.metricsURI
+    if (typeof clusterId === "string") {
+      const nodeIds = Object.keys(clusterNodesRegistry[clusterId] ?? {}).filter((id) => metricsServerMap.has(id))
+      await Promise.all(nodeIds.map((nodeId) =>
+        runMonitorForNode(ws, metricsServerMap.get(nodeId)?.metricsURI, monitorAction, { clusterId, nodeId }, nodeId),
+      ))
+    } else {
+      // Standalone path
+    const nodeId = toMetricsNodeId(connectionId)
+    await runMonitorForNode(ws, metricsServerMap.get(nodeId)?.metricsURI, monitorAction, { connectionId }, connectionId)
+    }
+  })
 
-      if (!metricsServerURI) {
-        sendMonitorError(ws, connectionId, new Error("Metrics server URI not found"))
-        return
-      }
+/**
+ * Issue a single node's monitor request and emit the reply.
+ * @param replyId  the explicit id-space for the reply payload
+ * @param watcherId the id watchers are subscribed under (db-suffixed
+ *   `connectionId` on standalone, db-less `nodeId` on cluster)
+ */
+async function runMonitorForNode(
+  ws: WebSocket,
+  metricsServerURI: string | undefined,
+  monitorAction: unknown,
+  replyId: NodeReplyId,
+  watcherId: string,
+) {
+  if (!metricsServerURI) {
+    sendMonitorError(ws, replyId, new Error("Metrics server URI not found"))
+    return
+  }
 
-      try {
-        const url = `${metricsServerURI}/monitor?action=${monitorAction as MonitorAction}`
+  try {
+    const url = `${metricsServerURI}/monitor?action=${monitorAction as MonitorAction}`
 
-        console.debug(`[Monitor] ${monitorAction} request to:`, url)
-        const response = await fetchWithTimeout(url)
-        const parsedResponse: MonitorResponse = await response.json() as MonitorResponse
+    console.debug(`[Monitor] ${monitorAction} request to:`, url)
+    const response = await fetchWithTimeout(url)
+    const parsedResponse: MonitorResponse = await response.json() as MonitorResponse
 
-        if (!response.ok) {
-          sendMonitorError(ws, connectionId, new Error(parsedResponse.error ?? `HTTP ${response.status}`))
-          return
-        }
+    if (!response.ok) {
+      sendMonitorError(ws, replyId, new Error(parsedResponse.error ?? `HTTP ${response.status}`))
+      return
+    }
 
-        sendMonitorFulfilled(ws, connectionId, parsedResponse)
+    sendMonitorFulfilled(ws, replyId, parsedResponse)
 
-        // No need to broadcast on status as no state change.
-        if (monitorAction === "start" || monitorAction === "stop") {
-          getOtherWatchers(connectionId, ws).forEach((watcher) => {
-            sendMonitorFulfilled(watcher, connectionId, parsedResponse)
-          })
-        }
-      } catch (error) {
-        sendMonitorError(ws, connectionId, error)
-      }
-    })
-    await Promise.all(promises)
-  })
+    // No need to broadcast on status as no state change.
+    if (monitorAction === "start" || monitorAction === "stop") {
+      getOtherWatchers(watcherId, ws).forEach((watcher) => {
+        sendMonitorFulfilled(watcher, replyId, parsedResponse)
+      })
+    }
+  } catch (error) {
+    sendMonitorError(ws, replyId, error)
+  }
+}
 
 export const saveMonitorSettingsRequested = withDeps<Deps, void>(
   async ({ ws, clients, connectionId, metricsServerMap, connectedNodesByCluster, clusterNodesRegistry, action }) => {
diff --git a/common/src/index.ts b/common/src/index.ts
index 47fe1deb..d5fbd0ac 100644
--- a/common/src/index.ts
+++ b/common/src/index.ts
@@ -9,6 +9,7 @@ export * from "./json-utils"
 export * from "./key-tree-builder"
 export * from "./key-validators"
 export * from "./memory-usage-calculation"
+export * from "./reply-id"
 export * from "./time-utils"
 export * from "./ttl-conversion"
 export * from "./url-utils"
diff --git a/common/src/reply-id.ts b/common/src/reply-id.ts
new file mode 100644
index 00000000..34203c62
--- /dev/null
+++ b/common/src/reply-id.ts
@@ -0,0 +1,28 @@
+/**
+ * Explicit id-space envelopes for server → frontend reply payloads.
+ *
+ * Every metrics reply identifies itself with exactly one id-space so producer
+ * and consumer never disagree. Two shapes exist, distinguished by how the frontend stores the
+ * resulting state:
+ *
+ *   - `AggregateReplyId` — the reply is stored as a SINGLE entry per cluster (or
+ *     per standalone connection). Used by features that aggregate all cluster
+ *     nodes server-side into one result.
+ *
+ *   - `NodeReplyId` — the reply is stored PER NODE. Used by features that keep
+ *     per-node state on the frontend.
+ *
+ * Both share the standalone arm `{ connectionId }` (db-suffixed
+ * Connection_Identifier). No field ever holds a different id-space than its
+ * name; `clusterId`/`nodeId` are db-less, `connectionId` is db-suffixed.
+ */
+
+/** Cluster-scoped or standalone reply, stored as one entry per cluster/connection. */
+export type AggregateReplyId =
+  | { clusterId: string }
+  | { connectionId: string }
+
+/** Per-node (cluster) or standalone reply, stored as one entry per node/connection. */
+export type NodeReplyId =
+  | { clusterId: string; nodeId: string }
+  | { connectionId: string }

From 711fa95c6e66e318ffe6488b679853369811bef5 Mon Sep 17 00:00:00 2001
From: Argus Li <argus@argusli.dev>
Date: Fri, 19 Jun 2026 13:17:03 -0700
Subject: [PATCH 03/10] Fix changes in the frontend.

Signed-off-by: Argus Li <argus@argusli.dev>
---
 apps/frontend/src/state/epics/valkeyEpics.ts  |  2 +-
 .../commandlogs/commandLogsSlice.ts           | 24 +++++-----
 .../valkey-features/config/configSlice.ts     | 46 +++++++++++--------
 .../valkey-features/hotkeys/hotKeysSlice.ts   | 19 ++++----
 4 files changed, 50 insertions(+), 41 deletions(-)

diff --git a/apps/frontend/src/state/epics/valkeyEpics.ts b/apps/frontend/src/state/epics/valkeyEpics.ts
index d24e8c25..31fe4c72 100644
--- a/apps/frontend/src/state/epics/valkeyEpics.ts
+++ b/apps/frontend/src/state/epics/valkeyEpics.ts
@@ -395,7 +395,7 @@ export const setDataEpic = (store: Store) =>
         connectionDetails: { clusterId },
       } = action.payload as unknown as { connectionId:string, connectionDetails: { clusterId?: string } }
 
-      store.dispatch(setConfig( action.payload))
+      store.dispatch(setConfig(action.payload))
 
       if (action.type === clusterConnectFulfilled.type) {
         socket.next({ type: setClusterData.type, payload: { clusterId, connectionId } })
diff --git a/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.ts b/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.ts
index 3889dd20..f0bd64e5 100644
--- a/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.ts
+++ b/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.ts
@@ -82,11 +82,12 @@ const commandLogsSlice = createSlice({
       state[id].loading = true
     },
     commandLogsFulfilled: (state, action) => {
-      const { connectionId, parsedResponse, nodeErrors } = action.payload
+      const { parsedResponse, nodeErrors } = action.payload
+      const key = action.payload.clusterId ?? action.payload.connectionId
       const commandLogType: CommandLogType = action.payload.commandLogType
       const { rows, count } = parsedResponse
-      if (!state[connectionId]) {
-        state[connectionId] = {
+      if (!state[key]) {
+        state[key] = {
           logs: {
             slow: [],
             [COMMANDLOG_TYPE.LARGE_REQUEST]: [],
@@ -96,16 +97,17 @@ const commandLogsSlice = createSlice({
           loading: false,
         }
       }
-      state[connectionId].logs[commandLogType] = rows
-      state[connectionId].count = count
-      state[connectionId].loading = false
-      state[connectionId].nodeErrors = nodeErrors ?? []
+      state[key].logs[commandLogType] = rows
+      state[key].count = count
+      state[key].loading = false
+      state[key].nodeErrors = nodeErrors ?? []
     },
     commandLogsError: (state, action) => {
-      const { connectionId, error } = action.payload
-      if (state[connectionId]) {
-        state[connectionId].error = error
-        state[connectionId].loading = false
+      const { error } = action.payload
+      const key = action.payload.clusterId ?? action.payload.connectionId
+      if (state[key]) {
+        state[key].error = error
+        state[key].loading = false
       }
     },
   },
diff --git a/apps/frontend/src/state/valkey-features/config/configSlice.ts b/apps/frontend/src/state/valkey-features/config/configSlice.ts
index 72e5251d..62bf1610 100644
--- a/apps/frontend/src/state/valkey-features/config/configSlice.ts
+++ b/apps/frontend/src/state/valkey-features/config/configSlice.ts
@@ -43,9 +43,13 @@ const configSlice = createSlice({
   initialState,
   reducers: {
     setConfig: (state, action) => {
-      const { connectionId, connectionDetails: { keyEvictionPolicy, clusterSlotStatsEnabled } } = action.payload
-      if (!state[connectionId]) {
-        state[connectionId] = defaultConfig({
+      const { connectionId, connectionDetails: { clusterId, keyEvictionPolicy, clusterSlotStatsEnabled } } = action.payload
+      // `setConfig` seeds local config from connection identity (not a server
+      // reply), so its clusterId lives under connectionDetails. Key by clusterId
+      // for clusters or connectionId for standalone.
+      const key = clusterId ?? connectionId
+      if (!state[key]) {
+        state[key] = defaultConfig({
           keyEvictionPolicy,
           clusterSlotStatsEnabled: clusterSlotStatsEnabled ?? false,
         })
@@ -53,19 +57,20 @@ const configSlice = createSlice({
     },
 
     updateConfig: (state, action) => {
-      const { connectionId } = action.payload
-      if (!state[connectionId]) {
-        state[connectionId] = defaultConfig({ status: "updating" })
+      const key = action.payload.clusterId ?? action.payload.connectionId
+      if (!state[key]) {
+        state[key] = defaultConfig({ status: "updating" })
         return
       }
-      state[connectionId].status = "updating"
-      state[connectionId].errorMessage = null // reset any previous error
+      state[key].status = "updating"
+      state[key].errorMessage = null // reset any previous error
     },
 
     updateConfigFulfilled: (state, action) => {
-      const { connectionId, response } = action.payload
-      if (!state[connectionId]) {
-        state[connectionId] = defaultConfig()
+      const { connectionId, clusterId, response } = action.payload
+      const key = clusterId ?? connectionId
+      if (!state[key]) {
+        state[key] = defaultConfig()
       }
 
       if (response.data?.epic) {
@@ -73,24 +78,25 @@ const configSlice = createSlice({
           Object.keys(defaultConfig().monitoring),
           response.data.epic,
         )
-        state[connectionId].monitoring = {
-          ...state[connectionId].monitoring,
+        state[key].monitoring = {
+          ...state[key].monitoring,
           ...updatedMonitoringConfig,
         }
       }
 
-      state[connectionId].status = "updated"
-      state[connectionId].errorMessage = null
+      state[key].status = "updated"
+      state[key].errorMessage = null
     },
 
     updateConfigFailed: (state, action) => {
-      const { connectionId, response } = action.payload
-      if (!state[connectionId]) {
-        state[connectionId] = defaultConfig({ status: "failed", errorMessage: response.errorMessage })
+      const { response } = action.payload
+      const key = action.payload.clusterId ?? action.payload.connectionId
+      if (!state[key]) {
+        state[key] = defaultConfig({ status: "failed", errorMessage: response.errorMessage })
         return
       }
-      state[connectionId].status = "failed"
-      state[connectionId].errorMessage = response.errorMessage
+      state[key].status = "failed"
+      state[key].errorMessage = response.errorMessage
     },
   },
 })
diff --git a/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.ts b/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.ts
index 3a015d41..caf8d3c3 100644
--- a/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.ts
+++ b/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.ts
@@ -59,10 +59,10 @@ const hotKeysSlice = createSlice({
     },
     hotKeysFulfilled: (state, action) => {
       const { hotKeys, monitorRunning, checkAt, nodeId, lastCollectedAt } = action.payload.parsedResponse
-      const connectionId = action.payload.connectionId
+      const key = action.payload.clusterId ?? action.payload.connectionId
       const nodeErrors = action.payload.nodeErrors ?? []
-      if (!state[connectionId]) {
-        state[connectionId] = {
+      if (!state[key]) {
+        state[key] = {
           hotKeys: [],
           checkAt: null,
           monitorRunning: false,
@@ -70,7 +70,7 @@ const hotKeysSlice = createSlice({
           status: PENDING,
         }
       }
-      state[connectionId] = {
+      state[key] = {
         hotKeys,
         checkAt,
         monitorRunning,
@@ -82,9 +82,10 @@ const hotKeysSlice = createSlice({
       
     },
     hotKeysError: (state, action) => {
-      const { connectionId, error } = action.payload
-      if (!state[connectionId]) {
-        state[connectionId] = {
+      const { error } = action.payload
+      const key = action.payload.clusterId ?? action.payload.connectionId
+      if (!state[key]) {
+        state[key] = {
           hotKeys: [],
           checkAt: null, 
           monitorRunning: false,
@@ -92,8 +93,8 @@ const hotKeysSlice = createSlice({
           status: ERROR,
         }
       }
-      state[connectionId].error = error
-      state[connectionId].status = ERROR
+      state[key].error = error
+      state[key].status = ERROR
     },
   },
 })

From ede6eda22760f218daea10d51ba55f509e8446c1 Mon Sep 17 00:00:00 2001
From: Argus Li <argus@argusli.dev>
Date: Mon, 22 Jun 2026 12:30:41 -0700
Subject: [PATCH 04/10] Add configSlice test

Signed-off-by: Argus Li <argus@argusli.dev>
---
 .../config/configSlice.test.ts                | 110 ++++++++++++++++++
 .../valkey-features/config/configSlice.ts     |   2 +-
 2 files changed, 111 insertions(+), 1 deletion(-)
 create mode 100644 apps/frontend/src/state/valkey-features/config/configSlice.test.ts

diff --git a/apps/frontend/src/state/valkey-features/config/configSlice.test.ts b/apps/frontend/src/state/valkey-features/config/configSlice.test.ts
new file mode 100644
index 00000000..ff5f9d32
--- /dev/null
+++ b/apps/frontend/src/state/valkey-features/config/configSlice.test.ts
@@ -0,0 +1,110 @@
+import { describe, it, expect } from "vitest"
+import configReducer, {
+  setConfig,
+  updateConfig,
+  updateConfigFulfilled,
+  updateConfigFailed,
+  selectConfig,
+} from "./configSlice"
+
+describe("configSlice", () => {
+  const initialState = {}
+
+  describe("setConfig (seed on connect)", () => {
+    it("keys standalone config by connectionId", () => {
+      const state = configReducer(
+        initialState,
+        setConfig({
+          connectionId: "host-6379-db0",
+          connectionDetails: { keyEvictionPolicy: "noeviction", clusterSlotStatsEnabled: false },
+        }),
+      )
+
+      expect(state["host-6379-db0"]).toBeDefined()
+      expect(state["host-6379-db0"].keyEvictionPolicy).toBe("noeviction")
+    })
+
+    it("keys cluster config by clusterId (nested in connectionDetails)", () => {
+      const state = configReducer(
+        initialState,
+        setConfig({
+          connectionId: "node-1-db0",
+          connectionDetails: { clusterId: "cluster-1", keyEvictionPolicy: "allkeys-lfu", clusterSlotStatsEnabled: true },
+        }),
+      )
+
+      // Seeded under clusterId, NOT the db-suffixed connectionId.
+      expect(state["cluster-1"]).toBeDefined()
+      expect(state["node-1-db0"]).toBeUndefined()
+      expect(state["cluster-1"].clusterSlotStatsEnabled).toBe(true)
+    })
+  })
+
+  describe("updateConfigFulfilled (server reply)", () => {
+    it("applies monitoring settings on the cluster entry (keyed by clusterId)", () => {
+      const seeded = configReducer(
+        initialState,
+        setConfig({
+          connectionId: "node-1-db0",
+          connectionDetails: { clusterId: "cluster-1", clusterSlotStatsEnabled: false },
+        }),
+      )
+
+      const state = configReducer(
+        seeded,
+        updateConfigFulfilled({
+          clusterId: "cluster-1",
+          response: { data: { epic: { name: "monitor", monitoringDuration: 5000, monitoringInterval: 7000 } } },
+        }),
+      )
+
+      // Initial seed and post-update land on the SAME cluster-keyed entry.
+      expect(state["cluster-1"].monitoring.monitoringDuration).toBe(5000)
+      expect(state["cluster-1"].monitoring.monitoringInterval).toBe(7000)
+      expect(state["cluster-1"].status).toBe("updated")
+    })
+
+    it("applies standalone monitoring settings keyed by connectionId", () => {
+      const state = configReducer(
+        initialState,
+        updateConfigFulfilled({
+          connectionId: "host-6379-db0",
+          response: { data: { epic: { name: "monitor", monitoringDuration: 1234 } } },
+        }),
+      )
+
+      expect(state["host-6379-db0"].monitoring.monitoringDuration).toBe(1234)
+    })
+  })
+
+  describe("updateConfigFailed", () => {
+    it("sets failed status on the cluster entry", () => {
+      const state = configReducer(
+        initialState,
+        updateConfigFailed({ clusterId: "cluster-1", response: { errorMessage: "bad config" } }),
+      )
+
+      expect(state["cluster-1"].status).toBe("failed")
+      expect(state["cluster-1"].errorMessage).toBe("bad config")
+    })
+  })
+
+  describe("updateConfig (optimistic, dead path aligned for future use)", () => {
+    it("keys by clusterId when present", () => {
+      const state = configReducer(initialState, updateConfig({ clusterId: "cluster-1", connectionId: "node-1-db0" }))
+      expect(state["cluster-1"].status).toBe("updating")
+      expect(state["node-1-db0"]).toBeUndefined()
+    })
+  })
+
+  describe("selectConfig", () => {
+    it("reads the cluster entry via clusterId ?? id", () => {
+      const seeded = configReducer(
+        initialState,
+        setConfig({ connectionId: "node-1-db0", connectionDetails: { clusterId: "cluster-1" } }),
+      )
+      const rootState = { config: seeded } as never
+      expect(selectConfig("cluster-1")(rootState)).toBeDefined()
+    })
+  })
+})
diff --git a/apps/frontend/src/state/valkey-features/config/configSlice.ts b/apps/frontend/src/state/valkey-features/config/configSlice.ts
index 62bf1610..73cd2670 100644
--- a/apps/frontend/src/state/valkey-features/config/configSlice.ts
+++ b/apps/frontend/src/state/valkey-features/config/configSlice.ts
@@ -2,7 +2,7 @@ import { type KeyEvictionPolicy } from "@common/src/constants"
 import { createSlice } from "@reduxjs/toolkit"
 import * as R from "ramda"
 import { VALKEY } from "@common/src/constants"
-import { type RootState } from "@/store"
+import type { RootState } from "@/store"
 
 type UpdateStatus = "updating" | "updated" | "failed"
 export const selectConfig = (id: string) => (state: RootState) =>

From 00d38434c97fa03b66b98fb31b0d2058857ae8c0 Mon Sep 17 00:00:00 2001
From: Argus Li <argus@argusli.dev>
Date: Tue, 23 Jun 2026 13:21:29 -0700
Subject: [PATCH 05/10] Re-key all node level metrics states to nodeId

Signed-off-by: Argus Li <argus@argusli.dev>
---
 .../components/activity-view/ActivityView.tsx |  32 +--
 .../hotkeys/hot-keys-params-modal.tsx         |  11 +-
 .../components/ui/monitor-warning-banner.tsx  |  45 ++--
 .../commandlogs/commandLogsSlice.test.ts      | 110 +++++++++
 .../commandlogs/commandLogsSlice.ts           |  45 ++--
 .../config/configSlice.test.ts                |  97 ++++++--
 .../valkey-features/config/configSlice.ts     |  68 +++---
 .../hotkeys/hotKeysSlice.test.ts              | 111 +++++++++
 .../valkey-features/hotkeys/hotKeysSlice.ts   |  63 +++--
 .../monitor/monitorSlice.test.ts              | 197 ++++++++++++----
 .../valkey-features/monitor/monitorSlice.ts   |  92 ++++++--
 apps/server/src/__tests__/connection.test.ts  |   6 +-
 .../src/__tests__/hotkeys-commandlogs.test.ts | 220 ++++++++++++++++++
 .../__tests__/metrics-orchestrator.test.ts    |  29 ---
 .../src/__tests__/monitorAction.test.ts       | 146 +++++++++++-
 apps/server/src/actions/commandLogs.ts        |  19 +-
 apps/server/src/actions/config.ts             |   9 +-
 apps/server/src/actions/cpuUsage.ts           |   7 +-
 apps/server/src/actions/hotkeys.ts            |  15 +-
 apps/server/src/actions/memoryUsage.ts        |   7 +-
 apps/server/src/actions/monitorAction.ts      |  10 +-
 apps/server/src/actions/stats.ts              |   4 +-
 apps/server/src/connection.ts                 |  17 +-
 apps/server/src/metrics-orchestrator.ts       |  30 +--
 common/package.json                           |   3 +-
 common/src/__tests__/connection-id.test.ts    |  31 +++
 common/src/connection-id.ts                   |  19 ++
 common/src/reply-id.ts                        |  24 +-
 28 files changed, 1123 insertions(+), 344 deletions(-)
 create mode 100644 apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.test.ts
 create mode 100644 apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.test.ts
 create mode 100644 apps/server/src/__tests__/hotkeys-commandlogs.test.ts
 create mode 100644 common/src/__tests__/connection-id.test.ts

diff --git a/apps/frontend/src/components/activity-view/ActivityView.tsx b/apps/frontend/src/components/activity-view/ActivityView.tsx
index 2181ba1a..cc160fab 100644
--- a/apps/frontend/src/components/activity-view/ActivityView.tsx
+++ b/apps/frontend/src/components/activity-view/ActivityView.tsx
@@ -5,6 +5,7 @@ import { useParams } from "react-router"
 import { COMMANDLOG_TYPE } from "@common/src/constants"
 import { truncateText } from "@common/src/truncate-text"
 import { MONITOR_ACTION } from "@common/src/constants"
+import { toNodeId } from "@common/src/connection-id.ts"
 import { AppHeader } from "../ui/app-header"
 import { TabGroup } from "../ui/tab-group"
 import { ButtonGroup } from "../ui/button-group"
@@ -22,7 +23,7 @@ import {
   hotKeysRequested, selectHotKeys, selectHotKeysStatus, selectHotKeysError,
   selectHotKeysNodeErrors, selectHotKeysLastCollectedAt
 } from "@/state/valkey-features/hotkeys/hotKeysSlice"
-import { monitorRequested, selectMonitorRunning } from "@/state/valkey-features/monitor/monitorSlice"
+import { monitorRequested, selectMonitorRunning, selectClusterMonitorRunning } from "@/state/valkey-features/monitor/monitorSlice"
 import { selectConnectionDetails, selectClusterAlias } from "@/state/valkey-features/connection/connectionSelectors"
 import { getKeyTypeRequested } from "@/state/valkey-features/keys/keyBrowserSlice"
 import { selectKeys } from "@/state/valkey-features/keys/keyBrowserSelectors"
@@ -48,18 +49,23 @@ export const ActivityView = () => {
   const [selectedKey, setSelectedKey] = useState<string | null>(null)
   const [configOpen, setConfigOpen] = useState(false)
 
-  const commandLogsId = clusterId ?? id!
-  const commandLogsSlowData = useSelector((state: RootState) => selectCommandLogs(commandLogsId, COMMANDLOG_TYPE.SLOW)(state))
-  const commandLogsLargeRequestData = useSelector((state: RootState) => selectCommandLogs(commandLogsId, COMMANDLOG_TYPE.LARGE_REQUEST)(state))
-  const commandLogsLargeReplyData = useSelector((state: RootState) => selectCommandLogs(commandLogsId, COMMANDLOG_TYPE.LARGE_REPLY)(state))
-  const commandLogsNodeErrors = useSelector((state: RootState) => selectCommandLogsNodeErrors(commandLogsId)(state))
-  const hotKeysId = clusterId ?? id!
-  const hotKeysData = useSelector((state: RootState) => selectHotKeys(hotKeysId)(state))
-  const hotKeysStatus = useSelector((state: RootState) => selectHotKeysStatus(hotKeysId)(state))
-  const hotKeysErrorMessage = useSelector((state: RootState) => selectHotKeysError(hotKeysId)(state))
-  const hotKeysNodeErrors = useSelector((state: RootState) => selectHotKeysNodeErrors(hotKeysId)(state))
-  const hotKeysLastCollectedAt = useSelector((state: RootState) => selectHotKeysLastCollectedAt(hotKeysId)(state))
-  const monitorRunning = useSelector(selectMonitorRunning(id!))
+  // `targetId` keys node-level metrics state: `clusterId` for a cluster, else
+  // the db-less `nodeId`. (Connection-scoped state below still uses `id`, the
+  // db-suffixed connectionId.)
+  const nodeId = toNodeId(id!)
+  const targetId = clusterId ?? nodeId
+  const commandLogsSlowData = useSelector((state: RootState) => selectCommandLogs(targetId, COMMANDLOG_TYPE.SLOW)(state))
+  const commandLogsLargeRequestData = useSelector((state: RootState) => selectCommandLogs(targetId, COMMANDLOG_TYPE.LARGE_REQUEST)(state))
+  const commandLogsLargeReplyData = useSelector((state: RootState) => selectCommandLogs(targetId, COMMANDLOG_TYPE.LARGE_REPLY)(state))
+  const commandLogsNodeErrors = useSelector((state: RootState) => selectCommandLogsNodeErrors(targetId)(state))
+  const hotKeysData = useSelector((state: RootState) => selectHotKeys(targetId)(state))
+  const hotKeysStatus = useSelector((state: RootState) => selectHotKeysStatus(targetId)(state))
+  const hotKeysErrorMessage = useSelector((state: RootState) => selectHotKeysError(targetId)(state))
+  const hotKeysNodeErrors = useSelector((state: RootState) => selectHotKeysNodeErrors(targetId)(state))
+  const hotKeysLastCollectedAt = useSelector((state: RootState) => selectHotKeysLastCollectedAt(targetId)(state))
+  const monitorRunning = useSelector((state: RootState) =>
+    clusterId ? selectClusterMonitorRunning(clusterId)(state) : selectMonitorRunning(nodeId)(state),
+  )
   const connectionDetails = useSelector((state: RootState) => selectConnectionDetails(id!)(state))
   const clusterAlias = useSelector(selectClusterAlias(id!))
   const useHotSlots = connectionDetails?.keyEvictionPolicy?.includes("lfu") && connectionDetails?.clusterSlotStatsEnabled
diff --git a/apps/frontend/src/components/activity-view/hotkeys/hot-keys-params-modal.tsx b/apps/frontend/src/components/activity-view/hotkeys/hot-keys-params-modal.tsx
index a6b3066a..32e9ac3d 100644
--- a/apps/frontend/src/components/activity-view/hotkeys/hot-keys-params-modal.tsx
+++ b/apps/frontend/src/components/activity-view/hotkeys/hot-keys-params-modal.tsx
@@ -4,6 +4,7 @@ import { useParams } from "react-router"
 import { AlertTriangle } from "lucide-react"
 import { TooltipProvider } from "@radix-ui/react-tooltip"
 import { MONITOR_ACTION } from "@common/src/constants"
+import { toNodeId } from "@common/src/connection-id.ts"
 import { ChartModal } from "../../ui/chart-modal"
 import { Button } from "../../ui/button"
 import { Input } from "../../ui/input"
@@ -11,7 +12,8 @@ import { Typography } from "../../ui/typography"
 import { TooltipIcon } from "../../ui/tooltip-icon"
 import { useAppDispatch } from "@/hooks/hooks"
 import { selectConfig } from "@/state/valkey-features/config/configSlice"
-import { saveMonitorSettingsRequested, selectMonitorRunning } from "@/state/valkey-features/monitor/monitorSlice"
+import { saveMonitorSettingsRequested, selectMonitorRunning, selectClusterMonitorRunning } from "@/state/valkey-features/monitor/monitorSlice"
+import type { RootState } from "@/store"
 
 interface HotKeysConfigModalProps {
   open: boolean
@@ -21,8 +23,11 @@ interface HotKeysConfigModalProps {
 export function HotKeysParamsModal({ open, onClose }: HotKeysConfigModalProps) {
   const { id, clusterId } = useParams()
   const dispatch = useAppDispatch()
-  const config = useSelector(selectConfig(id!))
-  const monitorRunning = useSelector(selectMonitorRunning(id!))
+  // Config and monitor state are cluster-keyed for clusters, node-keyed otherwise.
+  const config = useSelector(selectConfig(clusterId ?? toNodeId(id!)))
+  const monitorRunning = useSelector((state: RootState) =>
+    clusterId ? selectClusterMonitorRunning(clusterId)(state) : selectMonitorRunning(toNodeId(id!))(state),
+  )
 
   const [monitorDuration, setMonitorDuration] = useState(config?.monitoring?.monitoringDuration ?? 10000)
   const [monitorInterval, setMonitorInterval] = useState(config?.monitoring?.monitoringInterval ?? 10000)
diff --git a/apps/frontend/src/components/ui/monitor-warning-banner.tsx b/apps/frontend/src/components/ui/monitor-warning-banner.tsx
index 4af233a3..e61b56a6 100644
--- a/apps/frontend/src/components/ui/monitor-warning-banner.tsx
+++ b/apps/frontend/src/components/ui/monitor-warning-banner.tsx
@@ -8,7 +8,6 @@ import { Button } from "./button"
 import { Typography } from "./typography"
 import { useAppDispatch } from "@/hooks/hooks"
 import { monitorRequested, selectRunningMonitorConnections } from "@/state/valkey-features/monitor/monitorSlice"
-import { selectAllClusters } from "@/state/valkey-features/cluster/clusterSelectors"
 
 interface MonitoringConfig {
   monitoringDuration: number
@@ -18,7 +17,6 @@ interface MonitoringConfig {
 export function MonitorWarningBanner() {
   const dispatch = useAppDispatch()
   const runningConnections = useSelector(selectRunningMonitorConnections)
-  const clusters = useSelector(selectAllClusters)
   const configState = useSelector((state: unknown) =>
     R.path<Record<string, { monitoring?: MonitoringConfig }>>([VALKEY.CONFIG.name], state) ?? {},
   )
@@ -32,28 +30,27 @@ export function MonitorWarningBanner() {
   }, [runningConnections.length])
 
   const { clusterGroups, standaloneConnections } = useMemo(() => {
-    const groups: Record<string, { connectionId: string; startedAt: number | null }[]> = {}
-    const standalone: { connectionId: string; startedAt: number | null }[] = []
+    const groups: Record<string, { nodeId: string; startedAt: number | null }[]> = {}
+    const standalone: { nodeId: string; startedAt: number | null }[] = []
 
-    for (const [clusterId, cluster] of Object.entries(clusters)) {
-      const clusterNodeIds = new Set(Object.keys(cluster.clusterNodes ?? {}))
-      const matching = runningConnections.filter((c) => clusterNodeIds.has(c.connectionId))
-      if (matching.length > 0) groups[clusterId] = matching
-    }
-
-    const grouped = new Set(Object.values(groups).flat().map((c) => c.connectionId))
+    // Monitor entries are grouped by clusterId on the cluster path.
+    // Standalone entries have no clusterId.
     for (const conn of runningConnections) {
-      if (!grouped.has(conn.connectionId)) standalone.push(conn)
+      if (conn.clusterId) {
+        (groups[conn.clusterId] ??= []).push(conn)
+      } else {
+        standalone.push(conn)
+      }
     }
 
     return { clusterGroups: groups, standaloneConnections: standalone }
-  }, [runningConnections, clusters])
+  }, [runningConnections])
 
   if (runningConnections.length === 0) return null
 
-  const handleStop = (connectionId: string, cId?: string) => {
+  const handleStop = (nodeId: string, cId?: string) => {
     dispatch(monitorRequested({
-      connectionId,
+      connectionId: nodeId,
       clusterId: cId,
       monitorAction: MONITOR_ACTION.STOP,
     }))
@@ -91,7 +88,7 @@ export function MonitorWarningBanner() {
                 <div className="flex items-center justify-between gap-2">
                   <span className="font-mono text-xs truncate flex-1">{cId}</span>
                   <Button
-                    onClick={() => handleStop(nodes[0].connectionId, cId)}
+                    onClick={() => handleStop(nodes[0].nodeId, cId)}
                     size={"sm"}
                     variant={"destructive"}
                   >
@@ -104,20 +101,20 @@ export function MonitorWarningBanner() {
                   </span>
                 )}
                 <span className="text-xs text-gray-400 flex items-center">
-                  Duration: {milliSecondsToSeconds(configState[nodes[0].connectionId]?.monitoring?.monitoringDuration ?? 10000)} <Dot />
-                  Interval: {milliSecondsToSeconds(configState[nodes[0].connectionId]?.monitoring?.monitoringInterval ?? 10000)} <Dot />
+                  Duration: {milliSecondsToSeconds(configState[cId]?.monitoring?.monitoringDuration ?? 10000)} <Dot />
+                  Interval: {milliSecondsToSeconds(configState[cId]?.monitoring?.monitoringInterval ?? 10000)} <Dot />
                   Nodes: {nodes.length}
                 </span>
               </div>
             ))}
 
             {/* Standalone — with its own button */}
-            {standaloneConnections.map(({ connectionId, startedAt }) => (
-              <div className="border-b p-2 flex flex-col last:border-b-0" key={connectionId}>
+            {standaloneConnections.map(({ nodeId, startedAt }) => (
+              <div className="border-b p-2 flex flex-col last:border-b-0" key={nodeId}>
                 <div className="flex items-center justify-between gap-2">
-                  <span className="font-mono text-xs truncate flex-1">{connectionId}</span>
+                  <span className="font-mono text-xs truncate flex-1">{nodeId}</span>
                   <Button
-                    onClick={() => handleStop(connectionId)}
+                    onClick={() => handleStop(nodeId)}
                     size={"sm"}
                     variant={"destructive"}
                   >
@@ -130,8 +127,8 @@ export function MonitorWarningBanner() {
                   </span>
                 )}
                 <span className="text-xs text-gray-400 flex items-center">
-                  Duration: {milliSecondsToSeconds(configState[connectionId]?.monitoring?.monitoringDuration ?? 10000)} <Dot />
-                  Interval: {milliSecondsToSeconds(configState[connectionId]?.monitoring?.monitoringInterval ?? 10000)}
+                  Duration: {milliSecondsToSeconds(configState[nodeId]?.monitoring?.monitoringDuration ?? 10000)} <Dot />
+                  Interval: {milliSecondsToSeconds(configState[nodeId]?.monitoring?.monitoringInterval ?? 10000)}
                 </span>
               </div>
             ))}
diff --git a/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.test.ts b/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.test.ts
new file mode 100644
index 00000000..87b395ab
--- /dev/null
+++ b/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.test.ts
@@ -0,0 +1,110 @@
+import { describe, it, expect } from "vitest"
+import { COMMANDLOG_TYPE } from "@common/src/constants.ts"
+import commandLogsReducer, {
+  commandLogsRequested,
+  commandLogsFulfilled,
+  commandLogsError,
+} from "./commandLogsSlice"
+
+describe("commandLogsSlice", () => {
+  const initialState = {}
+
+  describe("commandLogsRequested", () => {
+    it("keys the standalone pending entry by the db-less nodeId", () => {
+      const state = commandLogsReducer(
+        initialState,
+        commandLogsRequested({ connectionId: "host-6379-db0" }),
+      )
+
+      expect(state["host-6379"]).toBeDefined()
+      expect(state["host-6379-db0"]).toBeUndefined()
+      expect(state["host-6379"].loading).toBe(true)
+    })
+
+    it("collapses two connections to the same node on different dbs into one entry", () => {
+      const afterDb0 = commandLogsReducer(
+        initialState,
+        commandLogsRequested({ connectionId: "host-6379-db0" }),
+      )
+      const afterDb1 = commandLogsReducer(
+        afterDb0,
+        commandLogsRequested({ connectionId: "host-6379-db1" }),
+      )
+
+      expect(Object.keys(afterDb1)).toEqual(["host-6379"])
+    })
+
+    it("keys the cluster pending entry by clusterId", () => {
+      const state = commandLogsReducer(
+        initialState,
+        commandLogsRequested({ connectionId: "node-1-db0", clusterId: "cluster-1" }),
+      )
+
+      expect(state["cluster-1"]).toBeDefined()
+      expect(state["node-1-db0"]).toBeUndefined()
+    })
+  })
+
+  describe("commandLogsFulfilled", () => {
+    it("keys a standalone reply by nodeId", () => {
+      const rows = [{ ts: 1, metric: "slow", values: [] }]
+      const state = commandLogsReducer(
+        initialState,
+        commandLogsFulfilled({
+          nodeId: "host-6379",
+          commandLogType: COMMANDLOG_TYPE.SLOW,
+          parsedResponse: { rows, count: 10 },
+        }),
+      )
+
+      expect(state["host-6379"]).toBeDefined()
+      expect(state["host-6379"].logs[COMMANDLOG_TYPE.SLOW]).toEqual(rows)
+      expect(state["host-6379"].count).toBe(10)
+      expect(state["host-6379"].loading).toBe(false)
+    })
+
+    it("keys a cluster reply by clusterId and keeps nodeErrors db-less", () => {
+      const state = commandLogsReducer(
+        initialState,
+        commandLogsFulfilled({
+          clusterId: "cluster-1",
+          commandLogType: COMMANDLOG_TYPE.SLOW,
+          parsedResponse: { rows: [], count: 0 },
+          nodeErrors: [{ nodeId: "node-1", error: "down" }],
+        }),
+      )
+
+      expect(state["cluster-1"]).toBeDefined()
+      expect(state["cluster-1"].nodeErrors).toEqual([{ nodeId: "node-1", error: "down" }])
+    })
+  })
+
+  describe("commandLogsError", () => {
+    it("keys a standalone error by nodeId", () => {
+      const seeded = commandLogsReducer(
+        initialState,
+        commandLogsRequested({ connectionId: "host-6379-db0" }),
+      )
+      const state = commandLogsReducer(
+        seeded,
+        commandLogsError({ nodeId: "host-6379", error: { message: "boom" } }),
+      )
+
+      expect(state["host-6379"].error).toEqual({ message: "boom" })
+      expect(state["host-6379"].loading).toBe(false)
+    })
+
+    it("keys a cluster error by clusterId", () => {
+      const seeded = commandLogsReducer(
+        initialState,
+        commandLogsRequested({ connectionId: "node-1-db0", clusterId: "cluster-1" }),
+      )
+      const state = commandLogsReducer(
+        seeded,
+        commandLogsError({ clusterId: "cluster-1", error: { message: "boom" } }),
+      )
+
+      expect(state["cluster-1"].error).toEqual({ message: "boom" })
+    })
+  })
+})
diff --git a/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.ts b/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.ts
index f0bd64e5..2cd21ffe 100644
--- a/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.ts
+++ b/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.ts
@@ -1,21 +1,24 @@
 import { createSlice } from "@reduxjs/toolkit"
 import { type JSONObject } from "@common/src/json-utils"
 import { VALKEY } from "@common/src/constants.ts"
+import { toNodeId } from "@common/src/connection-id.ts"
 import * as R from "ramda"
 import { COMMANDLOG_TYPE } from "@common/src/constants.ts"
 import type { RootState } from "@/store.ts"
 
 type CommandLogType = typeof COMMANDLOG_TYPE.SLOW | typeof COMMANDLOG_TYPE.LARGE_REQUEST | typeof COMMANDLOG_TYPE.LARGE_REPLY
 
+// `targetId` is the state key: `clusterId` for a cluster aggregate or the
+// db-less `nodeId` for a standalone node.
 export const selectCommandLogs =
-  (connectionId: string, type: CommandLogType) =>
+  (targetId: string, type: CommandLogType) =>
     (state: RootState) =>
-      R.path([VALKEY.COMMANDLOGS.name, connectionId, "logs", type], state)
+      R.path([VALKEY.COMMANDLOGS.name, targetId, "logs", type], state)
 
 export const selectCommandLogsNodeErrors =
-  (connectionId: string) =>
+  (targetId: string) =>
     (state: RootState) =>
-      R.path([VALKEY.COMMANDLOGS.name, connectionId, "nodeErrors"], state) ?? []
+      R.path([VALKEY.COMMANDLOGS.name, targetId, "nodeErrors"], state) ?? []
 
 interface CommandLogSlowEntry {
   id: string
@@ -42,7 +45,8 @@ interface CommandLogEntry {
 }
 
 interface CommandLogState {
-  [connectionId: string]: {
+  // Keyed by `targetId`: `clusterId` (cluster) or `nodeId` (standalone).
+  [targetId: string]: {
     logs: {
       slow: Array<{
         ts: number
@@ -67,9 +71,10 @@ const commandLogsSlice = createSlice({
   reducers: {
     commandLogsRequested: (state, action) => {
       const { connectionId, clusterId } = action.payload
-      const id = clusterId ?? connectionId
-      if (!state[id]) {
-        state[id] = {
+      // Standalone command logs state is node-level.
+      const targetId = clusterId ?? toNodeId(connectionId)
+      if (!state[targetId]) {
+        state[targetId] = {
           logs: {
             slow: [],
             [COMMANDLOG_TYPE.LARGE_REQUEST]: [],
@@ -79,15 +84,15 @@ const commandLogsSlice = createSlice({
           loading: false,
         }
       }
-      state[id].loading = true
+      state[targetId].loading = true
     },
     commandLogsFulfilled: (state, action) => {
       const { parsedResponse, nodeErrors } = action.payload
-      const key = action.payload.clusterId ?? action.payload.connectionId
+      const targetId = action.payload.clusterId ?? action.payload.nodeId
       const commandLogType: CommandLogType = action.payload.commandLogType
       const { rows, count } = parsedResponse
-      if (!state[key]) {
-        state[key] = {
+      if (!state[targetId]) {
+        state[targetId] = {
           logs: {
             slow: [],
             [COMMANDLOG_TYPE.LARGE_REQUEST]: [],
@@ -97,17 +102,17 @@ const commandLogsSlice = createSlice({
           loading: false,
         }
       }
-      state[key].logs[commandLogType] = rows
-      state[key].count = count
-      state[key].loading = false
-      state[key].nodeErrors = nodeErrors ?? []
+      state[targetId].logs[commandLogType] = rows
+      state[targetId].count = count
+      state[targetId].loading = false
+      state[targetId].nodeErrors = nodeErrors ?? []
     },
     commandLogsError: (state, action) => {
       const { error } = action.payload
-      const key = action.payload.clusterId ?? action.payload.connectionId
-      if (state[key]) {
-        state[key].error = error
-        state[key].loading = false
+      const targetId = action.payload.clusterId ?? action.payload.nodeId
+      if (state[targetId]) {
+        state[targetId].error = error
+        state[targetId].loading = false
       }
     },
   },
diff --git a/apps/frontend/src/state/valkey-features/config/configSlice.test.ts b/apps/frontend/src/state/valkey-features/config/configSlice.test.ts
index ff5f9d32..01834e11 100644
--- a/apps/frontend/src/state/valkey-features/config/configSlice.test.ts
+++ b/apps/frontend/src/state/valkey-features/config/configSlice.test.ts
@@ -11,17 +11,31 @@ describe("configSlice", () => {
   const initialState = {}
 
   describe("setConfig (seed on connect)", () => {
-    it("keys standalone config by connectionId", () => {
+    it("keys standalone config by the db-less nodeId", () => {
       const state = configReducer(
         initialState,
         setConfig({
           connectionId: "host-6379-db0",
-          connectionDetails: { keyEvictionPolicy: "noeviction", clusterSlotStatsEnabled: false },
+          connectionDetails: {},
         }),
       )
 
-      expect(state["host-6379-db0"]).toBeDefined()
-      expect(state["host-6379-db0"].keyEvictionPolicy).toBe("noeviction")
+      // Seeded under the db-less nodeId, not the db-suffixed connectionId.
+      expect(state["host-6379"]).toBeDefined()
+      expect(state["host-6379-db0"]).toBeUndefined()
+    })
+
+    it("collapses two connections to the same node on different dbs into one entry", () => {
+      const afterDb0 = configReducer(
+        initialState,
+        setConfig({ connectionId: "host-6379-db0", connectionDetails: {} }),
+      )
+      const afterDb1 = configReducer(
+        afterDb0,
+        setConfig({ connectionId: "host-6379-db1", connectionDetails: {} }),
+      )
+
+      expect(Object.keys(afterDb1)).toEqual(["host-6379"])
     })
 
     it("keys cluster config by clusterId (nested in connectionDetails)", () => {
@@ -29,14 +43,45 @@ describe("configSlice", () => {
         initialState,
         setConfig({
           connectionId: "node-1-db0",
-          connectionDetails: { clusterId: "cluster-1", keyEvictionPolicy: "allkeys-lfu", clusterSlotStatsEnabled: true },
+          connectionDetails: { clusterId: "cluster-1" },
         }),
       )
 
       // Seeded under clusterId, NOT the db-suffixed connectionId.
       expect(state["cluster-1"]).toBeDefined()
       expect(state["node-1-db0"]).toBeUndefined()
-      expect(state["cluster-1"].clusterSlotStatsEnabled).toBe(true)
+    })
+
+    it("seeds only monitoring/status/errorMessage (no dead fields)", () => {
+      const state = configReducer(
+        initialState,
+        setConfig({ connectionId: "host-6379-db0", connectionDetails: {} }),
+      )
+
+      const entry = state["host-6379"]
+      // ConfigEntry shape is exactly monitoring/status/errorMessage.
+      expect(Object.keys(entry).sort()).toEqual(["errorMessage", "monitoring", "status"])
+      expect(Object.keys(entry.monitoring).sort()).toEqual(
+        ["cutoffFrequency", "maxCommandsPerRun", "monitoringDuration", "monitoringInterval"],
+      )
+      // Removed dead fields are not present.
+      expect(entry).not.toHaveProperty("darkMode")
+      expect(entry).not.toHaveProperty("keyEvictionPolicy")
+      expect(entry).not.toHaveProperty("clusterSlotStatsEnabled")
+    })
+
+    it("does not copy connection details into config state", () => {
+      const state = configReducer(
+        initialState,
+        setConfig({
+          connectionId: "host-6379-db0",
+          connectionDetails: { keyEvictionPolicy: "allkeys-lfu", clusterSlotStatsEnabled: true },
+        }),
+      )
+
+      const entry = state["host-6379"]
+      expect(entry).not.toHaveProperty("keyEvictionPolicy")
+      expect(entry).not.toHaveProperty("clusterSlotStatsEnabled")
     })
   })
 
@@ -46,7 +91,7 @@ describe("configSlice", () => {
         initialState,
         setConfig({
           connectionId: "node-1-db0",
-          connectionDetails: { clusterId: "cluster-1", clusterSlotStatsEnabled: false },
+          connectionDetails: { clusterId: "cluster-1" },
         }),
       )
 
@@ -64,16 +109,16 @@ describe("configSlice", () => {
       expect(state["cluster-1"].status).toBe("updated")
     })
 
-    it("applies standalone monitoring settings keyed by connectionId", () => {
+    it("applies standalone monitoring settings keyed by nodeId", () => {
       const state = configReducer(
         initialState,
         updateConfigFulfilled({
-          connectionId: "host-6379-db0",
+          nodeId: "host-6379",
           response: { data: { epic: { name: "monitor", monitoringDuration: 1234 } } },
         }),
       )
 
-      expect(state["host-6379-db0"].monitoring.monitoringDuration).toBe(1234)
+      expect(state["host-6379"].monitoring.monitoringDuration).toBe(1234)
     })
   })
 
@@ -87,18 +132,33 @@ describe("configSlice", () => {
       expect(state["cluster-1"].status).toBe("failed")
       expect(state["cluster-1"].errorMessage).toBe("bad config")
     })
+
+    it("sets failed status on the standalone entry keyed by nodeId", () => {
+      const state = configReducer(
+        initialState,
+        updateConfigFailed({ nodeId: "host-6379", response: { errorMessage: "nope" } }),
+      )
+
+      expect(state["host-6379"].status).toBe("failed")
+      expect(state["host-6379"].errorMessage).toBe("nope")
+    })
   })
 
-  describe("updateConfig (optimistic, dead path aligned for future use)", () => {
+  describe("updateConfig (optimistic)", () => {
     it("keys by clusterId when present", () => {
-      const state = configReducer(initialState, updateConfig({ clusterId: "cluster-1", connectionId: "node-1-db0" }))
+      const state = configReducer(initialState, updateConfig({ clusterId: "cluster-1", nodeId: "node-1" }))
       expect(state["cluster-1"].status).toBe("updating")
-      expect(state["node-1-db0"]).toBeUndefined()
+      expect(state["node-1"]).toBeUndefined()
+    })
+
+    it("keys by nodeId when no clusterId", () => {
+      const state = configReducer(initialState, updateConfig({ nodeId: "host-6379" }))
+      expect(state["host-6379"].status).toBe("updating")
     })
   })
 
   describe("selectConfig", () => {
-    it("reads the cluster entry via clusterId ?? id", () => {
+    it("reads the cluster entry via clusterId", () => {
       const seeded = configReducer(
         initialState,
         setConfig({ connectionId: "node-1-db0", connectionDetails: { clusterId: "cluster-1" } }),
@@ -106,5 +166,14 @@ describe("configSlice", () => {
       const rootState = { config: seeded } as never
       expect(selectConfig("cluster-1")(rootState)).toBeDefined()
     })
+
+    it("reads the standalone entry via nodeId", () => {
+      const seeded = configReducer(
+        initialState,
+        setConfig({ connectionId: "host-6379-db0", connectionDetails: {} }),
+      )
+      const rootState = { config: seeded } as never
+      expect(selectConfig("host-6379")(rootState)).toBeDefined()
+    })
   })
 })
diff --git a/apps/frontend/src/state/valkey-features/config/configSlice.ts b/apps/frontend/src/state/valkey-features/config/configSlice.ts
index 73cd2670..30b0b85d 100644
--- a/apps/frontend/src/state/valkey-features/config/configSlice.ts
+++ b/apps/frontend/src/state/valkey-features/config/configSlice.ts
@@ -1,12 +1,14 @@
-import { type KeyEvictionPolicy } from "@common/src/constants"
 import { createSlice } from "@reduxjs/toolkit"
 import * as R from "ramda"
 import { VALKEY } from "@common/src/constants"
+import { toNodeId } from "@common/src/connection-id.ts"
 import type { RootState } from "@/store"
 
 type UpdateStatus = "updating" | "updated" | "failed"
-export const selectConfig = (id: string) => (state: RootState) =>
-  R.path([VALKEY.CONFIG.name, id], state)
+// `targetId` is the state key: `clusterId` for a cluster or the db-less
+// `nodeId` for a standalone node.
+export const selectConfig = (targetId: string) => (state: RootState) =>
+  R.path([VALKEY.CONFIG.name, targetId], state)
 
 interface MonitorConfig {
   // How long to monitor before stopping (ms)
@@ -19,11 +21,9 @@ interface MonitorConfig {
   cutoffFrequency: number,
 }
 interface ConfigState {
-  [connectionId: string]: {
-    darkMode: boolean,
-    // Valkey related. TODO: find best way to expose to user
-    keyEvictionPolicy?: KeyEvictionPolicy
-    clusterSlotStatsEnabled?: boolean,
+  // Node-level metrics config keyed by `targetId`: `clusterId` (cluster) or the
+  // db-less `nodeId` (standalone).
+  [targetId: string]: {
     monitoring: MonitorConfig
     status: UpdateStatus
     errorMessage?: string | null
@@ -31,7 +31,6 @@ interface ConfigState {
 }
 const initialState: ConfigState = {}
 const defaultConfig = (partial?: Partial<ConfigState[string]>): ConfigState[string] => ({
-  darkMode: false,
   monitoring: { monitoringDuration: 10000, monitoringInterval: 10000, maxCommandsPerRun: 1000000, cutoffFrequency: 100 },
   status: "updated",
   errorMessage: null,
@@ -43,34 +42,31 @@ const configSlice = createSlice({
   initialState,
   reducers: {
     setConfig: (state, action) => {
-      const { connectionId, connectionDetails: { clusterId, keyEvictionPolicy, clusterSlotStatsEnabled } } = action.payload
+      const { connectionId, connectionDetails: { clusterId } } = action.payload
       // `setConfig` seeds local config from connection identity (not a server
-      // reply), so its clusterId lives under connectionDetails. Key by clusterId
-      // for clusters or connectionId for standalone.
-      const key = clusterId ?? connectionId
-      if (!state[key]) {
-        state[key] = defaultConfig({
-          keyEvictionPolicy,
-          clusterSlotStatsEnabled: clusterSlotStatsEnabled ?? false,
-        })
+      // reply). Config is node-level, so key by clusterId for clusters or
+      // nodeId for standalone.
+      const targetId = clusterId ?? toNodeId(connectionId)
+      if (!state[targetId]) {
+        state[targetId] = defaultConfig()
       }
     },
 
     updateConfig: (state, action) => {
-      const key = action.payload.clusterId ?? action.payload.connectionId
-      if (!state[key]) {
-        state[key] = defaultConfig({ status: "updating" })
+      const targetId = action.payload.clusterId ?? action.payload.nodeId
+      if (!state[targetId]) {
+        state[targetId] = defaultConfig({ status: "updating" })
         return
       }
-      state[key].status = "updating"
-      state[key].errorMessage = null // reset any previous error
+      state[targetId].status = "updating"
+      state[targetId].errorMessage = null // reset any previous error
     },
 
     updateConfigFulfilled: (state, action) => {
-      const { connectionId, clusterId, response } = action.payload
-      const key = clusterId ?? connectionId
-      if (!state[key]) {
-        state[key] = defaultConfig()
+      const { nodeId, clusterId, response } = action.payload
+      const targetId = clusterId ?? nodeId
+      if (!state[targetId]) {
+        state[targetId] = defaultConfig()
       }
 
       if (response.data?.epic) {
@@ -78,25 +74,25 @@ const configSlice = createSlice({
           Object.keys(defaultConfig().monitoring),
           response.data.epic,
         )
-        state[key].monitoring = {
-          ...state[key].monitoring,
+        state[targetId].monitoring = {
+          ...state[targetId].monitoring,
           ...updatedMonitoringConfig,
         }
       }
 
-      state[key].status = "updated"
-      state[key].errorMessage = null
+      state[targetId].status = "updated"
+      state[targetId].errorMessage = null
     },
 
     updateConfigFailed: (state, action) => {
       const { response } = action.payload
-      const key = action.payload.clusterId ?? action.payload.connectionId
-      if (!state[key]) {
-        state[key] = defaultConfig({ status: "failed", errorMessage: response.errorMessage })
+      const targetId = action.payload.clusterId ?? action.payload.nodeId
+      if (!state[targetId]) {
+        state[targetId] = defaultConfig({ status: "failed", errorMessage: response.errorMessage })
         return
       }
-      state[key].status = "failed"
-      state[key].errorMessage = response.errorMessage
+      state[targetId].status = "failed"
+      state[targetId].errorMessage = response.errorMessage
     },
   },
 })
diff --git a/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.test.ts b/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.test.ts
new file mode 100644
index 00000000..2f79922f
--- /dev/null
+++ b/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.test.ts
@@ -0,0 +1,111 @@
+import { describe, it, expect } from "vitest"
+import { PENDING, FULFILLED, ERROR } from "@common/src/constants.ts"
+import hotKeysReducer, {
+  hotKeysRequested,
+  hotKeysFulfilled,
+  hotKeysError,
+} from "./hotKeysSlice"
+
+describe("hotKeysSlice", () => {
+  const initialState = {}
+
+  describe("hotKeysRequested", () => {
+    it("keys the standalone pending entry by the db-less nodeId", () => {
+      const state = hotKeysReducer(
+        initialState,
+        hotKeysRequested({ connectionId: "host-6379-db0" }),
+      )
+
+      expect(state["host-6379"]).toBeDefined()
+      expect(state["host-6379-db0"]).toBeUndefined()
+      expect(state["host-6379"].status).toBe(PENDING)
+    })
+
+    it("collapses two connections to the same node on different dbs into one entry", () => {
+      const afterDb0 = hotKeysReducer(
+        initialState,
+        hotKeysRequested({ connectionId: "host-6379-db0" }),
+      )
+      const afterDb1 = hotKeysReducer(
+        afterDb0,
+        hotKeysRequested({ connectionId: "host-6379-db1" }),
+      )
+
+      expect(Object.keys(afterDb1)).toEqual(["host-6379"])
+    })
+
+    it("keys the cluster pending entry by clusterId", () => {
+      const state = hotKeysReducer(
+        initialState,
+        hotKeysRequested({ connectionId: "node-1-db0", clusterId: "cluster-1" }),
+      )
+
+      expect(state["cluster-1"]).toBeDefined()
+      expect(state["node-1-db0"]).toBeUndefined()
+    })
+  })
+
+  describe("hotKeysFulfilled", () => {
+    it("keys a standalone reply by nodeId", () => {
+      const state = hotKeysReducer(
+        initialState,
+        hotKeysFulfilled({
+          nodeId: "host-6379",
+          parsedResponse: {
+            hotKeys: [["k", 1, null, 2]],
+            monitorRunning: true,
+            checkAt: "now",
+            nodeId: "host-6379",
+            lastCollectedAt: 100,
+          },
+        }),
+      )
+
+      expect(state["host-6379"]).toBeDefined()
+      expect(state["host-6379"].status).toBe(FULFILLED)
+      expect(state["host-6379"].monitorRunning).toBe(true)
+    })
+
+    it("keys a cluster reply by clusterId and keeps nodeErrors db-less", () => {
+      const state = hotKeysReducer(
+        initialState,
+        hotKeysFulfilled({
+          clusterId: "cluster-1",
+          parsedResponse: {
+            hotKeys: [],
+            monitorRunning: false,
+            checkAt: null,
+            nodeId: null,
+            lastCollectedAt: null,
+          },
+          nodeErrors: [{ nodeId: "node-1", error: "down" }],
+        }),
+      )
+
+      expect(state["cluster-1"]).toBeDefined()
+      expect(state["cluster-1"].nodeErrors).toEqual([{ nodeId: "node-1", error: "down" }])
+    })
+  })
+
+  describe("hotKeysError", () => {
+    it("keys a standalone error by nodeId", () => {
+      const state = hotKeysReducer(
+        initialState,
+        hotKeysError({ nodeId: "host-6379", error: { message: "boom" } }),
+      )
+
+      expect(state["host-6379"]).toBeDefined()
+      expect(state["host-6379"].status).toBe(ERROR)
+      expect(state["host-6379"].error).toEqual({ message: "boom" })
+    })
+
+    it("keys a cluster error by clusterId", () => {
+      const state = hotKeysReducer(
+        initialState,
+        hotKeysError({ clusterId: "cluster-1", error: { message: "boom" } }),
+      )
+
+      expect(state["cluster-1"].status).toBe(ERROR)
+    })
+  })
+})
diff --git a/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.ts b/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.ts
index caf8d3c3..f0a729e2 100644
--- a/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.ts
+++ b/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.ts
@@ -1,28 +1,32 @@
 import { createSlice } from "@reduxjs/toolkit"
 import { type JSONObject } from "@common/src/json-utils"
 import { ERROR, FULFILLED, PENDING, VALKEY } from "@common/src/constants.ts"
+import { toNodeId } from "@common/src/connection-id.ts"
 import * as R from "ramda"
 import type { RootState } from "@/store.ts"
 
 type HotKeysStatus = typeof PENDING | typeof FULFILLED | typeof ERROR
 
-export const selectHotKeys = (id: string) => (state: RootState) =>
-  R.path([VALKEY.HOTKEYS.name, id, "hotKeys"], state)
+// `targetId` is the state key: `clusterId` for a cluster aggregate or the
+// db-less `nodeId` for a standalone node.
+export const selectHotKeys = (targetId: string) => (state: RootState) =>
+  R.path([VALKEY.HOTKEYS.name, targetId, "hotKeys"], state)
 
-export const selectHotKeysStatus = (id: string) => (state: RootState) =>
-  R.path([VALKEY.HOTKEYS.name, id, "status"], state)
+export const selectHotKeysStatus = (targetId: string) => (state: RootState) =>
+  R.path([VALKEY.HOTKEYS.name, targetId, "status"], state)
 
-export const selectHotKeysError = (id: string) => (state: RootState) =>
-  R.path([VALKEY.HOTKEYS.name, id, "error"], state)
+export const selectHotKeysError = (targetId: string) => (state: RootState) =>
+  R.path([VALKEY.HOTKEYS.name, targetId, "error"], state)
 
-export const selectHotKeysNodeErrors = (id: string) => (state: RootState) =>
-  R.path([VALKEY.HOTKEYS.name, id, "nodeErrors"], state) ?? []
+export const selectHotKeysNodeErrors = (targetId: string) => (state: RootState) =>
+  R.path([VALKEY.HOTKEYS.name, targetId, "nodeErrors"], state) ?? []
 
-export const selectHotKeysLastCollectedAt = (id: string) => (state: RootState) =>
-  R.path([VALKEY.HOTKEYS.name, id, "lastCollectedAt"], state) ?? null
+export const selectHotKeysLastCollectedAt = (targetId: string) => (state: RootState) =>
+  R.path([VALKEY.HOTKEYS.name, targetId, "lastCollectedAt"], state) ?? null
 
 interface HotKeysState {
-  [connectionId: string]: {
+  // Keyed by `targetId`: `clusterId` (cluster) or db-less `nodeId` (standalone).
+  [targetId: string]: {
     hotKeys: [string, number, number | null, number, string?][]
     checkAt: string | null,
     monitorRunning: boolean,
@@ -42,9 +46,10 @@ const hotKeysSlice = createSlice({
   reducers: {
     hotKeysRequested: (state, action) => {
       const { connectionId, clusterId } = action.payload
-      const id = clusterId ?? connectionId
-      if (!state[id]) {
-        state[id] = {
+      // Standalone hot keys state is node-level.
+      const targetId = clusterId ?? toNodeId(connectionId)
+      if (!state[targetId]) {
+        state[targetId] = {
           hotKeys: [],
           checkAt: null,
           monitorRunning: false,
@@ -52,25 +57,16 @@ const hotKeysSlice = createSlice({
           status: PENDING,
         }
       } else {
-        state[id].status = PENDING
-        state[id].hotKeys = []
-        state[id].error = null
+        state[targetId].status = PENDING
+        state[targetId].hotKeys = []
+        state[targetId].error = null
       }
     },
     hotKeysFulfilled: (state, action) => {
       const { hotKeys, monitorRunning, checkAt, nodeId, lastCollectedAt } = action.payload.parsedResponse
-      const key = action.payload.clusterId ?? action.payload.connectionId
+      const targetId = action.payload.clusterId ?? action.payload.nodeId
       const nodeErrors = action.payload.nodeErrors ?? []
-      if (!state[key]) {
-        state[key] = {
-          hotKeys: [],
-          checkAt: null,
-          monitorRunning: false,
-          nodeId: null,
-          status: PENDING,
-        }
-      }
-      state[key] = {
+      state[targetId] = {
         hotKeys,
         checkAt,
         monitorRunning,
@@ -79,13 +75,12 @@ const hotKeysSlice = createSlice({
         nodeErrors,
         status: FULFILLED,
       }
-      
     },
     hotKeysError: (state, action) => {
       const { error } = action.payload
-      const key = action.payload.clusterId ?? action.payload.connectionId
-      if (!state[key]) {
-        state[key] = {
+      const targetId = action.payload.clusterId ?? action.payload.nodeId
+      if (!state[targetId]) {
+        state[targetId] = {
           hotKeys: [],
           checkAt: null, 
           monitorRunning: false,
@@ -93,8 +88,8 @@ const hotKeysSlice = createSlice({
           status: ERROR,
         }
       }
-      state[key].error = error
-      state[key].status = ERROR
+      state[targetId].error = error
+      state[targetId].status = ERROR
     },
   },
 })
diff --git a/apps/frontend/src/state/valkey-features/monitor/monitorSlice.test.ts b/apps/frontend/src/state/valkey-features/monitor/monitorSlice.test.ts
index adb14fd6..e1b41593 100644
--- a/apps/frontend/src/state/valkey-features/monitor/monitorSlice.test.ts
+++ b/apps/frontend/src/state/valkey-features/monitor/monitorSlice.test.ts
@@ -5,53 +5,137 @@ import monitorReducer, {
   monitorError,
   saveMonitorSettingsRequested,
   selectMonitorRunning,
-  selectMonitorLoading
+  selectMonitorLoading,
+  selectClusterMonitorRunning,
+  selectClusterMonitorLoading,
+  selectRunningMonitorConnections
 } from "./monitorSlice"
 
 describe("monitorSlice", () => {
   const initialState = {}
 
   describe("monitorRequested", () => {
-    it("should create state for new connectionId and set loading to true", () => {
+    it("should create a node-keyed entry from a db-suffixed connectionId and set loading", () => {
       const state = monitorReducer(
         initialState,
-        monitorRequested({ connectionId: "conn-1" }),
+        monitorRequested({ connectionId: "host-6379-db0" }),
       )
 
-      expect(state["conn-1"]).toBeDefined()
-      expect(state["conn-1"].loading).toBe(true)
-      expect(state["conn-1"].monitorRunning).toBe(false)
-      expect(state["conn-1"].checkAt).toBeNull()
+      // Standalone pending entries are keyed by the db-less nodeId.
+      expect(state["host-6379"]).toBeDefined()
+      expect(state["host-6379-db0"]).toBeUndefined()
+      expect(state["host-6379"].loading).toBe(true)
+      expect(state["host-6379"].monitorRunning).toBe(false)
+      expect(state["host-6379"].checkAt).toBeNull()
+    })
+
+    it("should collapse two connections to the same node on different dbs into a single entry", () => {
+      const afterDb0 = monitorReducer(
+        initialState,
+        monitorRequested({ connectionId: "host-6379-db0" }),
+      )
+      const afterDb1 = monitorReducer(
+        afterDb0,
+        monitorRequested({ connectionId: "host-6379-db1" }),
+      )
+
+      // Both connections resolve to the same db-less nodeId → one entry.
+      expect(Object.keys(afterDb1)).toEqual(["host-6379"])
     })
 
     it("should set loading to true on existing state and preserve other fields", () => {
       const previousState = {
-        "conn-1": {
+        "host-6379": {
           monitorRunning: true,
           checkAt: 12345,
           loading: false,
+          startedAt: 100,
           error: null,
         },
       }
 
       const state = monitorReducer(
         previousState,
-        monitorRequested({ connectionId: "conn-1" }),
+        monitorRequested({ connectionId: "host-6379-db0" }),
       )
 
-      expect(state["conn-1"].loading).toBe(true)
-      expect(state["conn-1"].monitorRunning).toBe(true)
-      expect(state["conn-1"].checkAt).toBe(12345)
+      expect(state["host-6379"].loading).toBe(true)
+      expect(state["host-6379"].monitorRunning).toBe(true)
+      expect(state["host-6379"].checkAt).toBe(12345)
+    })
+
+    it("should NOT create a pending entry under the connection id on the cluster path", () => {
+      const state = monitorReducer(
+        initialState,
+        monitorRequested({ connectionId: "node-1-db0", clusterId: "cluster-1" }),
+      )
+
+      // Per-node entries come from replies; no orphan entry under the route id.
+      expect(state["node-1-db0"]).toBeUndefined()
+    })
+  })
+
+  describe("cluster monitor keying and selectors", () => {
+    it("keys cluster fulfilled by nodeId and tags clusterId", () => {
+      const state = monitorReducer(
+        initialState,
+        monitorFulfilled({
+          clusterId: "cluster-1",
+          nodeId: "node-1",
+          parsedResponse: { monitorRunning: true, checkAt: 1, startedAt: 2 },
+        }),
+      )
+
+      expect(state["node-1"]).toBeDefined()
+      expect(state["node-1"].clusterId).toBe("cluster-1")
+      expect(state["node-1"].monitorRunning).toBe(true)
+    })
+
+    it("selectClusterMonitorRunning is true only when all present cluster nodes run", () => {
+      const running = {
+        "node-1": { monitorRunning: true, checkAt: null, loading: false, startedAt: null, clusterId: "c1" },
+        "node-2": { monitorRunning: true, checkAt: null, loading: false, startedAt: null, clusterId: "c1" },
+      }
+      const partial = {
+        ...running,
+        "node-2": { monitorRunning: false, checkAt: null, loading: false, startedAt: null, clusterId: "c1" },
+      }
+      expect(selectClusterMonitorRunning("c1")({ monitor: running } as never)).toBe(true)
+      expect(selectClusterMonitorRunning("c1")({ monitor: partial } as never)).toBe(false)
+      // No entries for the cluster → not running.
+      expect(selectClusterMonitorRunning("c1")({ monitor: {} } as never)).toBe(false)
+    })
+
+    it("selectClusterMonitorLoading is true when any cluster node is loading", () => {
+      const state = {
+        "node-1": { monitorRunning: false, checkAt: null, loading: true, startedAt: null, clusterId: "c1" },
+        "node-2": { monitorRunning: false, checkAt: null, loading: false, startedAt: null, clusterId: "c1" },
+      }
+      expect(selectClusterMonitorLoading("c1")({ monitor: state } as never)).toBe(true)
+    })
+
+    it("selectRunningMonitorConnections includes clusterId for grouping", () => {
+      const state = {
+        "node-1": { monitorRunning: true, checkAt: null, loading: false, startedAt: 5, clusterId: "c1" },
+        "host-6379": { monitorRunning: true, checkAt: null, loading: false, startedAt: 6 },
+      }
+      const running = selectRunningMonitorConnections({ monitor: state } as never)
+      const node1 = running.find((r) => r.nodeId === "node-1")
+      expect(node1?.clusterId).toBe("c1")
+      expect(node1?.startedAt).toBe(5)
+      const standalone = running.find((r) => r.nodeId === "host-6379")
+      expect(standalone?.clusterId).toBeUndefined()
     })
   })
 
   describe("monitorFulfilled", () => {
     it("should set monitorRunning true with checkAt and clear loading/error", () => {
       const previousState = {
-        "conn-1": {
+        "host-6379": {
           monitorRunning: false,
           checkAt: null,
           loading: true,
+          startedAt: null,
           error: "old error",
         },
       }
@@ -59,23 +143,25 @@ describe("monitorSlice", () => {
       const state = monitorReducer(
         previousState,
         monitorFulfilled({
-          connectionId: "conn-1",
-          parsedResponse: { monitorRunning: true, checkAt: 99999 },
+          nodeId: "host-6379",
+          parsedResponse: { monitorRunning: true, checkAt: 99999, startedAt: 88888 },
         }),
       )
 
-      expect(state["conn-1"].monitorRunning).toBe(true)
-      expect(state["conn-1"].checkAt).toBe(99999)
-      expect(state["conn-1"].loading).toBe(false)
-      expect(state["conn-1"].error).toBeNull()
+      expect(state["host-6379"].monitorRunning).toBe(true)
+      expect(state["host-6379"].checkAt).toBe(99999)
+      expect(state["host-6379"].startedAt).toBe(88888)
+      expect(state["host-6379"].loading).toBe(false)
+      expect(state["host-6379"].error).toBeNull()
     })
 
     it("should set monitorRunning false when response says false", () => {
       const previousState = {
-        "conn-1": {
+        "host-6379": {
           monitorRunning: true,
           checkAt: 12345,
           loading: true,
+          startedAt: 100,
           error: null,
         },
       }
@@ -83,59 +169,73 @@ describe("monitorSlice", () => {
       const state = monitorReducer(
         previousState,
         monitorFulfilled({
-          connectionId: "conn-1",
+          nodeId: "host-6379",
           parsedResponse: { monitorRunning: false, checkAt: null },
         }),
       )
 
-      expect(state["conn-1"].monitorRunning).toBe(false)
-      expect(state["conn-1"].checkAt).toBeNull()
+      expect(state["host-6379"].monitorRunning).toBe(false)
+      expect(state["host-6379"].checkAt).toBeNull()
     })
 
-    it("should initialize state if connectionId does not exist yet", () => {
+    it("should initialize state if nodeId does not exist yet", () => {
       const state = monitorReducer(
         initialState,
         monitorFulfilled({
-          connectionId: "conn-new",
+          nodeId: "host-new",
           parsedResponse: { monitorRunning: true, checkAt: 55555 },
         }),
       )
 
-      expect(state["conn-new"]).toBeDefined()
-      expect(state["conn-new"].monitorRunning).toBe(true)
-      expect(state["conn-new"].checkAt).toBe(55555)
-      expect(state["conn-new"].loading).toBe(false)
-      expect(state["conn-new"].error).toBeNull()
+      expect(state["host-new"]).toBeDefined()
+      expect(state["host-new"].monitorRunning).toBe(true)
+      expect(state["host-new"].checkAt).toBe(55555)
+      expect(state["host-new"].loading).toBe(false)
+      expect(state["host-new"].error).toBeNull()
     })
   })
 
   describe("monitorError", () => {
-    it("should set error and clear loading on existing connectionId", () => {
+    it("should set error and clear loading on existing nodeId", () => {
       const previousState = {
-        "conn-1": {
+        "host-6379": {
           monitorRunning: false,
           checkAt: null,
           loading: true,
+          startedAt: null,
           error: null,
         },
       }
 
       const state = monitorReducer(
         previousState,
-        monitorError({ connectionId: "conn-1", error: "something failed" }),
+        monitorError({ nodeId: "host-6379", error: "something failed" }),
+      )
+
+      expect(state["host-6379"].error).toBe("something failed")
+      expect(state["host-6379"].loading).toBe(false)
+    })
+
+    it("should create-or-update on missing nodeId so cluster errors are not dropped", () => {
+      const state = monitorReducer(
+        initialState,
+        monitorError({ nodeId: "nonexistent", error: "fail" }),
       )
 
-      expect(state["conn-1"].error).toBe("something failed")
-      expect(state["conn-1"].loading).toBe(false)
+      expect(state["nonexistent"]).toBeDefined()
+      expect(state["nonexistent"].error).toBe("fail")
+      expect(state["nonexistent"].loading).toBe(false)
     })
 
-    it("should no-op on missing connectionId", () => {
+    it("should key cluster errors by nodeId and tag clusterId", () => {
       const state = monitorReducer(
         initialState,
-        monitorError({ connectionId: "nonexistent", error: "fail" }),
+        monitorError({ clusterId: "cluster-1", nodeId: "node-1", error: "node down" }),
       )
 
-      expect(state["nonexistent"]).toBeUndefined()
+      expect(state["node-1"]).toBeDefined()
+      expect(state["node-1"].clusterId).toBe("cluster-1")
+      expect(state["node-1"].error).toBe("node down")
     })
   })
 
@@ -151,35 +251,36 @@ describe("monitorSlice", () => {
 
     it("should not change existing state", () => {
       const previousState = {
-        "conn-1": {
+        "host-6379": {
           monitorRunning: true,
           checkAt: 12345,
           loading: false,
+          startedAt: 100,
           error: null,
         },
       }
 
       const state = monitorReducer(
         previousState,
-        saveMonitorSettingsRequested({ connectionId: "conn-1", monitorAction: "stop" }),
+        saveMonitorSettingsRequested({ connectionId: "host-6379-db0", monitorAction: "stop" }),
       )
 
-      expect(state["conn-1"]).toEqual(previousState["conn-1"])
+      expect(state["host-6379"]).toEqual(previousState["host-6379"])
     })
   })
 
   describe("selectors", () => {
-    it("selectMonitorRunning returns true when monitor is running", () => {
+    it("selectMonitorRunning returns true when monitor is running for a nodeId", () => {
       const rootState = {
         monitor: {
-          "conn-1": { monitorRunning: true, checkAt: null, loading: false },
+          "host-6379": { monitorRunning: true, checkAt: null, loading: false, startedAt: null },
         },
       }
 
-      expect(selectMonitorRunning("conn-1")(rootState as never)).toBe(true)
+      expect(selectMonitorRunning("host-6379")(rootState as never)).toBe(true)
     })
 
-    it("selectMonitorRunning defaults to false for missing connectionId", () => {
+    it("selectMonitorRunning defaults to false for missing nodeId", () => {
       const rootState = { monitor: {} }
 
       expect(selectMonitorRunning("missing")(rootState as never)).toBe(false)
@@ -188,14 +289,14 @@ describe("monitorSlice", () => {
     it("selectMonitorLoading returns true when loading", () => {
       const rootState = {
         monitor: {
-          "conn-1": { monitorRunning: false, checkAt: null, loading: true },
+          "host-6379": { monitorRunning: false, checkAt: null, loading: true, startedAt: null },
         },
       }
 
-      expect(selectMonitorLoading("conn-1")(rootState as never)).toBe(true)
+      expect(selectMonitorLoading("host-6379")(rootState as never)).toBe(true)
     })
 
-    it("selectMonitorLoading defaults to false for missing connectionId", () => {
+    it("selectMonitorLoading defaults to false for missing nodeId", () => {
       const rootState = { monitor: {} }
 
       expect(selectMonitorLoading("missing")(rootState as never)).toBe(false)
diff --git a/apps/frontend/src/state/valkey-features/monitor/monitorSlice.ts b/apps/frontend/src/state/valkey-features/monitor/monitorSlice.ts
index 691d2ac9..a76ea397 100644
--- a/apps/frontend/src/state/valkey-features/monitor/monitorSlice.ts
+++ b/apps/frontend/src/state/valkey-features/monitor/monitorSlice.ts
@@ -1,33 +1,61 @@
 import { createSlice } from "@reduxjs/toolkit"
 import { VALKEY } from "@common/src/constants.ts"
+import { toNodeId } from "@common/src/connection-id.ts"
 import * as R from "ramda"
 import type { RootState } from "@/store.ts"
 
 export const selectMonitorRunning =
-  (connectionId: string) =>
+  (nodeId: string) =>
     (state: RootState) =>
-      R.path<boolean>([VALKEY.MONITOR.name, connectionId, "monitorRunning"], state) ?? false
+      R.path<boolean>([VALKEY.MONITOR.name, nodeId, "monitorRunning"], state) ?? false
 
 export const selectMonitorLoading =
-  (connectionId: string) =>
+  (nodeId: string) =>
     (state: RootState) =>
-      R.path<boolean>([VALKEY.MONITOR.name, connectionId, "loading"], state) ?? false
+      R.path<boolean>([VALKEY.MONITOR.name, nodeId, "loading"], state) ?? false
 
 export const selectRunningMonitorConnections =
-  (state: RootState): { connectionId: string; startedAt: number | null }[] => {
+  (state: RootState): { nodeId: string; clusterId?: string; startedAt: number | null }[] => {
     const monitorState = R.path<MonitorState>([VALKEY.MONITOR.name], state) ?? {}
+    // The entry key is a `nodeId` for both cluster and standalone
+    // entries. `clusterId` (when present) groups cluster nodes.
     return Object.entries(monitorState)
       .filter(([, entry]) => entry.monitorRunning)
-      .map(([connectionId, entry]) => ({ connectionId, startedAt: entry.startedAt }))
+      .map(([nodeId, entry]) => ({ nodeId, clusterId: entry.clusterId, startedAt: entry.startedAt }))
   }
 
+/**
+ * Cluster monitor state is stored PER NODE (keyed by `nodeId` and
+ * tagged with `clusterId`). The cluster route `id` is a db-suffixed
+ * Connection_Identifier, so it never matches those entries directly. Roll the
+ * per-node entries up by `clusterId` and report running iff at least one node is
+ * present and all present nodes are running.
+ */
+export const selectClusterMonitorRunning =
+  (clusterId: string) =>
+    (state: RootState): boolean => {
+      const monitorState = R.path<MonitorState>([VALKEY.MONITOR.name], state) ?? {}
+      const entries = Object.values(monitorState).filter((entry) => entry.clusterId === clusterId)
+      return entries.length > 0 && entries.every((entry) => entry.monitorRunning)
+    }
+
+/** Cluster-aware loading: loading iff any node entry for the cluster is loading. */
+export const selectClusterMonitorLoading =
+  (clusterId: string) =>
+    (state: RootState): boolean => {
+      const monitorState = R.path<MonitorState>([VALKEY.MONITOR.name], state) ?? {}
+      return Object.values(monitorState).some((entry) => entry.clusterId === clusterId && entry.loading)
+    }
+
 interface MonitorState {
-  [connectionId: string]: {
+  [nodeId: string]: {
     monitorRunning: boolean
     checkAt: number | null
     loading: boolean
     error?: string | null
     startedAt: number | null
+    // Present on per-node cluster entries to groups entries into a cluster.
+    clusterId?: string
   }
 }
 
@@ -38,43 +66,59 @@ const monitorSlice = createSlice({
   initialState: initialMonitorState,
   reducers: {
     monitorRequested: (state, action) => {
-      const { connectionId } = action.payload
-      if (!state[connectionId]) {
-        state[connectionId] = {
+      const { connectionId, clusterId } = action.payload
+      // Cluster monitor state is populated per-node by the replies; do not
+      // create a pending entry under the representative db-suffixed `id!`
+      if (clusterId) return
+      // Standalone monitor state is node-level; key the pending entry by the
+      // db-less nodeId so it matches the nodeId-keyed reply entries.
+      const nodeId = toNodeId(connectionId)
+      if (!state[nodeId]) {
+        state[nodeId] = {
           monitorRunning: false,
           checkAt: null,
           loading: false,
           startedAt: null,
         }
       }
-      state[connectionId].loading = true
+      state[nodeId].loading = true
     },
     monitorFulfilled: (state, action) => {
-      const { connectionId, parsedResponse } = action.payload
-      if (!state[connectionId]) {
-        state[connectionId] = {
+      // Cluster replies carry `{ clusterId, nodeId }` (key by nodeId, tag
+      // clusterId); standalone carries `{ nodeId }`.
+      const { nodeId, clusterId, parsedResponse } = action.payload
+      if (!state[nodeId]) {
+        state[nodeId] = {
           monitorRunning: false,
           checkAt: null,
           loading: false,
           startedAt: null,
         }
       }
-      state[connectionId].monitorRunning = parsedResponse.monitorRunning ?? false
-      state[connectionId].checkAt = parsedResponse.checkAt ?? null
-      state[connectionId].startedAt = parsedResponse.startedAt ?? null
-      state[connectionId].loading = false
-      state[connectionId].error = null
+      if (clusterId) state[nodeId].clusterId = clusterId
+      state[nodeId].monitorRunning = parsedResponse.monitorRunning ?? false
+      state[nodeId].checkAt = parsedResponse.checkAt ?? null
+      state[nodeId].startedAt = parsedResponse.startedAt ?? null
+      state[nodeId].loading = false
+      state[nodeId].error = null
     },
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    saveMonitorSettingsRequested: (state, action) => {
+    saveMonitorSettingsRequested: (_state, _action) => {
       // no-op: exists to generate the action creator for the epic
     },
     monitorError: (state, action) => {
-      const { connectionId, error } = action.payload
-      if (state[connectionId]) {
-        state[connectionId].error = error
-        state[connectionId].loading = false
+      const { nodeId, clusterId, error } = action.payload
+      if (!state[nodeId]) {
+        state[nodeId] = {
+          monitorRunning: false,
+          checkAt: null,
+          loading: false,
+          startedAt: null,
+        }
       }
+      if (clusterId) state[nodeId].clusterId = clusterId
+      state[nodeId].error = error
+      state[nodeId].loading = false
     },
   },
 })
diff --git a/apps/server/src/__tests__/connection.test.ts b/apps/server/src/__tests__/connection.test.ts
index 23f1fcf5..027a0e59 100644
--- a/apps/server/src/__tests__/connection.test.ts
+++ b/apps/server/src/__tests__/connection.test.ts
@@ -2,7 +2,7 @@
 import { describe, it, mock, beforeEach, afterEach } from "node:test"
 import assert from "node:assert"
 import { GlideClient, GlideClusterClient, InfoOptions } from "@valkey/valkey-glide"
-import { buildConnectionId, KEY_EVICTION_POLICY, VALKEY } from "valkey-common"
+import { buildConnectionId, KEY_EVICTION_POLICY, VALKEY, toNodeId } from "valkey-common"
 import {
   _resetConnectInFlight,
   _resetInFlightClusterClients,
@@ -13,7 +13,7 @@ import {
 import { resolveHostnameOrIpAddress, dns } from "../utils"
 import { checkJsonModuleAvailability } from "../check-json-module"
 import { ConnectionDetails } from "../actions/connection"
-import { toMetricsNodeId, type MetricsServerMap } from "../metrics-orchestrator"
+import { type MetricsServerMap } from "../metrics-orchestrator"
 import { _reset as resetNodeWatchers } from "../node-watchers"
 
 const DEFAULT_PAYLOAD = {
@@ -138,7 +138,7 @@ describe("connectToValkey", () => {
     // metricsServerMap is keyed by metrics-node-id; the empty Connection_Identifier
     // strips to the empty string, which matches the empty connectionId used by
     // the default payload in these tests.
-    metricsServerMap.set(toMetricsNodeId(DEFAULT_PAYLOAD.connectionId), {
+    metricsServerMap.set(toNodeId(DEFAULT_PAYLOAD.connectionId), {
       metricsURI: "http://localhost:1234",
       pid: 12345,
       lastSeen: Date.now(),
diff --git a/apps/server/src/__tests__/hotkeys-commandlogs.test.ts b/apps/server/src/__tests__/hotkeys-commandlogs.test.ts
new file mode 100644
index 00000000..135f2dbc
--- /dev/null
+++ b/apps/server/src/__tests__/hotkeys-commandlogs.test.ts
@@ -0,0 +1,220 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, mock, beforeEach, afterEach } from "node:test"
+import assert from "node:assert"
+import { VALKEY, COMMANDLOG_TYPE } from "valkey-common"
+import { hotKeysRequested } from "../actions/hotkeys"
+import { commandLogsRequested } from "../actions/commandLogs"
+import { ClusterRegistry } from "../metrics-orchestrator"
+
+function createMockResponse(body: any, ok = true, status = 200) {
+  return {
+    ok,
+    status,
+    json: async () => body,
+  }
+}
+
+describe("hotKeysRequested reply shape", () => {
+  let mockWs: any
+  let messages: string[]
+  let metricsServerMap: Map<string, any>
+  let connectedNodesByCluster: Map<string, string[]>
+  let clusterNodesRegistry: ClusterRegistry
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    messages = []
+    mockWs = { send: mock.fn((msg: string) => messages.push(msg)) }
+    metricsServerMap = new Map()
+    connectedNodesByCluster = new Map()
+    clusterNodesRegistry = {}
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  function mockFetch(body: any, ok = true, status = 200) {
+    const fetchCalls: string[] = []
+    globalThis.fetch = (async (url: any) => {
+      fetchCalls.push(String(url))
+      return createMockResponse(body, ok, status)
+    }) as any
+    return fetchCalls
+  }
+
+  const deps = () => ({
+    ws: mockWs, metricsServerMap, connectedNodesByCluster, clients: new Map(), connectionId: "", clusterNodesRegistry,
+  } as any)
+
+  it("standalone hotKeysFulfilled carries a db-less { nodeId } (db suffix stripped)", async () => {
+    metricsServerMap.set("host-6379", { metricsURI: "http://localhost:9999" })
+    mockFetch({ nodeId: "host-6379", hotKeys: [], checkAt: 0, monitorRunning: true, lastCollectedAt: null })
+
+    const action = {
+      type: VALKEY.HOTKEYS.hotKeysRequested,
+      payload: { connectionId: "host-6379-db3" },
+    }
+
+    await hotKeysRequested(deps())(action as any)
+
+    assert.strictEqual(messages.length, 1)
+    const sent = JSON.parse(messages[0])
+    assert.strictEqual(sent.type, VALKEY.HOTKEYS.hotKeysFulfilled)
+    assert.strictEqual(sent.payload.nodeId, "host-6379")
+    assert.strictEqual(sent.payload.connectionId, undefined)
+    assert.strictEqual(sent.payload.clusterId, undefined)
+  })
+
+  it("standalone hotKeysError carries a db-less { nodeId } (db suffix stripped)", async () => {
+    metricsServerMap.set("host-6379", { metricsURI: "http://localhost:9999" })
+    mockFetch({ error: "boom" }, false, 500)
+
+    const action = {
+      type: VALKEY.HOTKEYS.hotKeysRequested,
+      payload: { connectionId: "host-6379-db3" },
+    }
+
+    await hotKeysRequested(deps())(action as any)
+
+    assert.strictEqual(messages.length, 1)
+    const sent = JSON.parse(messages[0])
+    assert.strictEqual(sent.type, VALKEY.HOTKEYS.hotKeysError)
+    assert.strictEqual(sent.payload.nodeId, "host-6379")
+    assert.strictEqual(sent.payload.connectionId, undefined)
+    assert.strictEqual(sent.payload.error, "boom")
+  })
+
+  it("cluster hotKeysFulfilled carries { clusterId } and db-less nodeErrors[].nodeId", async () => {
+    metricsServerMap.set("node-1", { metricsURI: "http://localhost:9001" })
+    // node-2 has no metrics entry → surfaces as a nodeError with a db-less nodeId.
+    clusterNodesRegistry = {
+      "cluster-1": {
+        "node-1": { host: "127.0.0.1", port: 7000, tls: false, verifyTlsCertificate: false },
+        "node-2": { host: "127.0.0.1", port: 7001, tls: false, verifyTlsCertificate: false },
+      },
+    }
+    mockFetch({ nodeId: "node-1", hotKeys: [], checkAt: 0, monitorRunning: true, lastCollectedAt: null })
+
+    const action = {
+      type: VALKEY.HOTKEYS.hotKeysRequested,
+      payload: { connectionId: "node-1", clusterId: "cluster-1" },
+    }
+
+    await hotKeysRequested(deps())(action as any)
+
+    assert.strictEqual(messages.length, 1)
+    const sent = JSON.parse(messages[0])
+    assert.strictEqual(sent.type, VALKEY.HOTKEYS.hotKeysFulfilled)
+    assert.strictEqual(sent.payload.clusterId, "cluster-1")
+    assert.strictEqual(sent.payload.nodeId, undefined)
+    assert.strictEqual(sent.payload.connectionId, undefined)
+    assert.ok(Array.isArray(sent.payload.nodeErrors))
+    assert.strictEqual(sent.payload.nodeErrors[0].nodeId, "node-2")
+    assert.ok(!/-db\d+$/.test(sent.payload.nodeErrors[0].nodeId))
+  })
+})
+
+describe("commandLogsRequested reply shape", () => {
+  let mockWs: any
+  let messages: string[]
+  let metricsServerMap: Map<string, any>
+  let connectedNodesByCluster: Map<string, string[]>
+  let clusterNodesRegistry: ClusterRegistry
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    messages = []
+    mockWs = { send: mock.fn((msg: string) => messages.push(msg)) }
+    metricsServerMap = new Map()
+    connectedNodesByCluster = new Map()
+    clusterNodesRegistry = {}
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  function mockFetch(body: any, ok = true, status = 200) {
+    const fetchCalls: string[] = []
+    globalThis.fetch = (async (url: any) => {
+      fetchCalls.push(String(url))
+      return createMockResponse(body, ok, status)
+    }) as any
+    return fetchCalls
+  }
+
+  function mockFetchThrow(error: Error) {
+    globalThis.fetch = (async () => { throw error }) as any
+  }
+
+  const deps = () => ({
+    ws: mockWs, metricsServerMap, connectedNodesByCluster, clients: new Map(), connectionId: "", clusterNodesRegistry,
+  } as any)
+
+  it("standalone commandLogsFulfilled carries a db-less { nodeId } (db suffix stripped)", async () => {
+    metricsServerMap.set("host-6379", { metricsURI: "http://localhost:9999" })
+    mockFetch({ nodeId: "host-6379", rows: [], count: 0, checkAt: 0 })
+
+    const action = {
+      type: VALKEY.COMMANDLOGS.commandLogsRequested,
+      payload: { connectionId: "host-6379-db1", commandLogType: COMMANDLOG_TYPE.SLOW },
+    }
+
+    await commandLogsRequested(deps())(action as any)
+
+    assert.strictEqual(messages.length, 1)
+    const sent = JSON.parse(messages[0])
+    assert.strictEqual(sent.type, VALKEY.COMMANDLOGS.commandLogsFulfilled)
+    assert.strictEqual(sent.payload.nodeId, "host-6379")
+    assert.strictEqual(sent.payload.connectionId, undefined)
+    assert.strictEqual(sent.payload.clusterId, undefined)
+  })
+
+  it("standalone commandLogsError carries a db-less { nodeId } (db suffix stripped)", async () => {
+    metricsServerMap.set("host-6379", { metricsURI: "http://localhost:9999" })
+    mockFetchThrow(new Error("network timeout"))
+
+    const action = {
+      type: VALKEY.COMMANDLOGS.commandLogsRequested,
+      payload: { connectionId: "host-6379-db1", commandLogType: COMMANDLOG_TYPE.SLOW },
+    }
+
+    await commandLogsRequested(deps())(action as any)
+
+    const errMsg = messages.map((m) => JSON.parse(m)).find((m) => m.type === VALKEY.COMMANDLOGS.commandLogsError)
+    assert.ok(errMsg, "expected a commandLogsError message")
+    assert.strictEqual(errMsg.payload.nodeId, "host-6379")
+    assert.strictEqual(errMsg.payload.connectionId, undefined)
+    assert.strictEqual(errMsg.payload.error, "network timeout")
+  })
+
+  it("cluster commandLogsFulfilled carries { clusterId } and db-less nodeErrors[].nodeId", async () => {
+    metricsServerMap.set("node-1", { metricsURI: "http://localhost:9001" })
+    // node-2 has no metrics entry → surfaces as a nodeError with a db-less nodeId.
+    clusterNodesRegistry = {
+      "cluster-1": {
+        "node-1": { host: "127.0.0.1", port: 7000, tls: false, verifyTlsCertificate: false },
+        "node-2": { host: "127.0.0.1", port: 7001, tls: false, verifyTlsCertificate: false },
+      },
+    }
+    mockFetch({ nodeId: "node-1", rows: [], count: 0, checkAt: 0 })
+
+    const action = {
+      type: VALKEY.COMMANDLOGS.commandLogsRequested,
+      payload: { connectionId: "node-1", clusterId: "cluster-1", commandLogType: COMMANDLOG_TYPE.SLOW },
+    }
+
+    await commandLogsRequested(deps())(action as any)
+
+    assert.strictEqual(messages.length, 1)
+    const sent = JSON.parse(messages[0])
+    assert.strictEqual(sent.type, VALKEY.COMMANDLOGS.commandLogsFulfilled)
+    assert.strictEqual(sent.payload.clusterId, "cluster-1")
+    assert.strictEqual(sent.payload.nodeId, undefined)
+    assert.strictEqual(sent.payload.connectionId, undefined)
+    assert.ok(Array.isArray(sent.payload.nodeErrors))
+    assert.strictEqual(sent.payload.nodeErrors[0].nodeId, "node-2")
+    assert.ok(!/-db\d+$/.test(sent.payload.nodeErrors[0].nodeId))
+  })
+})
diff --git a/apps/server/src/__tests__/metrics-orchestrator.test.ts b/apps/server/src/__tests__/metrics-orchestrator.test.ts
index ecc80e39..1507a3d1 100644
--- a/apps/server/src/__tests__/metrics-orchestrator.test.ts
+++ b/apps/server/src/__tests__/metrics-orchestrator.test.ts
@@ -8,7 +8,6 @@ import {
   reconcileClusterMetricsServers,
   clients,
   clusterNodesRegistry,
-  toMetricsNodeId,
   __test__,
   type ClusterNodeMap, 
   type MetricsServerMap 
@@ -278,32 +277,4 @@ describe("metrics-orchestrator", () => {
       // updateMetricsServers should not be called because nothing changed
     })
   })
-
-  describe("toMetricsNodeId", () => {
-    // The boundary helper between Connection_Identifier-keyed `clients` and
-    // metrics-node-id-keyed `metricsServerMap`.
-    it("strips a trailing -db0 suffix", () => {
-      assert.strictEqual(toMetricsNodeId("127-0-0-1-6379-db0"), "127-0-0-1-6379")
-    })
-
-    it("strips a trailing -db15 suffix (multi-digit)", () => {
-      assert.strictEqual(toMetricsNodeId("valkey-7001-7001-db15"), "valkey-7001-7001")
-    })
-
-    it("is idempotent on already-stripped ids", () => {
-      assert.strictEqual(toMetricsNodeId("valkey-7001-7001"), "valkey-7001-7001")
-    })
-
-    it("does not touch a non-trailing -db<N> token", () => {
-      assert.strictEqual(toMetricsNodeId("dbserver-db5-host-6379"), "dbserver-db5-host-6379")
-    })
-
-    it("does not strip when -db is followed by non-digits", () => {
-      assert.strictEqual(toMetricsNodeId("host-6379-dbx"), "host-6379-dbx")
-    })
-
-    it("returns the empty string unchanged", () => {
-      assert.strictEqual(toMetricsNodeId(""), "")
-    })
-  })
 })
diff --git a/apps/server/src/__tests__/monitorAction.test.ts b/apps/server/src/__tests__/monitorAction.test.ts
index 689b280d..fc3dd879 100644
--- a/apps/server/src/__tests__/monitorAction.test.ts
+++ b/apps/server/src/__tests__/monitorAction.test.ts
@@ -72,12 +72,42 @@ describe("monitorAction", () => {
       assert.strictEqual(messages.length, 1)
       const sent = JSON.parse(messages[0])
       assert.strictEqual(sent.type, VALKEY.MONITOR.monitorFulfilled)
-      assert.strictEqual(sent.payload.connectionId, "conn-1")
+      // Standalone monitor replies carry a db-less { nodeId }.
+      assert.strictEqual(sent.payload.nodeId, "conn-1")
+      assert.strictEqual(sent.payload.connectionId, undefined)
       assert.strictEqual(sent.payload.parsedResponse.monitorRunning, false)
       assert.strictEqual(sent.payload.parsedResponse.checkAt, null)
     })
   })
 
+  describe("standalone db normalization", () => {
+    it("keys the reply by the db-less nodeId and looks up metrics by the db-less node id", async () => {
+      // metricsServerMap is keyed db-less; the payload connectionId is db-suffixed.
+      metricsServerMap.set("host-6379", { metricsURI: "http://localhost:9999" })
+      const fetchCalls = mockFetch({ monitorRunning: true, checkAt: 123 })
+
+      const action = {
+        type: VALKEY.MONITOR.monitorRequested,
+        payload: { connectionId: "host-6379-db2", monitorAction: "status" },
+      }
+
+      await monitorRequested(deps())(action as any)
+
+      // Looked up the db-less metrics entry.
+      assert.strictEqual(fetchCalls.length, 1)
+      assert.ok(fetchCalls[0].includes("localhost:9999/monitor?action=status"))
+
+      // Monitor state is node-level: the reply carries the db-less nodeId
+      // (the `-db2` suffix is stripped), never the db-suffixed connectionId.
+      assert.strictEqual(messages.length, 1)
+      const sent = JSON.parse(messages[0])
+      assert.strictEqual(sent.type, VALKEY.MONITOR.monitorFulfilled)
+      assert.strictEqual(sent.payload.nodeId, "host-6379")
+      assert.strictEqual(sent.payload.connectionId, undefined)
+      assert.strictEqual(sent.payload.clusterId, undefined)
+    })
+  })
+
   describe("start request", () => {
     it("should call GET /monitor?action=start and send monitorFulfilled", async () => {
       metricsServerMap.set("conn-1", { metricsURI: "http://localhost:9999" })
@@ -131,7 +161,9 @@ describe("monitorAction", () => {
       assert.strictEqual(messages.length, 1)
       const sent = JSON.parse(messages[0])
       assert.strictEqual(sent.type, VALKEY.MONITOR.monitorError)
-      assert.strictEqual(sent.payload.connectionId, "conn-missing")
+      // Standalone monitor errors are keyed by the db-less nodeId.
+      assert.strictEqual(sent.payload.nodeId, "conn-missing")
+      assert.strictEqual(sent.payload.connectionId, undefined)
       assert.strictEqual(sent.payload.error, "Metrics server URI not found")
     })
   })
@@ -211,8 +243,12 @@ describe("monitorAction", () => {
       const sent2 = JSON.parse(messages[1])
       assert.strictEqual(sent1.type, VALKEY.MONITOR.monitorFulfilled)
       assert.strictEqual(sent2.type, VALKEY.MONITOR.monitorFulfilled)
-      const sentConnectionIds = [sent1.payload.connectionId, sent2.payload.connectionId].sort()
-      assert.deepStrictEqual(sentConnectionIds, ["node-1", "node-2"])
+      // Cluster replies carry { clusterId, nodeId } (db-less nodeId), not connectionId.
+      assert.strictEqual(sent1.payload.connectionId, undefined)
+      assert.strictEqual(sent1.payload.clusterId, "cluster-1")
+      assert.strictEqual(sent2.payload.clusterId, "cluster-1")
+      const sentNodeIds = [sent1.payload.nodeId, sent2.payload.nodeId].sort()
+      assert.deepStrictEqual(sentNodeIds, ["node-1", "node-2"])
     })
   })
 
@@ -244,7 +280,9 @@ describe("monitorAction", () => {
       assert.strictEqual(watcherMessages.length, 1)
       const broadcast = JSON.parse(watcherMessages[0])
       assert.strictEqual(broadcast.type, VALKEY.MONITOR.monitorFulfilled)
-      assert.strictEqual(broadcast.payload.connectionId, "conn-1")
+      // Broadcast reply is node-keyed (db-less nodeId), not connectionId.
+      assert.strictEqual(broadcast.payload.nodeId, "conn-1")
+      assert.strictEqual(broadcast.payload.connectionId, undefined)
       assert.strictEqual(broadcast.payload.parsedResponse.monitorRunning, true)
     })
 
@@ -311,6 +349,36 @@ describe("monitorAction", () => {
       // Only one message to originator, no extra broadcast
       assert.strictEqual(messages.length, 1)
     })
+
+    it("looks up other watchers by the db-suffixed connectionId while replying with a db-less nodeId", async () => {
+      // Metrics is keyed db-less; watcher subscriptions stay keyed by the
+      // db-suffixed connectionId (Req 6.5). The reply payload is node-level.
+      metricsServerMap.set("host-6379", { metricsURI: "http://localhost:9999" })
+      mockFetch({ monitorRunning: true, checkAt: 12345 })
+
+      const watcherMessages: string[] = []
+      const otherWs: any = { send: mock.fn((msg: string) => watcherMessages.push(msg)) }
+
+      // Both clients subscribe under the db-suffixed connectionId.
+      subscribe("host-6379-db2", mockWs)
+      subscribe("host-6379-db2", otherWs)
+
+      const action = {
+        type: VALKEY.MONITOR.monitorRequested,
+        payload: { connectionId: "host-6379-db2", monitorAction: "start" },
+      }
+
+      await monitorRequested(deps())(action as any)
+
+      // getOtherWatchers resolved the db-suffixed connectionId, so the other
+      // watcher (subscribed under "host-6379-db2") received the broadcast.
+      assert.strictEqual(watcherMessages.length, 1)
+      const broadcast = JSON.parse(watcherMessages[0])
+      assert.strictEqual(broadcast.type, VALKEY.MONITOR.monitorFulfilled)
+      // ...but the reply payload itself is keyed by the db-less nodeId.
+      assert.strictEqual(broadcast.payload.nodeId, "host-6379")
+      assert.strictEqual(broadcast.payload.connectionId, undefined)
+    })
   })
 })
 
@@ -498,16 +566,76 @@ describe("saveMonitorSettingsRequested", () => {
 
     await saveMonitorSettingsRequested(deps())(action as any)
 
+    // Config: one POST per node (2) + one aggregated reply; monitor: 2 POSTs + 2 replies.
     assert.strictEqual(fetchCalls.length, 4)
-    // All config messages come before all monitor messages (sequential await)
     const parsed = messages.map((m: string) => JSON.parse(m))
     const configMsgs = parsed.filter((m: any) => m.type === VALKEY.CONFIG.updateConfigFulfilled)
     const monitorMsgs = parsed.filter((m: any) => m.type === VALKEY.MONITOR.monitorFulfilled)
-    assert.strictEqual(configMsgs.length, 2)
+    // Config aggregates the cluster fan-out into ONE cluster-keyed reply.
+    assert.strictEqual(configMsgs.length, 1)
+    assert.strictEqual(configMsgs[0].payload.clusterId, "cluster-1")
+    assert.strictEqual(configMsgs[0].payload.connectionId, undefined)
+    // Monitor remains per-node (2 replies).
     assert.strictEqual(monitorMsgs.length, 2)
 
-    // Config messages appear before monitor messages in the messages array
+    // The aggregated config message precedes the monitor messages (config awaited first)
     const firstMonitorIdx = parsed.findIndex((m: any) => m.type === VALKEY.MONITOR.monitorFulfilled)
-    assert.ok(firstMonitorIdx >= 2, "all config messages should precede monitor messages")
+    const configIdx = parsed.findIndex((m: any) => m.type === VALKEY.CONFIG.updateConfigFulfilled)
+    assert.ok(configIdx < firstMonitorIdx, "config message should precede monitor messages")
+  })
+
+  it("aggregates cluster config to one failure reply when a node fails (first error)", async () => {
+    metricsServerMap.set("node-1", { metricsURI: "http://localhost:9001" })
+    metricsServerMap.set("node-2", { metricsURI: "http://localhost:9002" })
+    clusterNodesRegistry = {
+      "cluster-1": {
+        "node-1": { host: "127.0.0.1", port: 7000, tls: false, verifyTlsCertificate: false },
+        "node-2": { host: "127.0.0.1", port: 7001, tls: false, verifyTlsCertificate: false },
+      },
+    }
+    // node-2 (9002) fails; node-1 succeeds.
+    globalThis.fetch = (async (url: any) => {
+      const urlStr = String(url)
+      if (urlStr.includes("9002")) {
+        return createMockResponse({ success: false, message: "bad config", data: {} }, false, 400)
+      }
+      return createMockResponse({ success: true, message: "", data: {} })
+    }) as any
+
+    const action = {
+      type: VALKEY.MONITOR.saveMonitorSettingsRequested,
+      payload: { connectionId: "node-1", clusterId: "cluster-1", config: { epic: { name: "monitor" } } },
+      meta: undefined,
+    }
+
+    await saveMonitorSettingsRequested(deps())(action as any)
+
+    // One aggregated reply, keyed by clusterId, surfacing the failure.
+    assert.strictEqual(messages.length, 1)
+    const sent = JSON.parse(messages[0])
+    assert.strictEqual(sent.type, VALKEY.CONFIG.updateConfigFailed)
+    assert.strictEqual(sent.payload.clusterId, "cluster-1")
+    assert.strictEqual(sent.payload.connectionId, undefined)
+  })
+
+  it("keys a standalone config reply by the db-less nodeId", async () => {
+    metricsServerMap.set("host-6379", { metricsURI: "http://localhost:9999" })
+    mockFetchRouted({ "/update-config": { body: { success: true, message: "", data: {} } } })
+
+    const action = {
+      type: VALKEY.MONITOR.saveMonitorSettingsRequested,
+      payload: { connectionId: "host-6379-db0", config: { epic: { name: "monitor" } } },
+      meta: undefined,
+    }
+
+    await saveMonitorSettingsRequested(deps())(action as any)
+
+    assert.strictEqual(messages.length, 1)
+    const sent = JSON.parse(messages[0])
+    assert.strictEqual(sent.type, VALKEY.CONFIG.updateConfigFulfilled)
+    // Config is node-level: reply carries the db-stripped nodeId, not the connectionId.
+    assert.strictEqual(sent.payload.nodeId, "host-6379")
+    assert.strictEqual(sent.payload.connectionId, undefined)
+    assert.strictEqual(sent.payload.clusterId, undefined)
   })
 })
diff --git a/apps/server/src/actions/commandLogs.ts b/apps/server/src/actions/commandLogs.ts
index 7ece84bf..44fb13f0 100644
--- a/apps/server/src/actions/commandLogs.ts
+++ b/apps/server/src/actions/commandLogs.ts
@@ -1,8 +1,7 @@
 import { type WebSocket } from "ws"
-import { VALKEY, COMMANDLOG_TYPE, type AggregateReplyId } from "valkey-common"
+import { VALKEY, COMMANDLOG_TYPE, type AggregateReplyId, toNodeId } from "valkey-common"
 import * as R from "ramda"
 import { withDeps, Deps } from "./utils"
-import { toMetricsNodeId } from "../metrics-orchestrator"
 
 type CommandLogType = typeof COMMANDLOG_TYPE.SLOW | typeof COMMANDLOG_TYPE.LARGE_REQUEST | typeof COMMANDLOG_TYPE.LARGE_REPLY
 
@@ -66,7 +65,7 @@ const sendCommandLogsFulfilled = (
 
 const sendCommandLogsError = (
   ws: WebSocket,
-  connectionId: string,
+  nodeId: string,
   error: unknown,
 ) => {
   console.error(error)
@@ -74,7 +73,7 @@ const sendCommandLogsError = (
     JSON.stringify({
       type: VALKEY.COMMANDLOGS.commandLogsError,
       payload: {
-        connectionId,
+        nodeId,
         error: error instanceof Error ? error.message : String(error),
       },
     }),
@@ -101,34 +100,34 @@ export const commandLogsRequested = withDeps<Deps, void>(
     const commandLogType: CommandLogType = action.payload.commandLogType as CommandLogType
 
     const nodes = typeof clusterId === "string" ? clusterNodesRegistry[clusterId] : undefined
-    const nodeIds = nodes ? Object.keys(nodes) : [toMetricsNodeId(connectionId)]
+    const nodeIds = nodes ? Object.keys(nodes) : [toNodeId(connectionId)]
 
     const promises = nodeIds.map(async (nodeId: string) => {
       const metricsServerURI = metricsServerMap.get(nodeId)?.metricsURI
       if (!metricsServerURI) {
-        if (!nodes) sendCommandLogsError(ws, connectionId, new Error("Metrics server URI not found"))
+        if (!nodes) sendCommandLogsError(ws, nodeId, new Error("Metrics server URI not found"))
         return { nodeId, error: "Metrics server not started" } as NodeError
       }
       try {
         console.debug(`[Command Logs ${commandLogType}] Fetching from:`, metricsServerURI)
         return await fetchCommandLogs(metricsServerURI, commandLogType)
       } catch (error) {
-        if (!nodes) sendCommandLogsError(ws, connectionId, error)
+        if (!nodes) sendCommandLogsError(ws, nodeId, error)
         return { nodeId, error: error instanceof Error ? error.message : String(error) } as NodeError
       }
     })
 
     const settled = await Promise.all(promises)
-    const results = settled.filter((r): r is CommandLogResponse & { connectionId: string } => !!r && "rows" in r)
+    const results = settled.filter((r): r is CommandLogResponse => !!r && "rows" in r)
     const nodeErrors = nodes ? settled.filter((r): r is NodeError => !!r && "error" in r) : []
 
     if (!nodes) {
-      if (results[0]) sendCommandLogsFulfilled(ws, { connectionId }, results[0], commandLogType)
+      if (results[0]) sendCommandLogsFulfilled(ws, { nodeId: toNodeId(connectionId) }, results[0], commandLogType)
       return
     }
 
     const sortedValues = R.pipe(
-      R.chain(({ rows, nodeId }) => rows.map((row) => ({ row, nodeId }))),
+      R.chain((r: CommandLogResponse) => (r.rows ?? []).map((row) => ({ row, nodeId: r.nodeId }))),
       R.chain(({ row, nodeId }) => (row.values ?? []).map((v) => ({ ...v, nodeId }))),
       R.sort(
         R.descend(
diff --git a/apps/server/src/actions/config.ts b/apps/server/src/actions/config.ts
index d686604c..ce0004df 100644
--- a/apps/server/src/actions/config.ts
+++ b/apps/server/src/actions/config.ts
@@ -1,7 +1,6 @@
 import { type WebSocket } from "ws"
-import { VALKEY, type AggregateReplyId } from "valkey-common"
+import { VALKEY, type AggregateReplyId, toNodeId } from "valkey-common"
 import { Deps, withDeps, fetchWithTimeout } from "./utils"
-import { toMetricsNodeId } from "../metrics-orchestrator"
 
 interface ParsedResponse  {
   success: boolean, 
@@ -56,12 +55,12 @@ export const updateConfig = withDeps<Deps, void>(
       return
     }
 
-    const nodeId = toMetricsNodeId(connectionId)
+    const nodeId = toNodeId(connectionId)
     const response = await postConfigToNode(metricsServerMap.get(nodeId)?.metricsURI, config)
     if (response.success) {
-      sendUpdateFulfilled(ws, { connectionId }, response)
+      sendUpdateFulfilled(ws, { nodeId }, response)
     } else {
-      sendUpdateError(ws, { connectionId }, response)
+      sendUpdateError(ws, { nodeId }, response)
     }
   },  
 )
diff --git a/apps/server/src/actions/cpuUsage.ts b/apps/server/src/actions/cpuUsage.ts
index 7e0e8195..62768e5f 100644
--- a/apps/server/src/actions/cpuUsage.ts
+++ b/apps/server/src/actions/cpuUsage.ts
@@ -1,7 +1,6 @@
 import { type WebSocket } from "ws"
-import { VALKEY } from "valkey-common"
+import { VALKEY, toNodeId } from "valkey-common"
 import { withDeps, Deps, fetchWithTimeout } from "./utils"
-import { toMetricsNodeId } from "../metrics-orchestrator"
 
 type CpuUsageResponse = Array<{
   timestamp: number
@@ -55,9 +54,9 @@ export const cpuUsageRequested = withDeps<Deps, void>(
     const connectionIds = clusterId ? connectedNodesByCluster.get(clusterId as string) ?? [] : [connectionId]
 
     const promises = connectionIds.map(async (connectionId: string) => {
-      // metricsServerMap is keyed by metrics-node-id; map at the boundary.
+      // metricsServerMap is keyed by metrics-node-id.
       // Idempotent on the cluster-fan-out path where ids already lack `-db`.
-      const metricsServerURI = metricsServerMap.get(toMetricsNodeId(connectionId))?.metricsURI
+      const metricsServerURI = metricsServerMap.get(toNodeId(connectionId))?.metricsURI
 
       if (!metricsServerURI) {
         sendCpuUsageError(ws, connectionId, new Error("Metrics server URI not found"))
diff --git a/apps/server/src/actions/hotkeys.ts b/apps/server/src/actions/hotkeys.ts
index 3bc62b6d..70b59336 100644
--- a/apps/server/src/actions/hotkeys.ts
+++ b/apps/server/src/actions/hotkeys.ts
@@ -1,8 +1,7 @@
 import { type WebSocket } from "ws"
-import { VALKEY, type AggregateReplyId } from "valkey-common"
+import { VALKEY, type AggregateReplyId, toNodeId } from "valkey-common"
 import * as R from "ramda"
 import { withDeps, Deps } from "./utils"
-import { toMetricsNodeId } from "../metrics-orchestrator"
 
 type HotKeysResponse = {
   nodeId: string
@@ -37,7 +36,7 @@ const sendHotKeysFulfilled = (
 
 const sendHotKeysError = (
   ws: WebSocket,
-  connectionId: string,
+  nodeId: string,
   error: unknown,
 ) => {
   console.error(error)
@@ -45,7 +44,7 @@ const sendHotKeysError = (
     JSON.stringify({
       type: VALKEY.HOTKEYS.hotKeysError,
       payload: {
-        connectionId,
+        nodeId,
         error: error instanceof Error ? error.message : String(error),
       },
     }),
@@ -61,7 +60,7 @@ export const hotKeysRequested = withDeps<Deps, void>(
       ? clusterNodesRegistry[clusterId] 
       : undefined
 
-    const nodeIds = nodes ? Object.keys(nodes) : [toMetricsNodeId(connectionId)]
+    const nodeIds = nodes ? Object.keys(nodes) : [toNodeId(connectionId)]
 
     const promises = nodeIds.map(async (nodeId: string) => {
       const metricsServerURI = metricsServerMap.get(nodeId)?.metricsURI
@@ -81,7 +80,7 @@ export const hotKeysRequested = withDeps<Deps, void>(
         if (!initialResponse.ok) {
           const errorBody = await initialResponse.json() as { error?: string }
           if (!nodes) {
-            sendHotKeysError(ws, connectionId, errorBody.error ?? `HTTP ${initialResponse.status}`)
+            sendHotKeysError(ws, nodeId, errorBody.error ?? `HTTP ${initialResponse.status}`)
             return
           }
           return { nodeId, error: errorBody.error ?? `HTTP ${initialResponse.status}` } as NodeError
@@ -99,7 +98,7 @@ export const hotKeysRequested = withDeps<Deps, void>(
         }
       } catch (error) {
         if (!nodes) {
-          sendHotKeysError(ws, connectionId, error)
+          sendHotKeysError(ws, nodeId, error)
           return
         }
         return { nodeId, error: error instanceof Error ? error.message : String(error) } as NodeError
@@ -119,7 +118,7 @@ export const hotKeysRequested = withDeps<Deps, void>(
     }
 
     if (!nodes) {
-      sendHotKeysFulfilled(ws, { connectionId }, results[0])
+      sendHotKeysFulfilled(ws, { nodeId: toNodeId(connectionId) }, results[0])
       return
     }
 
diff --git a/apps/server/src/actions/memoryUsage.ts b/apps/server/src/actions/memoryUsage.ts
index af61c3f8..c99864a8 100644
--- a/apps/server/src/actions/memoryUsage.ts
+++ b/apps/server/src/actions/memoryUsage.ts
@@ -1,7 +1,6 @@
 import { type WebSocket } from "ws"
-import { VALKEY } from "valkey-common"
+import { VALKEY, toNodeId } from "valkey-common"
 import { withDeps, Deps, fetchWithTimeout } from "./utils"
-import { toMetricsNodeId } from "../metrics-orchestrator"
 
 interface MemoryMetric {
   description: string
@@ -61,9 +60,9 @@ export const memoryUsageRequested = withDeps<Deps, void>(
     const { connectionId, clusterId, timeRange = "12h" } = action.payload as unknown as RequestPayload
     const connectionIds = clusterId ? connectedNodesByCluster.get(clusterId as string) ?? [] : [connectionId]
     const promises = connectionIds.map(async (connectionId: string) => {
-      // metricsServerMap is keyed by metrics-node-id; map at the boundary.
+      // metricsServerMap is keyed by metrics-node-id.
       // Idempotent on the cluster-fan-out path where ids already lack `-db`.
-      const metricsServerURI = metricsServerMap.get(toMetricsNodeId(connectionId))?.metricsURI
+      const metricsServerURI = metricsServerMap.get(toNodeId(connectionId))?.metricsURI
 
       if (!metricsServerURI) {
         sendMemoryUsageError(ws, connectionId, new Error("Metrics server URI not found"))
diff --git a/apps/server/src/actions/monitorAction.ts b/apps/server/src/actions/monitorAction.ts
index 4e88daf4..9e85691a 100644
--- a/apps/server/src/actions/monitorAction.ts
+++ b/apps/server/src/actions/monitorAction.ts
@@ -1,9 +1,8 @@
 import { type WebSocket } from "ws"
-import { VALKEY, type MonitorAction, type NodeReplyId } from "valkey-common"
+import { VALKEY, type MonitorAction, type NodeReplyId, toNodeId } from "valkey-common"
 import { withDeps, type Deps, fetchWithTimeout, type ReduxAction } from "./utils"
 import { updateConfig } from "./config"
 import { getOtherWatchers } from "../node-watchers"
-import { toMetricsNodeId } from "../metrics-orchestrator"
 
 type MonitorResponse = {
   monitorRunning: boolean
@@ -55,9 +54,10 @@ export const monitorRequested = withDeps<Deps, void>(
         runMonitorForNode(ws, metricsServerMap.get(nodeId)?.metricsURI, monitorAction, { clusterId, nodeId }, nodeId),
       ))
     } else {
-      // Standalone path
-    const nodeId = toMetricsNodeId(connectionId)
-    await runMonitorForNode(ws, metricsServerMap.get(nodeId)?.metricsURI, monitorAction, { connectionId }, connectionId)
+      // Standalone path. Monitor state is keyed by the db-less nodeId, so the
+      // reply carries { nodeId }.
+      const nodeId = toNodeId(connectionId)
+      await runMonitorForNode(ws, metricsServerMap.get(nodeId)?.metricsURI, monitorAction, { nodeId }, connectionId)
     }
   })
 
diff --git a/apps/server/src/actions/stats.ts b/apps/server/src/actions/stats.ts
index 45d71da8..12872380 100644
--- a/apps/server/src/actions/stats.ts
+++ b/apps/server/src/actions/stats.ts
@@ -1,10 +1,10 @@
 import { type Deps, withDeps } from "./utils"
 import { setDashboardData } from "../set-dashboard-data"
-import { toMetricsNodeId } from "../metrics-orchestrator"
+import { toNodeId } from "valkey-common"
 
 export const setData = withDeps<Deps, void>(
   async ({ ws, metricsServerMap, connectionId }) => {
-    const metricsServerURI = metricsServerMap.get(toMetricsNodeId(connectionId))?.metricsURI
+    const metricsServerURI = metricsServerMap.get(toNodeId(connectionId))?.metricsURI
     await setDashboardData(connectionId, metricsServerURI, ws)
   },
 )
diff --git a/apps/server/src/connection.ts b/apps/server/src/connection.ts
index de599a14..4799e318 100644
--- a/apps/server/src/connection.ts
+++ b/apps/server/src/connection.ts
@@ -2,7 +2,7 @@ import { GlideClient, GlideClusterClient, InfoOptions, ServerCredentials, Servic
 import * as R from "ramda"
 import WebSocket from "ws"
 import { VALKEY } from "valkey-common"
-import { buildConnectionId, isValidDatabaseIndex, sanitizeUrl } from "valkey-common"
+import { buildConnectionId, isValidDatabaseIndex, sanitizeUrl, toNodeId } from "valkey-common"
 import { KeyEvictionPolicy } from "common/dist"
 import { 
   getExistingClusterClient, 
@@ -22,7 +22,6 @@ import {
   clusterCredentials, 
   reconcileClusterMetricsServers, 
   isKubernetes, 
-  toMetricsNodeId, 
   ClusterNodeMap } from "./metrics-orchestrator"
 import { subscribe } from "./node-watchers"
 import { createClusterValkeyClient, createStandaloneValkeyClient } from "./valkey-client"
@@ -370,10 +369,10 @@ async function connectToValkeyLocked(
 
     // In K8s or Web, metrics servers register themselves.
     if (!isKubernetes) {
-      // `metricsServerMap` is keyed by metrics-node-id, not Connection_Identifier.
+      // `metricsServerMap` is keyed by node-id, not Connection_Identifier.
       // Strip the `-db<N>` suffix so a second user connection on a different
       // db reuses the existing metrics process for the same node (N:1).
-      const metricsNodeId = toMetricsNodeId(payload.connectionId)
+      const metricsNodeId = toNodeId(payload.connectionId)
       if (!metricsServerMap.has(metricsNodeId)) {
         await startMetricsServer(payload.connectionDetails, metricsNodeId)
       }
@@ -649,7 +648,7 @@ export async function closeMetricsServer(
   clients: Map<string, { client: GlideClient | GlideClusterClient; clusterId?: string }>,
 ) {
   // Map Connection_Identifier → metrics-node-id at the boundary.
-  const metricsNodeId = toMetricsNodeId(connectionId)
+  const nodeId = toNodeId(connectionId)
 
   // N:1 invariant: many user-visible connections may share one metrics
   // process for the same (host, port). Only close when this is the LAST
@@ -658,11 +657,11 @@ export async function closeMetricsServer(
   // removed `connectionId` from `clients`; teardownConnection currently
   // removes first, so this is belt-and-suspenders.
   const stillReferenced = [...clients.keys()].some(
-    (id) => id !== connectionId && toMetricsNodeId(id) === metricsNodeId,
+    (id) => id !== connectionId && toNodeId(id) === nodeId,
   )
   if (stillReferenced) return
 
-  const metricsServerUri = metricsServerMap.get(metricsNodeId)?.metricsURI
+  const metricsServerUri = metricsServerMap.get(nodeId)?.metricsURI
   if (metricsServerUri) {
     const res = await fetch(`${metricsServerUri}/connection/close`, 
       { method: "POST",
@@ -670,8 +669,8 @@ export async function closeMetricsServer(
         body: JSON.stringify({ connectionId }), 
       })
     if (res.ok) {
-      metricsServerMap.delete(metricsNodeId)
-      console.log(`Metrics server for ${metricsNodeId} closed successfully`)
+      metricsServerMap.delete(nodeId)
+      console.log(`Metrics server for ${nodeId} closed successfully`)
     }
     else console.warn("Could not kill metrics server process")
   }
diff --git a/apps/server/src/metrics-orchestrator.ts b/apps/server/src/metrics-orchestrator.ts
index 6f9f3f92..978329e1 100644
--- a/apps/server/src/metrics-orchestrator.ts
+++ b/apps/server/src/metrics-orchestrator.ts
@@ -9,7 +9,7 @@
  * The relationship is N:1 (many Connection_Identifiers per metrics-node-id):
  * a metrics process is one OS process per Valkey node, and the data it
  * collects (INFO, MEMORY STATS, MONITOR, COMMANDLOG) is server-global, not
- * db-scoped. Use `toMetricsNodeId` at every boundary; never use the metrics
+ * db-scoped. Use `toNodeId` at every boundary; never use the metrics
  * map directly with a Connection_Identifier.
  */
 import { GlideClient, GlideClusterClient, ConnectionError, ServiceType } from "@valkey/valkey-glide"
@@ -17,33 +17,11 @@ import { ChildProcess, spawn } from "child_process"
 import { fileURLToPath } from "url"
 import { Router, type Request, type Response } from "express"
 import path from "path"
-import { DEPLOYMENT_TYPE, sanitizeUrl } from "valkey-common"
+import { DEPLOYMENT_TYPE, sanitizeUrl, toNodeId } from "valkey-common"
 import { discoverCluster } from "./connection"
 import { ConnectionDetails } from "./actions/connection"
 import { createOrchestratorValkeyClient } from "./valkey-client"
 
-/**
- * Strip the `-db<N>` suffix from a Connection_Identifier so it matches the
- * metrics-node-id format used as a key in `metricsServerMap`.
- *
- * Why this helper exists:
- *   - `clients` keys carry `db` because each (host, port, db) is a distinct
- *     user-visible connection with its own Glide client.
- *   - `metricsServerMap` keys do NOT carry `db`. A metrics process is one OS
- *     process per Valkey node (host, port); the data it collects is
- *     server-global, not db-scoped.
- *   - The two maps therefore have an N:1 relationship: many user-visible
- *     connections under one metrics process. Use this helper at every
- *     boundary that turns a Connection_Identifier into the matching
- *     metrics-node-id.
- *
- * Idempotent — calling it on an already-stripped id returns the same id.
- * The `$` anchor only strips a trailing `-db<digits>` group, never random
- * text earlier in the id.
- */
-export const toMetricsNodeId = (connectionId: string): string =>
-  connectionId.replace(/-db\d+$/, "")
-
 // Assumes nodeId is unique among all clusters
 export type MetricsServerMap = Map<string,
   {
@@ -145,7 +123,7 @@ export function createMetricsOrchestratorRouter() {
     // so any open user-visible connection under this node counts as a valid
     // client.
     const nodeConnected = [...clients.keys()].some(
-      (id) => toMetricsNodeId(id) === nodeId,
+      (id) => toNodeId(id) === nodeId,
     )
 
     if (nodeBelongsToCluster || nodeConnected)  {
@@ -253,7 +231,7 @@ async function findDiff(metricsServerMap: MetricsServerMap, clusterNodeMap: Clus
       // down to this node (N:1). Avoids evicting standalone metrics whose
       // owner connection is keyed `-db<N>`.
       const knownToClients = [...clients.keys()].some(
-        (id) => toMetricsNodeId(id) === key,
+        (id) => toNodeId(id) === key,
       )
       return (!clusterNodes[key] && !knownToClients) || (now - value.lastSeen) > ttl
     })
diff --git a/common/package.json b/common/package.json
index f848e3b6..65d4ddaf 100644
--- a/common/package.json
+++ b/common/package.json
@@ -13,7 +13,8 @@
   },
   "files": ["dist"],
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --out-dir dist --clean"
+    "build": "tsup src/index.ts --format esm --dts --out-dir dist --clean",
+    "test": "npx tsx --test src/__tests__/*.test.ts"
   },
   "devDependencies": {
     "tsup": "^7.0.0",
diff --git a/common/src/__tests__/connection-id.test.ts b/common/src/__tests__/connection-id.test.ts
new file mode 100644
index 00000000..15283a0f
--- /dev/null
+++ b/common/src/__tests__/connection-id.test.ts
@@ -0,0 +1,31 @@
+import { describe, it } from "node:test"
+import assert from "node:assert"
+import { toNodeId } from "../connection-id"
+
+describe("toNodeId", () => {
+  // The shared db-strip helper that turns a Connection_Identifier
+  // (`<host>-<port>-db<N>`) into the db-less metrics-node-id (`<host>-<port>`).
+  it("strips a trailing -db0 suffix", () => {
+    assert.strictEqual(toNodeId("127-0-0-1-6379-db0"), "127-0-0-1-6379")
+  })
+
+  it("strips a trailing -db15 suffix (multi-digit)", () => {
+    assert.strictEqual(toNodeId("valkey-7001-7001-db15"), "valkey-7001-7001")
+  })
+
+  it("is idempotent on already-stripped ids", () => {
+    assert.strictEqual(toNodeId("valkey-7001-7001"), "valkey-7001-7001")
+  })
+
+  it("does not touch a non-trailing -db<N> token", () => {
+    assert.strictEqual(toNodeId("dbserver-db5-host-6379"), "dbserver-db5-host-6379")
+  })
+
+  it("does not strip when -db is followed by non-digits", () => {
+    assert.strictEqual(toNodeId("host-6379-dbx"), "host-6379-dbx")
+  })
+
+  it("returns the empty string unchanged", () => {
+    assert.strictEqual(toNodeId(""), "")
+  })
+})
diff --git a/common/src/connection-id.ts b/common/src/connection-id.ts
index 46cd2930..fa4c03b8 100644
--- a/common/src/connection-id.ts
+++ b/common/src/connection-id.ts
@@ -18,6 +18,25 @@ export const buildConnectionId = (
   db: number = 0,
 ): string => `${sanitizeUrl(`${host}-${port}`)}-db${db}`
 
+/**
+ * Strip the trailing `-db<N>` suffix from a Connection_Identifier so it
+ * matches the db-less metrics-node-id (`nodeId`) format.
+ *
+ * Why this helper exists:
+ *   - Connection_Identifiers (`<host>-<port>-db<N>`) carry `db` because each
+ *     (host, port, db) is a distinct user-visible connection with its own
+ *     Glide client.
+ *   - Node-level metrics state (monitor status, sampler config, hot keys,
+ *     command logs) and `metricsServerMap` are keyed by the db-less
+ *     `<host>-<port>` because a metrics process is one OS process per Valkey
+ *     node.
+ *
+ * Idempotent.
+ *
+ * @param id - A Connection_Identifier (or an already-db-less node id).
+ */
+export const toNodeId = (id: string): string => id.replace(/-db\d+$/, "")
+
 /**
  * Type guard for the Database_Index. Returns true only for non-negative
  * integers; rejects negatives, non-integers, NaN, and non-numbers.
diff --git a/common/src/reply-id.ts b/common/src/reply-id.ts
index 34203c62..835a9285 100644
--- a/common/src/reply-id.ts
+++ b/common/src/reply-id.ts
@@ -5,24 +5,22 @@
  * and consumer never disagree. Two shapes exist, distinguished by how the frontend stores the
  * resulting state:
  *
- *   - `AggregateReplyId` — the reply is stored as a SINGLE entry per cluster (or
- *     per standalone connection). Used by features that aggregate all cluster
- *     nodes server-side into one result.
+ *   - `AggregateReplyId` — the reply is stored as a SINGLE entry per cluster or
+ *     per standalone node. Used by features that aggregate all cluster
+ *     nodes server-side into one result (config, hotkeys, commandlogs).
  *
  *   - `NodeReplyId` — the reply is stored PER NODE. Used by features that keep
- *     per-node state on the frontend.
+ *     per-node state on the frontend (monitor).
  *
- * Both share the standalone arm `{ connectionId }` (db-suffixed
- * Connection_Identifier). No field ever holds a different id-space than its
- * name; `clusterId`/`nodeId` are db-less, `connectionId` is db-suffixed.
+ * No metrics reply carries a db-suffixed `{ connectionId }` arm, every reply
+ * identifies itself by `clusterId` (cluster) or `nodeId` (standalone/per-node),
+ * both of which are db-less.
  */
 
-/** Cluster-scoped or standalone reply, stored as one entry per cluster/connection. */
-export type AggregateReplyId =
-  | { clusterId: string }
-  | { connectionId: string }
+/** Cluster-scoped or standalone reply, stored as one entry per cluster/node. */
+export type AggregateReplyId = { clusterId: string } | { nodeId: string }
 
-/** Per-node (cluster) or standalone reply, stored as one entry per node/connection. */
+/** Per-node (cluster) or standalone reply, stored as one entry per node. */
 export type NodeReplyId =
   | { clusterId: string; nodeId: string }
-  | { connectionId: string }
+  | { nodeId: string }

From 0c63e4e61bd768c1e86ec7d6c3645ebdad429bc7 Mon Sep 17 00:00:00 2001
From: Argus Li <argus@argusli.dev>
Date: Tue, 23 Jun 2026 13:59:44 -0700
Subject: [PATCH 06/10] Fix hotkey standalone no result bug.

Signed-off-by: Argus Li <argus@argusli.dev>
---
 apps/server/src/actions/hotkeys.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/apps/server/src/actions/hotkeys.ts b/apps/server/src/actions/hotkeys.ts
index 70b59336..8f48d46b 100644
--- a/apps/server/src/actions/hotkeys.ts
+++ b/apps/server/src/actions/hotkeys.ts
@@ -110,9 +110,12 @@ export const hotKeysRequested = withDeps<Deps, void>(
     const nodeErrors = nodes ? settled.filter((r): r is NodeError => !!r && "error" in r) : []
 
     if (results.length === 0) {
+      const emptyResponse = { hotKeys: [], monitorRunning: false, checkAt: 0, nodeId: "" } as unknown as HotKeysResponse
       if (nodes) {
-        const emptyResponse = { hotKeys: [], monitorRunning: false, checkAt: 0, nodeId: "" } as unknown as HotKeysResponse
         sendHotKeysFulfilled(ws, { clusterId: clusterId as string }, emptyResponse, nodeErrors)
+      } else {
+        // standalone
+        sendHotKeysFulfilled(ws, { nodeId: toNodeId(connectionId) }, emptyResponse, nodeErrors)
       }
       return
     }

From 927a19c6ed21175e1a983833af7b67da9790adee Mon Sep 17 00:00:00 2001
From: Argus Li <argus@argusli.dev>
Date: Tue, 23 Jun 2026 14:17:17 -0700
Subject: [PATCH 07/10] fix lint import issue

Signed-off-by: Argus Li <argus@argusli.dev>
---
 eslint.config.js => eslint.config.mjs | 0
 package.json                          | 2 +-
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename eslint.config.js => eslint.config.mjs (100%)

diff --git a/eslint.config.js b/eslint.config.mjs
similarity index 100%
rename from eslint.config.js
rename to eslint.config.mjs
diff --git a/package.json b/package.json
index 11882df5..aaa97813 100644
--- a/package.json
+++ b/package.json
@@ -51,7 +51,7 @@
     "package:linux:nosign": "export CSC_IDENTITY_AUTO_DISCOVERY=false && npm run package:linux",
     "package:linux:arm64": "npm run build:electron && npx electron-builder --linux --arm64 --publish never",
     "package:linux:arm64:nosign": "export CSC_IDENTITY_AUTO_DISCOVERY=false && npm run package:linux:arm64",
-    "lint": "eslint .",
+    "lint": "eslint --fix .",
     "test:integration": "npm --workspace apps/server run test:integration"
   },
   "build": {

From 6a87f0578701640b956003df4782f25ce9eaeddf Mon Sep 17 00:00:00 2001
From: Argus Li <argus@argusli.dev>
Date: Tue, 23 Jun 2026 14:17:47 -0700
Subject: [PATCH 08/10] Fix lint

Signed-off-by: Argus Li <argus@argusli.dev>
---
 .../activity-view/hotkeys/hot-keys-params-modal.tsx           | 2 +-
 .../valkey-features/commandlogs/commandLogsSlice.test.ts      | 2 +-
 .../src/state/valkey-features/config/configSlice.test.ts      | 2 +-
 .../src/state/valkey-features/hotkeys/hotKeysSlice.test.ts    | 2 +-
 apps/server/src/actions/hotkeys.ts                            | 4 ++--
 apps/server/src/actions/stats.ts                              | 2 +-
 6 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/apps/frontend/src/components/activity-view/hotkeys/hot-keys-params-modal.tsx b/apps/frontend/src/components/activity-view/hotkeys/hot-keys-params-modal.tsx
index 32e9ac3d..3e368f4e 100644
--- a/apps/frontend/src/components/activity-view/hotkeys/hot-keys-params-modal.tsx
+++ b/apps/frontend/src/components/activity-view/hotkeys/hot-keys-params-modal.tsx
@@ -10,10 +10,10 @@ import { Button } from "../../ui/button"
 import { Input } from "../../ui/input"
 import { Typography } from "../../ui/typography"
 import { TooltipIcon } from "../../ui/tooltip-icon"
+import type { RootState } from "@/store"
 import { useAppDispatch } from "@/hooks/hooks"
 import { selectConfig } from "@/state/valkey-features/config/configSlice"
 import { saveMonitorSettingsRequested, selectMonitorRunning, selectClusterMonitorRunning } from "@/state/valkey-features/monitor/monitorSlice"
-import type { RootState } from "@/store"
 
 interface HotKeysConfigModalProps {
   open: boolean
diff --git a/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.test.ts b/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.test.ts
index 87b395ab..e318e594 100644
--- a/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.test.ts
+++ b/apps/frontend/src/state/valkey-features/commandlogs/commandLogsSlice.test.ts
@@ -3,7 +3,7 @@ import { COMMANDLOG_TYPE } from "@common/src/constants.ts"
 import commandLogsReducer, {
   commandLogsRequested,
   commandLogsFulfilled,
-  commandLogsError,
+  commandLogsError
 } from "./commandLogsSlice"
 
 describe("commandLogsSlice", () => {
diff --git a/apps/frontend/src/state/valkey-features/config/configSlice.test.ts b/apps/frontend/src/state/valkey-features/config/configSlice.test.ts
index 01834e11..c227bcc1 100644
--- a/apps/frontend/src/state/valkey-features/config/configSlice.test.ts
+++ b/apps/frontend/src/state/valkey-features/config/configSlice.test.ts
@@ -4,7 +4,7 @@ import configReducer, {
   updateConfig,
   updateConfigFulfilled,
   updateConfigFailed,
-  selectConfig,
+  selectConfig
 } from "./configSlice"
 
 describe("configSlice", () => {
diff --git a/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.test.ts b/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.test.ts
index 2f79922f..f9c30093 100644
--- a/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.test.ts
+++ b/apps/frontend/src/state/valkey-features/hotkeys/hotKeysSlice.test.ts
@@ -3,7 +3,7 @@ import { PENDING, FULFILLED, ERROR } from "@common/src/constants.ts"
 import hotKeysReducer, {
   hotKeysRequested,
   hotKeysFulfilled,
-  hotKeysError,
+  hotKeysError
 } from "./hotKeysSlice"
 
 describe("hotKeysSlice", () => {
diff --git a/apps/server/src/actions/hotkeys.ts b/apps/server/src/actions/hotkeys.ts
index 8f48d46b..43e555d6 100644
--- a/apps/server/src/actions/hotkeys.ts
+++ b/apps/server/src/actions/hotkeys.ts
@@ -57,8 +57,8 @@ export const hotKeysRequested = withDeps<Deps, void>(
 
     const nodes =
       typeof clusterId === "string" 
-      ? clusterNodesRegistry[clusterId] 
-      : undefined
+        ? clusterNodesRegistry[clusterId] 
+        : undefined
 
     const nodeIds = nodes ? Object.keys(nodes) : [toNodeId(connectionId)]
 
diff --git a/apps/server/src/actions/stats.ts b/apps/server/src/actions/stats.ts
index 12872380..bc7f0f5f 100644
--- a/apps/server/src/actions/stats.ts
+++ b/apps/server/src/actions/stats.ts
@@ -1,6 +1,6 @@
+import { toNodeId } from "valkey-common"
 import { type Deps, withDeps } from "./utils"
 import { setDashboardData } from "../set-dashboard-data"
-import { toNodeId } from "valkey-common"
 
 export const setData = withDeps<Deps, void>(
   async ({ ws, metricsServerMap, connectionId }) => {

From da46eb6edb2e696215689eadf6aa9c35ca3bb37b Mon Sep 17 00:00:00 2001
From: Argus Li <argus@argusli.dev>
Date: Tue, 23 Jun 2026 15:18:51 -0700
Subject: [PATCH 09/10] Fix double hot key response.

Signed-off-by: Argus Li <argus@argusli.dev>
---
 apps/server/src/actions/hotkeys.ts | 28 ++++++++++++----------------
 1 file changed, 12 insertions(+), 16 deletions(-)

diff --git a/apps/server/src/actions/hotkeys.ts b/apps/server/src/actions/hotkeys.ts
index 43e555d6..04133d96 100644
--- a/apps/server/src/actions/hotkeys.ts
+++ b/apps/server/src/actions/hotkeys.ts
@@ -65,10 +65,7 @@ export const hotKeysRequested = withDeps<Deps, void>(
     const promises = nodeIds.map(async (nodeId: string) => {
       const metricsServerURI = metricsServerMap.get(nodeId)?.metricsURI
       if (!metricsServerURI) {
-        if (!nodes) {
-          console.warn("Metrics server not started for node: ", nodeId)
-          return
-        }
+        console.warn("Metrics server not started for node: ", nodeId)
         return { nodeId, error: "Metrics server not started" } as NodeError
       }
       const url = new URL("/hot-keys", metricsServerURI)
@@ -79,10 +76,6 @@ export const hotKeysRequested = withDeps<Deps, void>(
         const initialResponse = await fetch(url)
         if (!initialResponse.ok) {
           const errorBody = await initialResponse.json() as { error?: string }
-          if (!nodes) {
-            sendHotKeysError(ws, nodeId, errorBody.error ?? `HTTP ${initialResponse.status}`)
-            return
-          }
           return { nodeId, error: errorBody.error ?? `HTTP ${initialResponse.status}` } as NodeError
         }
         const initialParsedResponse: HotKeysResponse = await initialResponse.json() as HotKeysResponse
@@ -97,25 +90,28 @@ export const hotKeysRequested = withDeps<Deps, void>(
           return initialParsedResponse
         }
       } catch (error) {
-        if (!nodes) {
-          sendHotKeysError(ws, nodeId, error)
-          return
-        }
         return { nodeId, error: error instanceof Error ? error.message : String(error) } as NodeError
       }
     })
 
     const settled = await Promise.all(promises)
     const results = settled.filter((r): r is HotKeysResponse => !!r && "hotKeys" in r)
-    const nodeErrors = nodes ? settled.filter((r): r is NodeError => !!r && "error" in r) : []
+    const nodeErrors = settled.filter((r): r is NodeError => !!r && "error" in r)
 
     if (results.length === 0) {
-      const emptyResponse = { hotKeys: [], monitorRunning: false, checkAt: 0, nodeId: "" } as unknown as HotKeysResponse
       if (nodes) {
+        const emptyResponse = { hotKeys: [], monitorRunning: false, checkAt: 0, nodeId: "" } as unknown as HotKeysResponse
         sendHotKeysFulfilled(ws, { clusterId: clusterId as string }, emptyResponse, nodeErrors)
+        return
+      }
+      // Standalone: surface the node's error if it failed; otherwise emit an
+      // empty fulfilled so the request still terminates (clears the spinner).
+      if (nodeErrors[0]) {
+        sendHotKeysError(ws, toNodeId(connectionId), nodeErrors[0].error)
       } else {
-        // standalone
-        sendHotKeysFulfilled(ws, { nodeId: toNodeId(connectionId) }, emptyResponse, nodeErrors)
+        const nodeId = toNodeId(connectionId)
+        const emptyResponse = { hotKeys: [], monitorRunning: false, checkAt: 0, nodeId } as unknown as HotKeysResponse
+        sendHotKeysFulfilled(ws, { nodeId }, emptyResponse)
       }
       return
     }

From 568d3d1b2bf826f0e073524683a453b180924c25 Mon Sep 17 00:00:00 2001
From: Argus Li <argus@argusli.dev>
Date: Wed, 24 Jun 2026 10:15:44 -0700
Subject: [PATCH 10/10] Add ADR.

Signed-off-by: Argus Li <argus@argusli.dev>
---
 ...0624-node-level-metrics-keyed-by-nodeid.md | 55 +++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 docs/adr/20260624-node-level-metrics-keyed-by-nodeid.md

diff --git a/docs/adr/20260624-node-level-metrics-keyed-by-nodeid.md b/docs/adr/20260624-node-level-metrics-keyed-by-nodeid.md
new file mode 100644
index 00000000..78a0ac01
--- /dev/null
+++ b/docs/adr/20260624-node-level-metrics-keyed-by-nodeid.md
@@ -0,0 +1,55 @@
+# ADR — Node-level metrics state keyed by db-less `nodeId`, not the db-suffixed `connectionId`
+
+- **Status:** Accepted
+- **Date:** 2026-06-24
+- **Related:** Builds on the `cluster-monitor-config-id-mismatch` bugfix, which made cluster monitor/config state surface correctly. This ADR records the id-space decision that fix implied and extends it to standalone monitor, config, hot keys, and command logs.
+
+## Context
+
+Valkey Admin uses three distinct id-spaces that must not be conflated:
+
+- **`connectionId`** — `<host>-<port>-db<N>`, db-suffixed. It is the key of the server `clients` map, the frontend route param `id`, and the identity of a user-visible connection. Each `(host, port, db)` triple is a separate connection with its own Glide client.
+- **`nodeId`** — `<host>-<port>`, db-less. The identity of a Valkey node. A metrics process is **one OS process per node**, and the data it samples (MONITOR, COMMANDLOG, MEMORY/INFO stats) and its sampler config are server-global per node, not db-scoped. Many db connections map to one node (N:1).
+- **`clusterId`** — the cluster's own id from `CLUSTER SLOTS`; db-less.
+
+One further name, **`targetId`**, appears in the frontend but is *not* a fourth id-space: it is the deliberately polymorphic key variable used in the metrics slices and `ActivityView`, resolved as `clusterId ?? nodeId`. It holds whichever of the two db-less id-spaces applies (cluster aggregate vs. per-node/standalone) and is the one place a name intentionally spans id-spaces; every other field is named for its exact id-space.
+
+Node-level metrics state (monitor status, sampler config, hot keys, command logs) was keyed by the db-suffixed `connectionId` on the standalone path, while the server emitted some replies in the db-less node id-space. Producer and consumer disagreed on the id-space: state was written under keys the UI never read. The visible symptoms were monitor status that never surfaced, config updates that didn't appear, a pending monitor stuck loading, duplicate hot-key responses, and standalone hot keys showing no result.
+
+The ambiguity was **invisible at the call sites.** A single reply field (`connectionId`) sometimes carried a `clusterId`, and the same `<host>-<port>-db<N>` string was used both as a connection key and, after an ad-hoc `toMetricsNodeId` strip, as a metrics key. A reader could not tell from a reducer or an action which id-space a value belonged to, so "two connections to the same node on different databases" silently produced two independent monitor/config entries for what is physically one sampler.
+
+## Decision
+
+All node-level metrics state is keyed by the db-less **`nodeId`**, with cluster aggregates keyed by **`clusterId`**. No metrics reply or metrics state is keyed by the db-suffixed `connectionId`.
+
+Concretely:
+
+- **Explicit reply id-spaces** (`common/src/reply-id.ts`). Every metrics reply identifies itself with exactly one id-space — no field holds more than one:
+  - `AggregateReplyId = { clusterId } | { nodeId }` — stored as one entry per cluster (aggregated) or per standalone node. Used by config, hot keys, command logs.
+  - `NodeReplyId = { clusterId, nodeId } | { nodeId }` — stored per node. Used by monitor.
+
+  No reply carries a `{ connectionId }` arm.
+
+- **One shared, idempotent db-strip** (`toNodeId` in `common/src/connection-id.ts`, exported from `valkey-common`). It strips only a trailing `-db<digits>` group (`id.replace(/-db\d+$/, "")`), is total and idempotent, and replaces the server's duplicated `toMetricsNodeId` regex at every call site (`metrics-orchestrator`, `connection`, and the `config`/`cpuUsage`/`memoryUsage`/`hotkeys`/`commandLogs`/`monitorAction`/`stats` actions).
+
+- **Explicit cluster vs. standalone branches.** Server actions and frontend reducers split into explicit branches rather than overloading one `targetId`/`connectionId` value. Standalone emits `{ nodeId }`; cluster emits `{ clusterId }` (aggregated) or `{ clusterId, nodeId }` (per-node monitor). Frontend consumers resolve their key as `clusterId ?? toNodeId(id)`.
+
+Rationale:
+
+- **The data is node-level, so the key must be.** One MONITOR sampler runs per node; its data and config have no database dimension. Keying by `connectionId` modeled a database dimension that does not exist, splitting one physical sampler into multiple entries.
+- **Naming for the id-space prevents the class of bug.** When every field, variable, and parameter is named `clusterId`, `nodeId`, or `connectionId` and holds exactly that, producer and consumer cannot silently disagree. The original defect was a single field that sometimes held a `clusterId`.
+- **`connectionId` is still correct where identity is db-scoped.** The `clients` map, route params, connection state, and watcher subscriptions legitimately remain db-suffixed. Only metrics reply/state keying moves to `nodeId`.
+
+## Consequences
+
+- Two connections to the same node on different databases now share a single monitor/config/hot-keys/command-logs entry, matching the one-sampler-per-node reality.
+- `nodeId` derivation is centralized: the server no longer reimplements the strip, and the frontend uses the same `toNodeId`. The `connection-id-ownership` guard is unaffected (it targets `sanitizeUrl(host-port)` construction, not strips).
+- Connection-scoped state remains keyed by the db-suffixed `connectionId` and coexists with the node-level state in the same view. In `ActivityView`, the route supplies `id` (`connectionId`) and `clusterId`; the component derives `nodeId = toNodeId(id)` and `targetId = clusterId ?? nodeId` once, then routes each selector to the id-space its data actually lives in: hot keys, command logs, monitor, and sampler config read by `targetId`, while `connectionDetails`, `clusterAlias`, and the key browser read by `id`. The two ids are not redundant copies of one record as they address different state.
+- Tests assert the id-space directly: standalone replies carry `{ nodeId }`, cluster replies carry `{ clusterId }` (or `{ clusterId, nodeId }` for monitor), `nodeErrors[].nodeId` stays db-less, and a db-suffixed input is stripped in the emitted id. `toNodeId` has unit coverage for idempotence and trailing-only stripping.
+- Cluster aggregation, the per-node granularity of `MonitorWarningBanner`, and the standalone watcher broadcast are behavior-preserving; only the key changes.
+
+## Out of scope
+
+- **Watcher subscription keying.** `node-watchers` subscribe by the db-suffixed `connectionId`, and `getOtherWatchers` is still called with the `connectionId` on the standalone monitor path. Unchanged.
+- **Connection state, route params, and the `clients` map.** These are genuinely db-scoped and remain keyed by `connectionId`.
+- **Per-row `nodeId` inside aggregated hot-keys/command-logs data.** Already db-less; unchanged.