In `@internal/service/frontend/api/v2/sse_data.go`:
- Around line 96-171: GetDAGRunLogsData currently hardcodes
fileutil.LogReadOptions{Tail: 500} which causes SSE payloads to always return
500 lines regardless of the UI pageSize; modify GetDAGRunLogsData to accept a
tail parameter from the SSE identifier/query (e.g., parse an optional tail value
from identifier or read from the SSE request query) and use that value when
constructing fileutil.LogReadOptions.Tail (fallback to existing default like 500
or ui default 1000 if missing), validate/clamp the tail to reasonable bounds,
and ensure the same identifier parsing logic around strings.Cut(ref :=
exec.NewDAGRunRef(...)) continues to work so SSE and REST return consistent line
counts.

In `@internal/service/frontend/sse/proxy.go`:
- Around line 32-38: The TLS config for the HTTP client (the client variable
using http.Transport with TLSClientConfig and node.SkipTLSVerify) must set a
secure minimum TLS version and the http.Client should have a request timeout to
avoid goroutine leaks; update the tls.Config to include MinVersion (e.g.,
tls.VersionTLS12 or higher) and set a sensible Timeout on the http.Client, and
ensure the "time" package is imported for the timeout value.

In `@internal/service/frontend/sse/watcher.go`:
- Around line 117-129: The broadcast method on Watcher calls
w.metrics.MessageSent(...) without checking for a nil w.metrics, which can
panic; update Watcher.broadcast to guard the metrics call (e.g., if w.metrics !=
nil) before invoking MessageSent, mirroring the nil-check pattern used in poll
so that metrics are only recorded when w.metrics is non-nil while preserving the
existing Send/Close logic for clients.
- Around line 83-98: The poll method in Watcher calls w.metrics.FetchError(...)
without checking if w.metrics is nil, which will panic; add a nil check before
invoking FetchError (e.g., if w.metrics != nil {
w.metrics.FetchError(string(w.topicType)) }) so metrics calls are only made when
w.metrics is non-nil; keep the existing backoff, broadcast(&Event{Type:
EventTypeError, Data: err.Error()}) and errorBackoff.Next logic intact.
- Around line 53-70: The Watcher currently never emits lifecycle metrics; call
the Metrics methods when the watcher starts and stops: invoke
w.metrics.WatcherStarted() at the beginning of Watcher.Start (after creating the
ticker / after initial poll) and ensure w.metrics.WatcherStopped() is invoked
whenever Start returns (on ctx.Done(), w.stopCh or any early exit), and also add
the stop metric call inside Watcher.Stop (or wherever w.stopCh is closed) so
both Watcher.Start and Watcher.Stop consistently emit
WatcherStarted()/WatcherStopped() using the existing w.metrics field.

In `@ui/src/features/dags/components/dag-execution/ExecutionLog.tsx`:
- Around line 68-69: isLiveMode is only initialized from isRunning and never
updated, so when dagRun.status stops being Status.Running the UI can hide the
live toggle while polling/SSE remain active; add a useEffect in ExecutionLog
that watches isRunning (derived from dagRun?.status === Status.Running) and
calls setIsLiveMode(isRunning) or sets false when isRunning becomes false to
keep isLiveMode in sync with dagRun state (use the existing isLiveMode,
setIsLiveMode, isRunning, and Status.Running symbols).
- Around line 238-247: The highlight uses the removed Tailwind v4
`bg-opacity-20`; in the scroll-to-line highlight block inside ExecutionLog.tsx
(the loop that finds elements by '[data-line-number]' and calls scrollIntoView),
replace the two-class approach htmlElement.classList.add('bg-primary/100',
'bg-opacity-20') and the corresponding classList.remove with a single
slash-opacity color class (e.g., 'bg-primary/100/20' or if your palette uses
hyphen shades 'bg-primary-100/20' or simply 'bg-primary/20'); remove any use of
'bg-opacity-20' so add/remove use the new single class name.

In `@ui/src/hooks/useDAGRunsListSSE.ts`:
- Around line 10-17: The DAGRunsListParams.interface currently types status as
string but the API uses a numeric Status enum; change the status property to
number (status?: number) in the DAGRunsListParams definition and update any call
sites in useDAGRunsListSSE (or functions that build the request/polling params)
to stop treating it as a string—remove parseInt() conversions and ensure values
passed to the polling endpoint are numeric so types and runtime behavior align
with the API.

