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

Inline comments:
In `@internal/agent/api.go`:
- Around line 553-556: The struct is initializing LastActivity from persisted
sess.UpdatedAt which lets reactivated sessions appear idle and be evicted;
change the runtime initialization to set LastActivity to the current time (e.g.,
time.Now()) when creating/reactivating the session instead of sess.UpdatedAt so
reactivated sessions start with fresh activity. Update the initializer that sets
LastActivity (near Title/CreatedAt/OnMessage and the createMessageCallback(id)
usage) to use the current timestamp when bringing a session back into an active
manager.

In `@ui/src/hooks/SSEManager.ts`:
- Around line 589-595: The stale-check currently performed using conn.sessionId
!== mutationSessionId || conn.eventSource !== mutationEventSource happens before
awaiting response.json(), so if a reconnect occurs during parsing the old
mutation may still be applied; after awaiting response.json() (the JSON parse of
the SSE message) re-run the same staleness check (comparing conn.sessionId and
conn.eventSource to mutationSessionId/mutationEventSource) and bail out if stale
before mutating connection state in the code that updates the connection (the
mutation block that follows the parse). Ensure you apply this same re-check
pattern for the other similar section that handles parsed messages (the earlier
block around the other response.json() usage) so no stale subscription state is
applied after async parsing.

---

Nitpick comments:
In `@ui/src/features/agent/hooks/__tests__/useSSEConnection.test.tsx`:
- Around line 5-52: The MockEventSource class used in tests lacks a
removeEventListener method which will cause failures if the hook calls it during
cleanup or reconnection; add a removeEventListener(type: string, listener:
(event: MessageEvent<string>) => void) that looks up the Set in the private
listeners map and removes the provided listener (and deletes the Set if empty),
ensuring behavior mirrors addEventListener and preventing thrown errors when
useSSEConnection or tests call removeEventListener on MockEventSource.

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

Inline comments:
In `@internal/agent/session.go`:
- Around line 128-150: The reconstructed totalCost ignores costs stored on
reactivated delegates, so reactivateSession/SessionManagerConfig.Delegates leads
to an underreported total; update the totalCost reconstruction loop to also sum
any per-delegate restored costs by iterating cfg.Delegates (the DelegateSnapshot
entries) and adding their Cost/Cost pointer values (e.g., delegateSnapshot.Cost)
to totalCost (guarding nil pointers) in addition to the existing loop over
messages, ensuring you reference cfg.Delegates, DelegateSnapshot, and totalCost
so the restored delegate costs are included.

In `@internal/service/frontend/sse/types.go`:
- Around line 125-127: The current code truncates the encoded query (result :=
values.Encode()) to maxQueryLength, which mutates the topic identifier and can
collapse distinct filter sets; instead detect when len(result) > maxQueryLength
and return an explicit error (e.g., ErrQueryTooLong) rather than slicing; update
the function that builds topic IDs (the block using values.Encode(), result and
maxQueryLength) to validate length and propagate the error so callers can reject
or handle overly long queries without changing identifiers.
- Around line 95-99: The current loop drains the entire upstream body with
io.Copy(io.Discard, body) when a downstream write fails, but body can be a
long-lived SSE stream and blocking on that drain will leak the goroutine and
connection; instead, on writeErr stop attempting to drain and cleanly terminate
the upstream stream by closing it (if it implements io.Closer) and/or cancelling
the upstream request context, then return. Locate the code using variables body,
w, buf (in the read/write loop) and replace the io.Copy(io.Discard, body) call
with a safe shutdown: if body implements io.Closer call body.Close(), otherwise
invoke the upstream request cancel function (or close the transport) so the
upstream connection is released, then return immediately. Ensure no blocking
draining is performed.

In `@ui/src/features/agent/components/CommandApprovalMessage.tsx`:
- Around line 1-2: The file CommandApprovalMessage.tsx is missing the required
GPL v3 license header; add the repository's standard GPL v3 header to the very
top of the file (above the existing import lines) — either run the repo license
tooling (e.g., make addlicense) to apply the header automatically or paste the
canonical GPL v3 header used across the project into CommandApprovalMessage.tsx
before the imports (ensure it matches other .tsx files and the project's license
template).

In `@ui/src/features/agent/hooks/useAgentChat.ts`:
- Around line 251-258: The current applySessionSnapshot callback treats any
historical user message as an ACK because it uses nextMessages.some(msg =>
msg.type === 'user'); change this to detect acknowledgement of the specific
pendingUserMessage instead: when pendingUserMessage exists, look for a message
in snapshot.messages that matches that pendingUserMessage's unique identifier
(e.g. pendingUserMessage.id, client_id, or a dedicated echo/client token) or, if
none exists, a robust match on content+timestamp, and only then call
setPendingUserMessage(null). Update the condition in applySessionSnapshot to
compare message.id or message.client_id (or the chosen unique field) against
pendingUserMessage's identifier rather than just message.type.

In `@ui/src/features/agent/hooks/useSSEConnection.ts`:
- Around line 12-33: The exported useSSEConnection currently returns a stub and
ignores its inputs (sessionId, remoteNode, SSECallbacks) which disables agent
streaming; fix by wiring this hook to the agent stream endpoint or removing it
entirely: if you want streaming, inside useSSEConnection use sessionId and
remoteNode to build the EventSource URL (/api/v1/agent/sessions/{id}/stream),
create an EventSource when sessionId is non-null, attach handlers to call the
provided SSECallbacks (onMessage/onOpen/onError as appropriate), update and
return AgentSSEStatus.isSessionLive = true while open, and ensure you close the
EventSource on parameter change/unmount to avoid leaks; if polling-only is
intentional, remove the useSSEConnection export and any callers instead of
leaving a no-op stub.

