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

Inline comments:
In `@internal/cmd/dequeue.go`:
- Around line 63-75: The current peek via QueueStore.ListPaginated leaves a bad
head item in place so dequeueFirst can get stuck; change the logic to perform a
destructive pop of the head instead of peeking (or, if you prefer, explicitly
remove/skipping bad heads): replace the ListPaginated usage with the QueueStore
pop/remove method (or call QueueStore.Delete on the head item) so that if
result.Items[0].Data() fails or dequeueQueuedDAGRun(...) returns a
skippable/stale error you delete the head and loop to the next item; ensure you
reference the same queueName and use dequeueQueuedDAGRun(ctx, queueName, *data)
only after successful pop and parsing so bad/stale heads are removed rather than
blocking subsequent calls.
- Line 50: The code must resolve the DAG run's actual queue before attempting
targeted dequeues: call queueNameForDAGRun(ctx, dagRun) to obtain
actualQueueName and pass that into dequeueQueuedDAGRun(ctx, actualQueueName,
dagRun) instead of the caller-supplied queueName; also update the error handling
around exec.ErrQueueItemNotFound (the block handling dequeue failures) so that
ErrQueueItemNotFound is not treated as success when the resolved queue differs —
if dequeue on the resolved queue returns ErrQueueItemNotFound, surface an
error/handle it appropriately rather than logging success.

In `@internal/cmd/retry.go`:
- Around line 112-115: When queueDispatchRetryRequested() is true, map store
read errors (exec.ErrDAGRunIDNotFound and exec.ErrNoStatusData) from the initial
lookup (e.g., findRetryAttempt and ReadStatus) into a &exec.DAGRunNotQueuedError
instead of letting the raw errors bubble; detect these errors after calling
findRetryAttempt/ReadStatus and return an exec.DAGRunNotQueuedError with
HasStatus=false (or appropriate flag for "no status") so cleared targets are
treated as benign stale-dispatches, and apply the same normalization to the
other similar block around findRetryAttempt/ReadStatus later in the file (the
region mentioned for lines ~217-240).

In `@ui/src/features/queues/components/QueueCard.tsx`:
- Around line 106-107: The onQueueCleared prop is awaited in QueueCard (await
onQueueCleared()) but is currently typed as () => void; update the prop type to
allow async functions by changing the signature to () => void | Promise<void> in
both QueueCardProps and QueueListProps so it can accept callers like the async
handleRefresh(): Promise<void> used by the queues page; ensure any other
usages/consumers of onQueueCleared are compatible with the widened type.

---

Outside diff comments:
In `@ui/src/features/queues/components/QueueCard.tsx`:
- Around line 1-7: This file (QueueCard.tsx / component QueueCard) is missing
the required GPL v3 license header; run the project's license tooling or add the
standard GPL v3 header used across the repo to the top of the file. Either run
the provided make target (make addlicense) to automatically insert the correct
header, or manually add the project's canonical GPL v3 header comment block at
the very top of QueueCard.tsx before any imports so the file complies with the
repository's /* .ts/.tsx */ license policy.

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

Inline comments:
In `@api/v1/api.yaml`:
- Around line 3172-3207: The change repurposes the existing /queues/{name}/items
endpoint and operationId listQueueItems to a queued-only cursor pagination
format, which breaks existing clients; restore backward compatibility by either
creating a new endpoint/operationId (e.g., /queues/{name}/backlog or a new
operationId) for the backlog/queued-only cursor API or revert the updated
contract for /queues/{name}/items so it continues to return the prior
page/cursor schema (QueuedDAGRunsPageResponse) until consumers migrate; apply
the same approach to the other affected occurrences referenced (lines around the
other two locations) so you do not change the existing path or operationId
in-place.

