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

Inline comments:
In `@internal/service/frontend/sse/app_stream.go`:
- Around line 316-323: Compare normalized/cleaned paths when deciding the
createRoot boolean: call the same normalization used by uniqueNonEmptyPaths on
cfg.Paths.DAGsDir (e.g., filepath.Clean/absolute equivalent) and compare that
cleaned value to dagRoot (which is already cleaned) before passing the boolean
to newRecursiveWatcher; apply the same fix for the second occurrence around the
other watcher creation (lines 348-360) so createRoot is true when the logical
primary DAGsDir matches regardless of trailing slashes or relative paths.
- Around line 260-263: The code in the fsnotify Create handling and in the
directory traversal swallows errors from w.addDirRecursive (and the
filepath.Walk used inside it), leaving subtrees unwatched; modify the Create
branch to check and propagate the error from w.addDirRecursive (e.g., if err :=
w.addDirRecursive(event.Name); err != nil { return err } or send the error to
the component's existing reset/error channel) and likewise update the traversal
logic inside addDirRecursive (or the filepath.Walk callback) to return any walk
errors instead of discarding them so callers can detect and handle
watch-registration failures.

In `@ui/src/features/cockpit/components/TemplateSelector.tsx`:
- Around line 104-116: The effect in TemplateSelector.tsx clears selectedDag
whenever the dropdown is closed because it returns early on !isOpen and also
clears selectedDag when selectedTemplate exists but the menu is closed, causing
the label to disappear; update the useEffect that references
selectedTemplate/filteredDags/isOpen so it only sets selectedDag(null) when
selectedTemplate is falsy and always tries to find and set the matching dag from
filteredDags (i.e., remove the early return on isOpen), and apply the same
change to the similar effect around lines 163-171 so the preselected
selectedTemplate keeps its label even when the dropdown is closed (refer to
selectedDag, selectedTemplate, filteredDags, isOpen in the effect).

In `@ui/src/features/cockpit/hooks/useCockpitState.ts`:
- Around line 60-70: The POST call to create a workspace using client.POST
currently swallows failures; update the createWorkspace flow to surface failures
by handling the returned error: when client.POST('/workspaces', ...) returns an
error, log it (e.g., via console.error or an existing logger), and either return
the error to callers or set a local error state so the UI can display it; keep
the existing success path that calls applyWorkspaces(...) and
selectWorkspace(...), but ensure the error branch does not silently
no-op—propagate or persist the error for user feedback.

In
`@ui/src/features/dag-runs/components/dag-run-details/__tests__/DAGRunDetailsPanel.test.tsx`:
- Around line 1-8: Add the required GPL v3 license header to the top of this
test file (DAGRunDetailsPanel.test.tsx) above the imports: include the standard
GPL v3 notice (or SPDX identifier such as "SPDX-License-Identifier:
GPL-3.0-or-later") plus the copyright/owner line used across the repo so the
file legally matches other sources; ensure the header sits before any code
(imports like React, render, MemoryRouter, etc.) so linters and tooling
recognize it.

In `@ui/src/features/dag-runs/components/dag-run-details/DAGRunDetailsModal.tsx`:
- Around line 73-75: The current gate makes dagRunQueryEnabled require a truthy
dagRunId, but the code later intentionally falls back to 'latest', so change the
condition for dagRunQueryEnabled to allow queries when name is present even if
dagRunId is empty (i.e., use isOpen && !canQuerySubDag && Boolean(name) instead
of requiring dagRunId); apply the same fix to the other occurrence around the
second block (the lines referenced 95-100) so both checks permit the 'latest'
fallback to run.

In
`@ui/src/features/dags/components/chat-history/__tests__/StepMessagesTable.test.tsx`:
- Around line 1-6: This new test file (StepMessagesTable.test.tsx) is missing
the required GPL v3 license header; add the standard GPL v3 license header to
the top of the file (above the imports) either by running the repository helper
(make addlicense) or by inserting the project’s canonical GPL v3 header manually
so the file header matches other source files and CI checks; ensure the header
is placed before the existing imports and saved.

In `@ui/src/hooks/AppLiveManager.ts`:
- Line 1: This new file AppLiveManager.ts is missing the project's required GPL
v3 license header; add the standard GPL header to the top of AppLiveManager.ts
(the file that currently imports getAuthToken) and then run the repository task
to apply/verify headers by executing make addlicense before merging so the file
conforms to the **/*.{go,ts,tsx,js} GPL header policy.

In `@ui/src/hooks/useAppLive.ts`:
- Line 1: This new file (useAppLive.ts — seen by the import line "import {
useContext, useEffect, useRef, useState } from 'react';") is missing the
required GPL v3 license header; run the repository's license tool (make
addlicense) in the ui/src directory (or project root as configured) to insert
the standard GPL header for TypeScript files, then recommit the updated file so
it conforms to the coding guideline for **/*.{go,ts,tsx,js}.

In `@ui/test-results/.last-run.json`:
- Around line 1-6: The committed JSON contains transient test-run state keys
"status" and "failedTests" and should not be versioned; remove the file from the
PR (delete the committed .last-run.json), add an ignore rule to your repo's
.gitignore to exclude the test-results/.last-run.json pattern (or the
test-results directory’s transient artifacts), and if you need a deterministic
example add a checked-in fixture file under a clearly named fixtures path
instead of this runtime output.

In
`@ui/test-results/dagu-cockpit-autoupdate-ch-dc750--run-without-manual-refresh/error-context.md`:
- Around line 1-154: Delete the committed run-specific artifact
ui/test-results/dagu-cockpit-autoupdate-ch-dc750--run-without-manual-refresh/error-context.md
from the repo and add a rule for ui/test-results/ to .gitignore so future
transient test outputs aren’t tracked; remove the file from version control
(ensure it’s deleted/unstaged from the index) and commit the updated .gitignore
and deletion together, and verify no source or tests reference error-context.md
before pushing.

---

Nitpick comments:
In `@internal/service/frontend/sse/app_stream_test.go`:
- Around line 37-56: Add an inline comment to each idempotency test clarifying
that the test asserts "no panic" by invoking the method twice: in
TestRecursiveWatcherStopIsIdempotent, above the two watcher.Stop() calls note
that the test ensures recursiveWatcher.Stop() is safe to call multiple times (no
panic); and in TestAppStreamServiceShutdownIsIdempotent, add a similar comment
above the two service.Shutdown() calls stating the test verifies
AppStreamService.Shutdown() is idempotent (no panic) so readers understand the
implicit assertion.
- Around line 13-35: Replace manual t.Fatalf checks in TestWriteAppEventFrame
with stretchr/testify assertions: import "github.com/stretchr/testify/require"
(or "assert"), call require.NoError(t, err) after writeAppEventFrame, and use
require.Contains(t, body, "event: dag.changed\n"), require.Contains(t, body,
`"fileName":"example.yaml"`), and require.Contains(t, body,
`"reason":"updated"`) instead of the three if/ t.Fatalf blocks; update the test
file imports accordingly and remove the now-unnecessary t.Fatalf branches in
TestWriteAppEventFrame.

In `@ui/src/features/cockpit/components/DateKanbanSection.tsx`:
- Around line 42-55: The component is using a loose inline cast for error;
update the hook useDateKanbanData to return a properly typed error (e.g., Error
| null) and then remove the cast in DateKanbanSection.tsx—use the typed error
directly (e.g., error?.message || 'Failed to load runs') and keep the existing
retry() call intact; ensure any callers and types for useDateKanbanData, and the
component's props/state that consume it, are updated to reflect Error | null so
the runtime check is safe and no inline assertion like (error as { message?:
string } | undefined) is needed.

In `@ui/src/features/cockpit/hooks/useCockpitState.ts`:
- Around line 88-91: The return value always sets workspaceError to null,
removing upstream error visibility; update useCockpitState to return the actual
error from the workspace query (e.g., replace workspaceError: null with
workspaceError: workspacesQuery.error or whatever error variable the fetch hook
exposes) so consumers (that read workspaces, selectedWorkspace) can render API
errors; locate the error coming from the workspace fetch hook used in
useCockpitState and pass it through as workspaceError.

In `@ui/src/features/dag-runs/components/dag-run-details/DAGRunDetailsPanel.tsx`:
- Around line 40-48: The ternary in liveEnabled redundantly re-checks the same
condition encapsulated by isSubDAGRun; replace the ternary with a simple boolean
expression: set liveEnabled = isSubDAGRun || Boolean(name && dagRunId) so
sub-DAG runs use isSubDAGRun directly and non-sub-DAG runs still check name +
dagRunId, leaving useLiveConnection(liveEnabled) unchanged.

In `@ui/src/hooks/AppLiveManager.ts`:
- Around line 293-312: notifySubscribers and updateState currently call
subscriber callbacks inline so one subscriber throwing aborts delivery to
others; wrap each call to subscriber.onInvalidate(event) in notifySubscribers
and subscriber.onStateChange(conn.state) in updateState with a try/catch to
isolate exceptions, handle/log the error (using existing logger or console) and
continue iterating so one bad subscriber cannot break the fan-out.