In `@ui/src/hooks/useSSE.ts`:
- Around line 70-74: The SSE listener registered via
eventSource.addEventListener('data', ...) currently calls
JSON.parse(messageEvent.data) without protection; wrap the parse in a try-catch
inside that listener so malformed JSON doesn't throw and break the SSE flow, log
or handle the parse error (e.g., processLogger/warn or set an error state) and
avoid calling setState with invalid parsed data; locate the listener in useSSE
(the handler that casts event as MessageEvent and assigns to parsed) and enclose
JSON.parse(...) in a try block with a catch that handles/logs the error and
returns early.
- Around line 93-98: In useSSE's retry logic, increment retryCountRef.current
before scheduling the setTimeout so the retry attempt uses the updated count
(preventing an extra attempt); specifically, inside the block that checks
retryCountRef.current < MAX_RETRIES, move the retryCountRef.current++ to execute
immediately (before calling setTimeout stored in retryTimeoutRef) and then
compute the delay via calculateRetryDelay(retryCountRef.current) and call
connect() from the timeout—this ensures retries 1..MAX_RETRIES occur instead of
0..MAX_RETRIES-1.

In `@internal/service/frontend/api/v2/dags.go`:
- Around line 350-391: getDAGDetailsData currently treats any error from
a.dagRunMgr.GetLatestStatus as fatal which hides valid DAGs with no runs; update
the GetLatestStatus error handling in getDAGDetailsData so that if the error is
exec.ErrNoStatusData (or the equivalent sentinel from the exec package) you
treat there being no latest run (e.g., leave dagStatus nil/zero and set
LatestDAGRun to an empty/nil value via ToDAGRunDetails), but for other errors
return the formatted error as before; adjust the call site around
a.dagRunMgr.GetLatestStatus and ToDAGRunDetails to handle the absent-status case
without failing the whole response.

In `@internal/service/frontend/api/v2/queues.go`:
- Around line 299-353: GetQueueItemsData duplicates DAG run summary fetching and
leaves running/queued as nil slices; refactor to call the existing helper
fetchDAGRunSummary for both the running loop (currently iterating runningRefs
from procStore.ListAllAlive) and the queued loop (iterating queuedItems from
queueStore.List) to remove duplicated logic, and initialize running and queued
with make([]api.DAGRunSummary, 0) so QueueItemsResponse always marshals to empty
arrays instead of null.

In `@internal/service/frontend/sse/handler_test.go`:
- Around line 329-366: The test TestHandleSSEMaxClients uses a fixed time.Sleep
to wait for the first client to connect which can cause flakiness; replace the
sleep with a deterministic wait that polls hub.ClientCount() (or a small loop
with timeout) after starting the goroutine for handler.HandleDAGEvents so the
test proceeds only once NewHub(WithMaxClients(1)) reports the first client is
registered, then run the second request and assert StatusServiceUnavailable and
"max clients reached"; ensure you reference TestHandleSSEMaxClients,
NewHub/WithMaxClients, hub.ClientCount(), and Handler.HandleDAGEvents when
implementing the polling wait.

In `@internal/service/frontend/sse/handler.go`:
- Around line 151-154: The code sends an Event with Data built by fmt.Sprintf
containing the raw topic, which allows JSON injection if topic contains
quotes/backslashes; update the construction of the Data field in the client.Send
call inside the handler so the topic is JSON-encoded (e.g., build a small struct
or value for {"topic": topic} and json.Marshal it) before assigning to
Event.Data, ensuring Event, EventTypeConnected and the client.Send call use the
marshaled bytes or string instead of fmt.Sprintf interpolation.

In `@ui/src/features/dag-runs/components/dag-run-details/DAGRunDetailsPanel.tsx`:
- Around line 115-140: The handler handleKeyDown is hijacking browser search
because pressing Ctrl/Cmd+F still triggers handleFullscreenClick; update
handleKeyDown (or specifically the 'f'/'F' branch) to ignore the key when
event.ctrlKey or event.metaKey (or other modifiers like altKey/shiftKey if
desired) are pressed, i.e., only trigger handleFullscreenClick when no modifier
keys are active and shouldIgnoreKeyboardShortcuts() is false.