In `@internal/cmd/dequeue.go`:
- Around line 117-135: queueNameForDAGRun currently returns early on
ErrDAGRunIDNotFound or ErrNoStatusData which prevents removing orphaned queue
items; change the error handling so that if queueNameForDAGRun(ctx, dagRun)
returns ErrDAGRunIDNotFound or ErrNoStatusData you set actualQueueName =
requestedQueueName and continue (rather than returning
mapAbortQueuedDAGRunError), otherwise keep the existing return behavior; then
proceed to call withQueueProcLock(ctx, actualQueueName, ...) and do the
DequeueByDAGRunID / AbortQueuedDAGRun logic as before so orphaned items in the
named queue can be cleared (reference symbols: queueNameForDAGRun,
ErrDAGRunIDNotFound, ErrNoStatusData, requestedQueueName, actualQueueName,
withQueueProcLock, ctx.QueueStore.DequeueByDAGRunID, exec.AbortQueuedDAGRun,
mapAbortQueuedDAGRunError, dequeueFirst).

In `@internal/cmd/remote_client.go`:
- Around line 226-228: The helper currently always sets params["limit"] =
fmt.Sprintf("%d", limit), forcing callers who pass the zero value to send
limit=0; change the code in the function that builds params (where params is
declared) to only add the "limit" key when limit != 0 so zero-value callers can
rely on the server default. Use the same formatting (fmt.Sprintf or
strconv.Itoa) when adding the key, but skip adding it for limit == 0.

In `@internal/cmd/retry.go`:
- Around line 94-119: The code incorrectly always calls
ctx.DAGRunStore.FindSubAttempt when rootRun is non-zero, bypassing the existing
helper findRetryAttempt that treats rootRun.ID == ref.ID as a top-level lookup;
update the branch so both paths reuse findRetryAttempt(ref, rootRun) for the
initial attempt lookup (instead of directly calling FindSubAttempt) and then
apply queueDispatchRetryRequested()/normalizeQueueDispatchRetryLookupError to
the returned error exactly as currently done, preserving the existing
error-wrapping behavior and the queue-dispatch short-circuit (i.e., replace the
direct FindSubAttempt call with a call to findRetryAttempt and keep the
subsequent error handling logic).

In `@internal/core/exec/queue.go`:
- Around line 128-131: The MockQueueStore.ListCursor method can panic when
args.Get(0) is nil; change its return logic to mirror other mocks (e.g.,
DequeueByName, List) by first retrieving v := args.Get(0), if v == nil return
zero-value CursorResult[QueuedItemData] and args.Error(1), otherwise assert and
return v.(CursorResult[QueuedItemData]) and args.Error(1); this avoids a nil
type-assertion panic while preserving the mocked error return.

In `@internal/runtime/subcmd.go`:
- Around line 279-291: The Retry and TaskRetry builders currently inherit the
process environment and can propagate the DAGU_QUEUE_DISPATCH_RETRY key into
plain retries; update the Retry and TaskRetry implementations to filter their
resulting CmdSpec.Env (and any os.Environ-based env construction) to remove any
entry whose key equals exec1.EnvKeyQueueDispatchRetry before returning the spec,
and leave the QueueDispatchRetry and QueueDispatchTaskRetry wrappers unchanged
so they explicitly append exec1.EnvKeyQueueDispatchRetry+"=1" only for
queue-dispatch retries.

In `@internal/service/scheduler/queue_processor.go`:
- Around line 593-596: The retry loop is returning a raw
*exec.StaleQueueDispatchError which backoff.Retry treats as retryable; detect
that error (the existing errors.As(err, &staleErr) check) and return it wrapped
as a permanent error (e.g., using backoff.Permanent) so the retry loop exits
immediately for stale dispatches instead of waiting through the retry schedule.

In `@ui/src/features/agent/components/__tests__/AgentChatModal.test.tsx`:
- Around line 1-2: The file AgentChatModal.test.tsx is missing the repository
GPL v3 license header; add the standard GPL v3 banner at the very top of the
file (above the import statements) — either run the repository tooling `make
addlicense` to apply the canonical header or insert the project's GPL v3 license
comment block manually so the test file has the same license banner as other
source files.