In `@ui/src/features/cockpit/components/TemplateSelector.tsx`:
- Around line 31-32: The write to hasOpenedRef currently happens during render
(hasOpenedRef.current = true when isOpen), which violates React render purity;
remove that mutation from the render path in TemplateSelector and instead set
hasOpenedRef.current = true inside the handler that opens the selector (e.g.,
handleOpen) at the moment you actually transition to open; ensure handleOpen is
the function invoked by the open trigger and that it performs the ref write
before any side effects that unpause queries, leaving the ref read-only during
render.

In `@ui/src/features/cockpit/hooks/useCockpitDagRuns.ts`:
- Around line 134-137: The loop currently drops any DAGRunSummary with no
startedAt (in useCockpitDagRuns.ts where it checks run.startedAt and does `if
(!startedAt) continue;` before `dayjs(startedAt).unix()`), which removes
queued/not-started runs; instead, when startedAt is missing, compute the bucket
timestamp using the same date field the backend uses for /dag-runs range
filtering (e.g., the DAG run's backend date field such as
logicalDate/executionDate or the configured dagRuns range date field) and use
that value for `dayjs(...).unix()` so Status.Queued and Status.NotStarted runs
are included in the correct day bucket rather than being skipped.
- Around line 1-9: Add the project's GPL v3 license header to the top of the new
source file useCockpitDagRuns.ts: insert the standard multi-line GPL banner (as
used elsewhere in the repo and added by make addlicense) before the import
statements so the file complies with the repository's licensing guidelines and
CI checks; you can run or emulate make addlicense to obtain the exact header and
place it above the first import in useCockpitDagRuns.ts.
- Around line 153-159: The hook currently returns a global isLoading = !data
which causes all DateKanbanSection components to show loading when the query key
(e.g., loadedDates) expands; change this so existing boards remain visible by
either enabling keepPreviousData on the useQuery that loads columns (so data
stays available while refetching) or by exposing a per-date loading indicator
(add a getIsLoadingForDate(date) that returns true only if the date is part of
the newly requested range and columnsByDate.has(date) is false). Update the hook
return to include getIsLoadingForDate (or replace isLoading) and reference
getColumnsForDate, columnsByDate and loadedDates when computing per-date loading
state so only newly requested days show placeholders.

---

Outside diff comments:
In `@ui/src/features/agent/components/CommandApprovalMessage.tsx`:
- Around line 8-41: The onRespond type is declared as returning void but the
real callback (respondToPrompt in useAgentChat.ts) is async; change the
CommandApprovalMessageProps onRespond signature to return Promise<void>, then
make handleApprove and handleReject async, await onRespond calls and wrap them
in try/finally so setIsSubmitting(true) is paired with setIsSubmitting(false)
even on error; update references to prompt.prompt_id and selected_option_ids as
before and ensure the handlers still pass the displayValue strings
('Approved'/'Rejected').

In `@ui/src/features/agent/components/UserPromptMessage.tsx`:
- Around line 66-94: handleSubmit and handleSkip call setIsSubmitting(true) but
never reset it, so if onRespond throws or rejects the buttons remain disabled;
update both handleSubmit and handleSkip to handle synchronous exceptions and
Promise rejections from onRespond and always call setIsSubmitting(false) in a
finally branch (or in .catch/.finally) after onRespond completes/fails.
Specifically, wrap the onRespond call inside handleSubmit and handleSkip with
try/catch/finally (or use Promise.resolve(onRespond(...)).finally(...)) so that
setIsSubmitting(false) is executed on error or success while preserving existing
response construction logic that uses selectedOptions and freeText. Ensure the
identifiers handleSubmit, handleSkip, setIsSubmitting, and onRespond are the
ones updated.

---

Duplicate comments:
In `@internal/agent/api.go`:
- Around line 616-624: The session manager is being initialized with
LastActivity set to the stored sess.UpdatedAt, which causes reactivated sessions
to appear idle and be evicted immediately; update the SessionManagerConfig
passed to NewSessionManager so LastActivity is set to the current time (e.g.,
time.Now()) when creating a manager for a reactivated or attached session
instead of using sess.UpdatedAt (refer to NewSessionManager,
SessionManagerConfig, LastActivity, and sess.UpdatedAt).

In `@ui/src/hooks/SSEManager.ts`:
- Around line 596-603: The pre-parse stale check using conn.sessionId !==
mutationSessionId || conn.eventSource !== mutationEventSource can be bypassed if
a reconnect occurs before awaiting response.json(); re-check staleness
immediately after parsing the JSON (right after const body = (await
response.json())) and before any mutation of connection state (the block that
tests 'subscribed' in body and subsequent calls that mutate conn). Specifically,
re-evaluate the same condition (using conn.sessionId, mutationSessionId,
conn.eventSource, mutationEventSource) and return early if stale to prevent
overwriting the current session state.

---

Nitpick comments:
In `@ui/src/features/agent/components/CommandApprovalMessage.tsx`:
- Around line 108-117: The approve/reject UI uses a shared isSubmitting flag
causing both buttons to show "Sending..."; modify the CommandApprovalMessage
component to track a pending action (e.g., pendingAction: 'approve' | 'reject' |
null) instead of only isSubmitting, set pendingAction = 'approve' in the approve
handler and 'reject' in handleReject, update the Approve button to show its
loader/text when pendingAction === 'approve' and the Reject button when
pendingAction === 'reject', keep disabling logic using pendingAction !== null,
and clear pendingAction (and isSubmitting if still used) in the success/finally
paths so only the clicked button shows the pending state.