ui/src/menu.tsx (1)

44-52: Redundant conditional: both branches apply the same class.

The ternary on lines 47-48 evaluates to text-primary-foreground regardless of isActive. Either remove the conditional or apply distinct styling for the active state if differentiation is intended.

🔎 Proposed fix

     <span
       className={cn(
-        'flex items-center justify-center w-5 h-5 transform-none text-primary-foreground',
-        isActive ? 'text-primary-foreground' : 'text-primary-foreground'
+        'flex items-center justify-center w-5 h-5 transform-none text-primary-foreground'
       )}
     >
       {children}
     </span>

api/v2/api.yaml (1)

1485-1498: Sub‑DAG filtering parameter looks consistent and well‑documented

The new parentSubDAGRunId query parameter and the updated description clearly convey the multi‑level nested behavior and match existing naming patterns. This is a clean extension of the public API surface.

If you end up reusing this parameter on other endpoints in the future, consider promoting it into components.parameters for reuse, but it’s fine as-is for a single use site.

ui/src/api/v2/schema.ts (1)

575-586: TS client update correctly reflects the new OpenAPI parameter

The updated JSDoc on /dag-runs/{name}/{dagRunId}/sub-dag-runs and the parentSubDAGRunId?: string addition to getSubDAGRuns.parameters.query are in sync with the OpenAPI spec and keep the client surface straightforward to consume.

Just ensure this file continues to be regenerated from api/v2/api.yaml (rather than hand‑edited) so it stays aligned with future spec changes.

Also applies to: 3256-3263

internal/runtime/executor/dag_runner.go (1)

60-84: Local sub‑DAG execution now correctly carries all inline DAG definitions

Passing rCtx.DAG.LocalDAGs into createTempDAGFile ensures the temp file for a local sub‑DAG contains not just the child DAG’s YAML but also its sibling inline DAGs, which is what enables the 3‑level nesting scenarios you’re testing.

One thing to be aware of: in the distributed path (BuildCoordinatorTask / dispatchToCoordinator), you still send string(e.DAG.YamlData) only. That means multi‑level nesting for inline DAGs is currently guaranteed only for the local execution path; if you ever attach a WorkerSelector to an inline DAG and rely on distributed sub‑DAG runs there, you’ll likely need a similar YAML aggregation strategy for the task payload as well.

Also applies to: 171-185

ui/src/features/dags/components/dag-details/SubDAGRunsList.tsx (1)

131-142: Unstable dependency: nodeSubRunIds Set recreated every render.

nodeSubRunIds is a new Set instance on every render (line 97), causing statusLabelMap to recompute unnecessarily. Consider memoizing the Set or using a stable representation.

Suggested fix

-  // Create a map of dagRunIds that belong to THIS node
-  const nodeSubRunIds = new Set(allSubRuns.map((sr) => sr.dagRunId));
+  // Create a map of dagRunIds that belong to THIS node (memoized for stable reference)
+  const nodeSubRunIds = useMemo(
+    () => new Set(allSubRuns.map((sr) => sr.dagRunId)),
+    [allSubRuns]
+  );

ui/src/features/dags/components/dag-execution/ParallelExecutionModal.tsx (2)

15-30: Consider extracting shared constants to reduce duplication.

StatusFilterValue type and STATUS_DISPLAY_LABELS constant are duplicated between this file and SubDAGRunsList.tsx. Consider extracting to a shared location for maintainability.

---

198-212: Auto-scroll may reference wrong child element after filtering.

container.children[selectedIndex] assumes children match filteredSubRuns indices. If the container has additional child elements (like the empty state message), this could scroll to the wrong element or fail silently.

Consider using data-index attributes and querySelector for more robust element targeting:

Suggested fix

   React.useEffect(() => {
     if (selectedIndex !== null && scrollContainerRef.current) {
       const container = scrollContainerRef.current;
-      const selectedElement = container.children[selectedIndex] as HTMLElement;
+      const selectedElement = container.querySelector(`[data-index="${selectedIndex}"]`) as HTMLElement;
       
       if (selectedElement) {
         selectedElement.scrollIntoView({
           block: 'nearest',
           behavior: 'smooth'
         });
       }
     }
   }, [selectedIndex]);

