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

Inline comments:
In `@internal/agent/api.go`:
- Around line 855-869: The current StreamResponse assembly reads multiple
SessionManager accessors (GetMessages, GetSession, IsWorking, HasPendingPrompt,
GetModel, GetTotalCost, GetDelegates) separately which can observe torn state;
add a single locked snapshot helper on SessionManager (e.g., Snapshot() or
GetLockedState()) that acquires the manager's mutex and returns a struct
containing Messages, Session, Working, HasPendingPrompt, Model, TotalCost,
Delegates atomically, then replace the field-by-field reads in the handler
(where sessions.Load and the StreamResponse/SessionState are built) with a
single call to that snapshot and map its fields into
StreamResponse/SessionState.
- Around line 847-849: AuthorizeSessionAccess currently calls
getUserIDFromContext (which may fallback to "admin") and then GetSessionDetail
(which loads full messages/delegates); change it to explicitly resolve the
principal from ctx without the admin fallback (or only allow the fallback when
auth is globally disabled) and perform a lightweight metadata-only session
existence/ownership check instead of calling GetSessionDetail—use the session
metadata accessor (or add one) to verify session existence and owner matches the
resolved user ID before returning.
- Around line 877-886: The code masks storage errors by turning any
a.store.GetSession error into ErrSessionNotFound and by swallowing
a.store.GetMessages errors (setting messages = []Message{}); change both to
propagate the original store error to the caller instead: return the error from
GetSession directly (do not map all errors to ErrSessionNotFound unless sess ==
nil with nil error) and on GetMessages return the err instead of substituting an
empty slice (remove the a.logger-only swallow path). Update callers to handle
these storage errors/retries as needed; use the existing symbols
a.store.GetSession, a.store.GetMessages, ErrSessionNotFound, and messages to
locate and fix the logic.

In `@internal/service/frontend/sse/multiplex_handler.go`:
- Around line 66-70: The bootstrapTopics call is currently executed after
writeControl/Serve which makes the new subscription state visible before the
snapshot enqueue and allows a race where a concurrent unsubscribe removes topics
but the snapshot still enqueues stale events; to fix, serialize snapshot
bootstrap with the session-scoped mutation by moving the call to
session.bootstrapTopics into the same critical section where
result.session.writeControl (and any session subscription state mutations) occur
so the enqueue happens atomically with the subscription change, or alternatively
add a check in the snapshot-enqueue path to drop topics that are no longer
attached (i.e., make the session's snapshot enqueue/append reject topics absent
from the current subscription set in Session). Ensure you update both code paths
that call bootstrapTopics (the one using
result.session.writeControl/result.session.Serve and the other mirror path) and
reference the Session methods writeControl, bootstrapTopics, Serve and the
session snapshot enqueue/append logic when making the change.
- Around line 117-130: The proxy only forwards query params so clients sending
Last-Event-ID via header are treated as new streams; update the multiplex
handler code that constructs the proxied HTTP requests to copy the incoming
request's "Last-Event-ID" header into the outbound request's headers (e.g., when
you create the outgoing *http.Request* for the remote stream). Ensure this
header copy is done in both places noted (the place that builds the proxied
request around parseLastEventID and the second occurrence referenced in the
review), and keep using parseLastEventID as-is to read either query or header on
the local side.

In `@internal/service/frontend/sse/multiplex.go`:
- Around line 411-427: getOrCreateTopicForMutation can return a topic that's
being retired by unsubscribeTopic, causing stop() to close stopCh on a
still-in-use object; fix by making topic lifecycle changes atomic: add a
lifecycle flag on multiplexTopic (e.g., stopped/shuttingDown) and update
getOrCreateTopicForMutation to check that flag under m.mu and treat a stopped
topic as non-existent (create a new one instead); change unsubscribeTopic to
mark the topic as shuttingDown and remove it from m.topics while holding m.mu,
then release the lock and call topic.stop() (closing stopCh) once — this ensures
lookups never get a topic that is mid-retire and prevents closing stopCh on a
live topic (refer to getOrCreateTopicForMutation, unsubscribeTopic,
multiplexTopic.sessionCount, multiplexTopic.stop, stopCh, and m.topics).
- Around line 256-367: The mutation logic in applyMutation must be serialized
with session teardown to avoid races; add a session-scoped mutex (e.g.,
mutationMu on streamSession) and acquire it at the start of applyMutation and in
removeSession (and the other mutation path noted at 457-476) to serialize checks
and membership updates (currentSet/finalCount, calls to
addTopic/removeTopic/removeSession). Hold the lock while re-checking
session.isClosed and while performing unsubscribeTopic/addTopic/topic.addSession
and any adjustments to topic membership, using defer to unlock; keep
resolveTopicsForMutation outside the lock but ensure createdTopics cleanup and
the final membership changes happen under the session lock so no concurrent
mutation or teardown can violate maxTopicsPerConn or leave topics attached to
closed sessions.

