Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@internal/cmn/config/loader.go`:
- Around line 1179-1181: The code unconditionally overwrites
cfg.Bots.Telegram.InterestedEventTypes from the config value and therefore
clobbers any earlier env-derived value; change the assignment in the loader so
you only set cfg.Bots.Telegram.InterestedEventTypes from
parseInterestedEventTypes(l.v.GetString("bots.telegram.interested_event_types"))
if the config file actually provided the key and the struct does not already
contain a value from env (e.g. check
l.v.InConfig("bots.telegram.interested_event_types") or that
cfg.Bots.Telegram.InterestedEventTypes is nil/empty before assigning). Apply the
same fix pattern to the other similar blocks (the ones around the other noted
ranges) so env-over-file precedence is preserved and env can be used to clear
the list.

In `@internal/persis/fileeventstore/notifications.go`:
- Around line 91-97: The code advances the inbox cursor before ensuring
s.readInboxDAGRunEvent(name) succeeded, causing transient read/parse errors to
be permanently skipped; update the loop so that cursor.LastInboxFile is only
advanced after a successful read and processing of the DAG-run event (i.e., call
or assign to cursor.LastInboxFile after s.readInboxDAGRunEvent returns nil), and
if a read/parse error occurs do not advance the cursor — instead quarantine the
bad file (e.g., rename/move using s.inboxDir and name to a ".bad" or failed
bucket) or surface a persistent failure so it can be retried, keeping the
existing slog.Warn but removing the skip that advances the cursor on error.

In `@internal/service/chatbridge/notifications.go`:
- Around line 397-406: NotificationClassForEvent currently returns
(NotificationClassUnknown, false) for eventstore.TypeDAGRunAborted and
eventstore.TypeDAGRunRejected so those persisted notification states are never
batched/delivered; change the map for NotificationClassForEvent (the switch
handling eventstore.TypeDAGRunAborted and eventstore.TypeDAGRunRejected) to
return a valid class (e.g., NotificationClassUrgent) and true so these terminal
DAG run events are enqueued by NotificationBatcher.Enqueue and not dropped,
preventing stale pending entries; update only the return for those cases in
NotificationClassForEvent.

In `@internal/service/eventstore/notifications.go`:
- Around line 244-251: DAGRunSnapshotFromEvent currently returns the decoded
snapshot from dagRunStatusSnapshotFromData without backfilling legacy top-level
dag_file; modify DAGRunSnapshotFromEvent to call
dagRunFileNameFromData(event.Data) after decoding and, if snapshot.DAGFile is
empty and dagRunFileNameFromData returns a non-empty value, set snapshot.DAGFile
to that value before returning; apply the same backfill logic to the other
event-to-snapshot function(s) in this file (the block around lines 264-305) so
legacy events carrying notification_status + top-level dag_file populate DAGFile
for downstream consumers.

In `@internal/service/frontend/api/v1/dagruns.go`:
- Around line 2905-2911: The current error branch that always returns
fmt.Errorf("sub dag-run ID %s not found for DAG %s", parts[2], parts[0]) is
masking context timeout/cancel errors; update the handler to first detect and
preserve cancellation/timeout (use errors.Is(err, context.Canceled) and
errors.Is(err, context.DeadlineExceeded) and return err directly) and only
wrap/transform other non-nil errors into the not-found message (i.e., if the
error is not a context cancel/timeout, return the formatted not-found error);
apply this change where the lookup error is handled (the branch referencing
parts[2] and parts[0]).

In `@internal/service/frontend/server.go`:
- Line 1149: The call to StartDAGRunEventInvalidation is being started even when
no wake source is configured (event_store.enabled false), which leaves topics
without invalidation or polling; guard the call by checking the configured wake
source / event service before starting it (e.g., verify srv.eventService is
non-nil or the event_store.enabled config flag is true) and only invoke
sse.StartDAGRunEventInvalidation(srv.sseMultiplexer.Context(), srv.eventService,
srv.sseMultiplexer, slog.Default(), time.Second) when that check passes; apply
the same guard to the other similar starts in the surrounding block (the calls
around the StartDAGRunEventInvalidation region) so topics are not switched to
on-demand mode when no wake source exists.

In `@ui/src/features/dag-runs/hooks/__tests__/useBoundedDAGRunDetails.test.tsx`:
- Around line 1-3: The new test file that imports useBoundedDAGRunDetails is
missing the repository's GPL v3 license header; add the standard GPL header to
this source file by running the repository's license tool (run make addlicense)
or manually insert the project's GPL v3 header at the top of the file so the
test file that imports useBoundedDAGRunDetails includes the required license
notice.

In `@ui/src/features/dag-runs/hooks/dagRunPagination.ts`:
- Around line 77-80: The hook fetchAllDAGRuns (and the other API-call sites
noted around lines 90-95 and 333-343) must ensure a remoteNode is always present
on requests: derive the correct remoteNode inside the hook (e.g., from the
client, context, or a helper that returns current remoteNode) and merge it into
the outgoing query object before calling the API so you never forward the
caller's raw query; update fetchAllDAGRuns to create a new params object = {
...query, remoteNode: derivedRemoteNode } (and do the same at the other
referenced call sites) so every /dag-runs request includes remoteNode per the
ui/* coding guideline.

In `@ui/src/features/dag-runs/hooks/useBoundedDAGRunDetails.ts`:
- Around line 55-65: The SSE subscriptions are missing the remote node routing
so pass target?.remoteNode into both useDAGRunSSE and useSubDAGRunSSE calls;
update the calls to include the remoteNode argument (e.g.,
useDAGRunSSE(target?.name ?? '', target?.dagRunId ?? '', enabled && target !=
null && !isSubDAGRunTarget, target?.remoteNode) and similarly for
useSubDAGRunSSE with target?.parentName, target?.parentDAGRunId,
target?.subDAGRunId, the same enabled condition, and target?.remoteNode) so the
stream is correctly scoped to the selected remote node.

In `@ui/src/hooks/useSubDAGRunSSE.ts`:
- Around line 1-3: Add the GPL v3 license header block to the top of the new
TypeScript source file useSubDAGRunSSE.ts (the file that imports "components"
and imports SSEState and useSSE) so it conforms with the repository policy for
"*.{go,ts,tsx,js}" files; insert the standard GPL v3 header comment as used by
make addlicense above the existing imports (before the lines referencing
components, SSEState, and useSSE).
- Around line 16-19: The SSE endpoint string in useSubDAGRunSSE (the endpoint
constant passed to useSSE<SubDAGRunSSEResponse>) is missing the remoteNode
parameter; update the endpoint construction to include remoteNode (from the hook
args or scope) either as part of the path or as a query parameter so the request
is routed to the correct node in multi-node deployments—ensure you reference the
existing variables name, dagRunId, subDAGRunId and add remoteNode into the
encoded URL before calling useSSE.

In `@ui/src/pages/dag-runs/index.tsx`:
- Around line 98-120: The auto-pagination can become permanently unreachable
after a transient failure or when IntersectionObserver is unavailable; update
the code so there is always a manual recovery path: restore an explicit control
that calls handleLoadMore (e.g., render a "Load more" button that invokes
handleLoadMore) and ensure useAutoLoadMore (the hook taking sentinelRef,
enabled, onLoadMore) does not permanently disable loading on
loadMoreError—either accept a separate flag (e.g., forceManualFallback) or
change the enabled logic so loadMoreError only stops automatic retries but still
allows manual handleLoadMore invocations; also keep the IntersectionObserver
feature-dallback: when IntersectionObserver is undefined, render the manual
"Load more" control so remaining pages remain reachable.

---

Outside diff comments:
In `@internal/service/frontend/sse/types.go`:
- Around line 55-80: The bug is that list/query-backed topics (TopicTypeDAGRuns,
TopicTypeQueues, TopicTypeDAGsList, TopicTypeDocTree) are built using a
sanitized query string that currently strips out remoteNode, causing different
remote nodes to collapse into one multiplexed topic; preserve the remoteNode
parameter instead of deleting it when building the topic key (i.e., stop
removing remoteNode in the code that sanitizes/normalizes the query before
constructing the topic identifier) so the final topic key for those types
includes remoteNode and multi-node routing remains correct.

In `@ui/src/hooks/SSEManager.ts`:
- Around line 1-8: Add the GPL v3 license header to this TypeScript source
(ui/src/hooks/SSEManager.ts) at the top of the file so it matches the project's
required header for **/*.{go,ts,tsx,js}; you can do this manually or run the
repository tool to apply it consistently: ensure the header precedes the
existing imports (e.g., before getAuthHeaders/getAuthToken) and then run make
addlicense to verify/apply the standard GPL v3 header across the file.