In `@ui/src/features/dags/components/dag-details/DAGDetailsPanel.tsx`:
- Around line 74-82: The current effect sets notFound for any error; change it
to only setNotFound(true) when the error represents a 404 AND there is no
existing data (i.e., when error?.status or error?.response?.status === 404
depending on your useQuery error shape), otherwise do not flip notFound and keep
lastValidData as-is (so transient/network errors won’t stop polling). Update the
useEffect that references error, data, setNotFound, and setLastValidData to
perform a 404-specific check before setting notFound and only clear notFound
(setNotFound(false) and setLastValidData(data as DAGDetailsData) ) when valid
data is present.
- Around line 84-91: When fileName changes the component resets notFound and
activeTab but does not clear the cached DAG, so lastValidData can briefly show
the previous DAG; update the existing useEffect that depends on fileName to also
clear the cached data and current run by calling setLastValidData(null) (or
undefined per codebase convention) and setCurrentRun(null/undefined) alongside
setNotFound(false) and setActiveTab('status') so the panel doesn't display stale
DAG details while a new DAG loads.
- Around line 52-72: SSE is not including the selected remote node so sseResult
targets local while polling uses remoteNode; update the DAGDetailsPanel call to
pass remoteNode into useDAGSSE and modify useDAGSSE to append remoteNode as a
query param (or otherwise route the SSE URL) so SSE and polling use the same
remoteNode; ensure the signature change to useDAGSSE accepts (fileName: string,
enabled: boolean, remoteNode?: string) (or similar) and that sseResult.data
remains compatible with existing code path that falls back to pollingData.

In `@ui/src/features/dags/components/dag-execution/StepLog.tsx`:
- Around line 247-274: The guard in handleJumpToLine wrongly returns when
cachedData?.totalLines is undefined; compute a safe total (e.g., const
totalLines = cachedData?.totalLines ?? lineCount ?? 0) and use that in the
validation instead of cachedData?.totalLines so jumpToLine, pageSize,
setCurrentPage and setViewMode still work when totalLines is missing; keep the
rest of the logic (calculating targetPage, scrolling to data-line-number, and
the highlight timeout) unchanged.
- Around line 97-105: The SSE hook call is missing the selected remote node,
causing streams to target the wrong instance; update the call to useStepLogSSE
to pass remoteNode (e.g., useStepLogSSE(dagName, dagRunId, stepName,
shouldUseSSE, remoteNode)) and then modify the useStepLogSSE implementation to
include remoteNode in the SSE endpoint construction and any reconnection/polling
logic so sseResult, sseIsActive and fallback behavior respect the selected
remoteNode.

In `@ui/src/pages/dag-runs/index.tsx`:
- Around line 414-425: SSE parameter object sseParams currently omits the remote
node, causing wrong data when a remote node is selected; update sseParams to
include remoteNode (e.g., remoteNode: apiRemoteNode || undefined) and then
update useDAGRunsListSSE and the backend endpoint builder to accept and append
remoteNode to the SSE request, or if adding the param is not supported, change
the logic around useDAGRunsListSSE/shouldUsePolling to disable SSE whenever a
remote node is selected (use apiRemoteNode to gate SSE). Ensure the same
remoteNode key is used consistently across sseParams, useDAGRunsListSSE, and the
endpoint builder.

In `@ui/src/pages/dags/index.tsx`:
- Around line 195-209: The queryParams passed to useDAGsListSSE omit remoteNode,
causing cross-node data; update the queryParams object used by useDAGsListSSE to
include remoteNode (e.g., remoteNode: remoteNode || undefined) and add
remoteNode to the React.useMemo dependency array so it regenerates correctly,
and also update the SSE endpoint builder to accept and propagate remoteNode;
alternatively, if the SSE endpoint cannot support remoteNode, modify the logic
around sseResult/usePolling so SSE is disabled for remote selections (e.g., set
usePolling = true when remoteNode is set) to ensure DAG API calls always include
the remoteNode context.