In `@internal/service/frontend/sse/proxy.go`:
- Around line 117-118: The TopicTypeAgent branch currently concatenates the raw
identifier into the path (case TopicTypeAgent -> return "/agent/sessions/" +
identifier + "/stream"), which allows reserved characters to alter path/query;
change this to treat the identifier as a single path segment by applying
url.PathEscape(identifier) when building the string (and add the net/url
import), so identifiers like "a/b" or "sess-1?x=y" are percent-escaped rather
than injected into the path or query.

In `@internal/service/frontend/sse/topic_parse.go`:
- Around line 52-68: The current branches for
TopicTypeDAGRuns/TopicTypeQueues/TopicTypeDAGsList/TopicTypeDocTree and
TopicTypeDAGRunLogs treat sanitizeQueryForTopic(...) == "" as success but
sanitizeQueryForTopic also returns "" on parse failure, which widens
subscriptions; change sanitizeQueryForTopic to return (string, error) or add a
new parseAndSanitizeQuery(identifier string) (string, error) helper that
distinguishes an empty-but-valid query from a parse error, then update the
branches in topic_parse.go (the cases handling TopicTypeDAGRuns,
TopicTypeQueues, TopicTypeDAGsList, TopicTypeDocTree and TopicTypeDAGRunLogs) to
call the new helper and return/propagate an error when parsing fails instead of
accepting "" as success; add a regression test that asserts malformed queries
like "%ZZ" cause the topic parsing to return an error rather than canonicalizing
to a broader subscription.

In `@internal/service/frontend/sse/types.go`:
- Around line 69-72: The Deprecation header in SetLegacyStreamDeprecationHeaders
is not RFC 9745 compliant (currently "true"); replace it with a Structured Field
Date value of the form "@<unix-seconds>" instead. In
SetLegacyStreamDeprecationHeaders, compute the deprecation instant as a Unix
timestamp (e.g., the deprecation moment or time.Now().Unix() / or derive from
legacyStreamSunset if that represents the instant), then set
w.Header().Set("Deprecation", fmt.Sprintf("@%d", ts)) while keeping the existing
Sunset header write for legacyStreamSunset.

In `@ui/src/features/agent/hooks/useAgentChat.ts`:
- Around line 260-275: The onPreConnect currently calls resetDelegates (passed
into useSSEConnection) which wipes delegates that
selectSession()/restoreDelegates just restored; remove the unconditional
resetDelegates from the onPreConnect arg and instead call resetDelegates only
from explicit paths that clear or start a brand-new session (e.g., the handler
that clears session or the new-session startup flow), or wrap onPreConnect with
a conditional that checks a "delegatesPreloaded" / "hasRestoredDelegates" flag
(set by restoreDelegates/selectSession) and only runs resetDelegates when that
flag is false; update useSSEConnection invocation to use the new conditional
wrapper or remove the call and place resetDelegates calls into the explicit
clear/start handlers.
- Around line 291-320: pollFallbackSnapshots can overlap because setInterval
fires regardless of in-flight work; add a single-run guard so only one poll runs
at a time and ensure timers are cancelled on cleanup. Implement either: (a) an
inFlight boolean (e.g., isPolling) checked at the top of pollFallbackSnapshots,
set true before doing fetchSessionDetail/fetchSessionDetail for delegateIds and
set false in a finally block so applySessionSnapshot/applyDelegateSnapshot are
only called from the active runner, or (b) replace setInterval(timer) with a
recursive setTimeout that schedules the next run only after the current run
completes; in both cases ensure you clear the timer and set active = false on
unmount/cleanup so no stray polls run.

In `@ui/src/hooks/SSEManager.ts`:
- Around line 216-225: The code replays the connection state to a new topic
immediately (topicEntry.subscribers.set(...);
callbacks.onStateChange(conn.state)) before the topic is moved from pendingAdd
into serverTopics, causing delegate panes to treat it as live; change this so
you emit topic-level state based on whether serverTopics.has(topic) or the
pendingAdd flag (i.e., report a pending/not-connected state instead of
conn.state for fresh topics) and defer flipping the topic to connected until
handleTopicAdded confirms the server subscription (or until the control/mutation
ack arrives); update the logic around topicEntry, callbacks.onStateChange,
handleTopicAdded and ensureConnected so handleTopicAdded performs the final
callbacks.onStateChange(connected) when the topic is actually moved into
serverTopics.

---

Nitpick comments:
In `@internal/cmn/config/config.go`:
- Around line 462-476: Validation currently allows zero for all SSE fields;
update the checks so HeartbeatInterval cannot be zero by changing the guard on
c.Server.SSE.HeartbeatInterval to reject <= 0 and return a clear error (e.g.,
"sse.heartbeat_interval must be > 0"); decide whether to treat
c.Server.SSE.MaxTopicsPerConnection and c.Server.SSE.MaxClients as > 0 as well
(if so, change their checks from < 0 to <= 0 and adjust error messages). Ensure
you reference the defaulting behavior in loader.go when making this change so
you don't break intended defaults.