In `@ui/src/features/queues/components/QueueCard.tsx`:
- Around line 27-33: The h3 in QueueCard currently uses the "truncate" class
which hides distinguishing parts of queue.name; replace "truncate" with
"whitespace-normal break-words" on the h3 that renders {queue.name} so long
names wrap and don't overflow (update the className on the h3 element inside the
QueueCard component accordingly to follow ui/**/*.{ts,tsx} guidelines).

In `@ui/src/features/queues/hooks/useQueueBatchDequeue.ts`:
- Around line 12-14: The snapshot currently only saves selectedRuns
(ActiveBatch.snapshot) but not the originating remoteNode, allowing requests to
be routed to whatever node is active when the dialog submits; update the
ActiveBatch type to include remoteNode, capture the remoteNode when creating the
snapshot inside useQueueBatchDequeue, and then use that stored remoteNode when
calling the APIs (the dequeue/bulk action functions invoked from
useQueueBatchDequeue) so every request includes the original remoteNode
parameter and routes to the correct node.

---

Outside diff comments:
In `@ui/src/api/v1/schema.ts`:
- Around line 1324-1343: Update the OpenAPI spec to add a DELETE operation for
the path "/queues/{name}/items" (so the generated client exposes a typed
delete/clear method, e.g. operationId matching the server handler such as
"clearQueueItems" or "deleteQueueItems"), include the optional remoteNode
parameter on that DELETE operation, then run the generation command (pnpm
gen:api) to regenerate ui/src/api/v1/schema.ts so the schema contains both the
GET (listQueueItems) and the new DELETE operation for "/queues/{name}/items".

In `@ui/src/App.tsx`:
- Around line 1-18: This TSX file is missing the required GPL v3 header; add the
standard GPL v3 license header to the top of App.tsx (above the first import
such as "import { Theme } from '@radix-ui/themes'") by running the repository
tooling: execute make addlicense to apply the GPL header automatically, or if
applying manually, insert the project's canonical GPL v3 comment block at file
top so the file (which contains imports like Theme, React, BrowserRouter,
SWRConfig) carries the required license header.

In `@ui/src/features/agent/components/AgentChatModal.tsx`:
- Line 1: This file (AgentChatModal.tsx) is missing the project's GPL v3 license
banner; add the repository's required GPL v3 header at the very top of the file
(above the import statements) consistent with other source files and the
project's formatting rules—either run the repository tooling (make addlicense)
to insert the standard header automatically or paste the canonical GPL v3 header
used elsewhere in the repo so the file (AgentChatModal component) includes the
correct license banner.

In `@ui/src/features/cockpit/components/MobileKanbanBoard.tsx`:
- Around line 1-6: The file MobileKanbanBoard.tsx is missing the required GPL v3
license header; run the repository's license tooling (e.g., execute the make
target used elsewhere: "make addlicense") or manually prepend the same GPL v3
header used in other files (for example match the header in
KanbanCounts.test.tsx) to the top of MobileKanbanBoard.tsx so the file contains
the standard license block before the imports; ensure the header is exact and
committed.