Then add data-index={displayIndex} to the rendered items at line 272.

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: dagu-org/dagu PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-12-04T10:34:17.062Z
Learning: Applies to **/*_test.go : Co-locate Go tests as `*_test.go`; favour table-driven cases and cover failure paths

Learnt from: CR
Repo: dagu-org/dagu PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-12-04T10:34:17.062Z
Learning: `make test` (or `make test-coverage`) executes the Go suite via `gotestsum`; append `TEST_TARGET=./internal/...` to focus packages

Learnt from: CR
Repo: dagu-org/dagu PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-12-04T10:34:17.062Z
Learning: Applies to ui/**/*.{ts,tsx} : The React + TypeScript frontend resides in `ui/`, with production bundles copied to `internal/service/frontend/assets` by `make ui`

Learnt from: CR
Repo: dagu-org/dagu PR: 0
File: ui/CLAUDE.md:0-0
Timestamp: 2025-12-04T10:34:01.045Z
Learning: Applies to ui/**/*.{ts,tsx,jsx,js} : Minimize row heights in tables and lists while maintaining readability, merge related columns, and always handle long text with `whitespace-normal break-words`

internal/integration/localdag_test.go (1)

111-165: LGTM! Multi-level nested local DAG support verified.

The test correctly validates that multi-level nested local DAGs (root → middle-dag → leaf-dag) now execute successfully. The assertions verify:

• Successful execution without errors
• Root node status is NodeSucceeded
• Middle-dag created a sub-run

The implicit verification (overall success proves leaf-dag executed) is acceptable for this integration test level.

Optional: Consider verifying leaf-dag execution explicitly

For more thorough verification of the 3-level nesting, you could optionally retrieve and verify the middle-dag's sub-run to confirm leaf-dag executed:

 // Verify middle-dag has a sub-run
 require.Len(t, dagRunStatus.Nodes[0].SubRuns, 1, "middle-dag should have one sub-run")
+
+// Optionally verify the leaf-dag execution within middle-dag's sub-run
+middleDAGSubRun := dagRunStatus.Nodes[0].SubRuns[0]
+require.Equal(t, core.Succeeded, middleDAGSubRun.Status, "middle-dag sub-run should succeed")
+// Could further verify leaf-dag is in middle-dag's sub-runs if that level of detail is tracked

However, the current level of verification is sufficient for confirming the feature works end-to-end.

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: dagu-org/dagu PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-12-04T10:34:17.062Z
Learning: Applies to **/*_test.go : Co-locate Go tests as `*_test.go`; favour table-driven cases and cover failure paths

internal/runtime/executor/dag_runner.go (1)

504-548: Verify if deterministic local DAG order matters.

The function correctly consolidates multiple local DAGs into a single multi-document YAML file. However, the iteration over the localDAGs map (lines 529-541) produces a non-deterministic order since Go maps have random iteration order.

If the DAG loader or execution logic is sensitive to the order of local DAG definitions, this could cause reproducibility or debugging issues.

Optional: ensure deterministic order by sorting

If deterministic order is required, consider sorting the local DAG names before iteration:

// Add other local DAG data to the temporary file
var names []string
for name := range localDAGs {
	if name != dagName {
		names = append(names, name)
	}
}
sort.Strings(names)

for _, name := range names {
	localDAG := localDAGs[name]
	if _, err := tempFile.WriteString("---\n"); err != nil {
		writeErr = err
		goto Fail
	}
	if _, err := tempFile.Write(localDAG.YamlData); err != nil {
		writeErr = err
		goto Fail
	}
}

This would require importing sort at the top of the file.

Configuration used: defaults

Review profile: CHILL

Plan: Pro

internal/integration/subdag_test.go (1)

427-452: Unused params declaration in worker-dag.

The worker-dag declares TASK_ID and TASK_NAME params (lines 438-439) but they're never passed when calling it (line 433). This appears to be leftover from copying the ParallelExecution test. Consider removing the unused params for clarity.

🔎 Proposed fix

 	t.Run("PartialSuccessSubDAG", func(t *testing.T) {
 		th := test.Setup(t)

 		testDAG := th.DAG(t, `
 steps:
   - name: parallel-tasks
     call: worker-dag
 ---

 name: worker-dag
-params:
-  - TASK_ID
-  - TASK_NAME
 steps:
   - command: exit 1
     continueOn:
       failure: true

   - exit 0
 `)

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Learnt from: CR
Repo: dagu-org/dagu PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-12-04T10:34:17.062Z
Learning: Applies to **/*_test.go : Co-locate Go tests as `*_test.go`; favour table-driven cases and cover failure paths

Learnt from: CR
Repo: dagu-org/dagu PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-12-04T10:34:17.062Z
Learning: `make test` (or `make test-coverage`) executes the Go suite via `gotestsum`; append `TEST_TARGET=./internal/...` to focus packages