In `@ui/src/pages/queues/index.tsx`:
- Around line 1-15: The modified TSX file (the one that imports Layers, Search,
QueueList, useQueuesListSSE and useSSECacheSync) is missing the repository's GPL
v3 license header; run the repository tool to apply it by executing make
addlicense (or manually prepend the project's GPL v3 header template) so the top
of the file contains the correct license block, then stage and commit the
change.

---

Nitpick comments:
In `@api/v1/api.yaml`:
- Around line 3175-3182: Update the OpenAPI docs for the listQueueItems
operation (operationId "listQueueItems") to explicitly state the deterministic
sort order used when returning a forward-only page and when providing
"nextCursor" (the QueueListCursor parameter): specify whether items are returned
oldest-first or newest-first, how ties are broken (e.g., by ID or timestamp),
and that the cursor advances in that same stable order; apply the same
clarification to the other affected operations referenced (the other endpoints
using the QueueListCursor parameter) so clients can unambiguously implement
cursor paging.

In `@internal/cmd/dequeue_test.go`:
- Around line 164-172: After calling th.RunCommand(t, cmd.Dequeue(), ...) and
asserting the queue length, also fetch the dequeued run by its identifier (e.g.,
"valid-run") from the persisted store and assert its persisted status is updated
to the dequeued/processed state (not still "queued"); use the test helpers/store
methods available in the test fixture (e.g., th.RunStore.Get or equivalent) to
load the run and assert its Status (or PersistedStatus) value, so the test
verifies the run itself was dequeued and not left in queued state.

In `@internal/core/exec/queue_abort.go`:
- Around line 44-68: After the CAS that sets the DAGRun status to Aborted
(CompareAndSwapLatestAttemptStatus and the anonymous func), handle failures from
attempt.Hide by emitting a warning that the abort succeeded but cleanup (Hide)
failed: call your logger (or log.Printf) with context including attempt.ID(),
dagRun.ID (or other identifying fields) and the error before returning the
wrapped error (fmt.Errorf("hide aborted attempt: %w", err)); keep existing
return behavior but add the warning log to make it clear callers/readers that
the status update succeeded even though Hide failed.

In `@internal/service/frontend/api/v1/queues.go`:
- Around line 29-46: collectQueues returns a map so iterating it produces
nondeterministic order; change the handler to build a sorted slice of queue
names from queueMap, sort it (e.g., sort.Strings on the keys), then iterate over
the sorted keys and use queueMap[key] when calling toQueueResource and
accumulating totalRunning/totalQueued/totalCapacity before appending to queues;
this ensures deterministic ordering of the queues in the response while keeping
the existing logic in toQueueResource and the totals calculations.

In `@ui/src/features/agent/components/__tests__/AgentChatModal.test.tsx`:
- Around line 55-57: The SessionSidebar mock currently returns null so the "new"
selection path isn't exercised; update the mock in AgentChatModal.test.tsx (and
the similar block at 154-166) to render a minimal component that accepts an
onSelectSession prop and calls it with "new" in a test-controlled way; then add
an assertion that invoking onSelectSession('new') triggers the component's
clearSession/handleClearSession flow and prevents auto-select (assert
clearSession was called and that the auto-select behavior did not run). Use the
exact prop name onSelectSession and the handler/spy names clearSession or
handleClearSession from the test to locate and hook into the right functions.

In `@ui/src/features/queues/hooks/useQueuedItemsFeed.ts`:
- Around line 169-183: The try/catch wrappers in the useQueuedItemsFeed hooks
are redundant because loadPage already handles errors and loading state; update
the loadMore and reload callbacks to simply call await loadPage(false) and await
loadPage(true) respectively (without catching and calling
setError/getQueueFeedError) so you don't duplicate error handling—leave the
React.useCallback and dependency on loadPage intact and remove the inner catch
blocks and setError calls.
- Around line 22-36: getQueueFeedError is defined but only used once in
useQueuedItemsFeed; remove the standalone getQueueFeedError function and inline
its logic at the call site inside useQueuedItemsFeed (replace the call to
getQueueFeedError(error, fallback) with the equivalent inline extraction: check
if error instanceof Error && error.message, else if error is object with a
string 'message' property and non-empty, else use fallback). Ensure you remove
the getQueueFeedError declaration to avoid dead code and keep the same return
semantics.

In `@ui/src/pages/queues/queue/index.tsx`:
- Around line 36-59: The hook useAutoLoadMore is re-creating the
IntersectionObserver whenever onLoadMore changes; stabilize the callback passed
into it by memoizing the loadMore handler (the function passed at line 147 where
"() => void loadMore()" is used) with React.useCallback so its reference is
stable across renders, then pass that memoized function into useAutoLoadMore
instead of an inline lambda; ensure the dependency array for the memoized
loadMore includes only the values it truly depends on so the callback doesn't
change unnecessarily.