How to use a "grep" result as an input of another grep, resulting in multiple lines?

If you're already using awk, you don't need to use grep. awk can do Extended Regular Expression (ERE) matches like grep -E.

And just as importantly, awk can use boolean operators (!, &&, ||, and even parentheses) with conditions/patterns, which grep can't do (although you can make a regex with alternations using | which is an OR operation).

For example:

awk -F- '/Rebuild All started/ && 
         /: (fatal|error)/ { print $1 }' build_output.txt | 
  sort -n |
  uniq

You could even write the awk script so that it stored the matches in an associative array, then sorted and printed the the output in an END block, avoiding the need for piping to sort -n | uniq.

BTW, egrep is deprecated. use grep -E instead for ERE. With GNU grep you also have the option of using -P for PCRE

If you're not using awk, then piping the output of grep into another grep is effectively an AND operation. If needed, you can use grep's -v option for negation.

e.g. using cut instead of awk.

grep 'Rebuild All started' build_output.txt |
  grep -E ': (fatal|error)/' |
  cut -d- -f1 |
  sort -n |
  uniq

This is objectively worse than just using awk. Every program in a pipeline has startup overhead and requires more resources (CPU time, RAM, and I/O bandwidth)...this is not as big a problem as it was a decade or two ago, we have much faster computers and storage devices now, but that's not really a good excuse to be wasteful in how we use them.

First off, a general rule: if you ever need to pipe the output of one text filter (sed, awk, grep, ...) into another text filter then you might be doing something wrong. Perhaps you are using the wrong text filter to begin with, perhaps you are doing something in two passes which could be done in one.

Now to the problem at hand. Another general remark: do it step by step. First, see if the regexp selects all the lines you are interested in. Look out for false positives (lines included in the result which shouldn't be there) and false negatives (lines that belong to the result but aren't there) as well. Only then proceed to cutting out what you are interested in, etc..

In the words of Seymour Cray, builder of the Cray Supercomputers, who I once heard speaking

Development has to be done like walking: one step after the other. If you try to do several steps at once you will hop up and down but won't get anywhere.

(In other words, a line containing "Rebuild All started")

OK, You are doing precisely that with your first command:

grep "Rebuild All started" build_output.txt

But then you are "refining" this result by selcting from that:

egrep ": fatal |: error " build_output.txt

It is not clear what "build_output.txt" contains here. I suppose it is the lines you filtered before, the ones containing "Rebuild All started". If that is the case, you effectively want to filter lines containing this text followed by ": fatal" or ": error". You can do that in one pass and without extended regular expressions:

grep -e 'Rebuild All started.*: fatal ' -e 'Rebuild All started.*: error '

This should give you all the lines you are interested in and you had to only call "grep" once. This doesn't look like much but the most "cost intensive" (in terms of resources) activity of a UNIX system is to set up a process. This is why using one "grep" is a lot better than using two.

Next step is to cut out the interesting part of these lines: "grep" can't do that, because it can only filter lines, but not change them. We need to switch to another tool which can do that: "awk" or "sed". "awk" is a lot bigger than "sed", both in functionality and in resource consumption. This is why I prefer to use "sed" for the things I can do with it and switch to "awk" only when I need to do something not easily accomplished in "sed".¹)

From the example line you provided it looks like the part you are intereseted in is the number at the beginning of the line up to (and including?) the ">". Using the same regexp as before we create a simple "sed"-script:

sed -n 's/^\([0-9]*>\)Rebuild All started.*: fatal/\1/p
        s/^\([0-9]*>\)Rebuild All started.*: error/\1/p' build_output.txt

Again: check, if that is gives you what you expect. Only then do some finishing touches: "sort" can do what "uniq" does using the option "-u":

sed -n 's/^\([0-9]*>\)Rebuild All started.*: fatal.*/\1/p
        s/^\([0-9]*>\)Rebuild All started.*: error.*/\1/p' build_output.txt |
sort -un

¹) There is a proof that "sed" is a "Turing-complete" language - just like "awk" - and hence it is theoretically possible to solve every problem solvable in "awk" in "sed" as well. If that is a good idea and if such a "sed" program is as maintainable as the "awk"-program for the same purpose is highly questionable. For example, here is the impementation of a Turing-machine.

Another answer, this one addressing your updated question:

$ awk -F'>' '/Rebuild.*started:/ { rebuild[$1] = $0 };
             /: (error|fatal)/   { errors[$1] = 1};
             END {
               if (length(errors)) {
                 print "Errors found for:"
                 for (i in errors) {
                   print rebuild[i]
                 }
               }
             }' build_output.txt 
Errors found for:
7>------ Rebuild All started: Project: SecurityHelper, Configuration: Debug Any CPU ------
15>------ Rebuild All started: Project: TicketPrinting, Configuration: Debug Any CPU ------
16>------ Rebuild All started: Project: SecurityProxy, Configuration: Debug Win32 ------

A slightly fancier version could extract the project name from the Rebuild line and just print that, optionally with the associated error message(s).

e.g. the following uses GNU awk (other versions of awk don't do multi-dimensional arrays like this, they kind of fake it with [i,j] rather than [i][j]. See GNU awk's Arrays Summary page). Also, gensub() is a GNU extension to awk.

 awk -F'[>:,]' '/Rebuild.*started:/ {
                  sub(/^ /,"",$4);
                  rebuild[$1] = $4
                };

                /: (error|fatal)/ {
                  errors[$1][++j] = gensub(/^[0-9]+> */, "\t", 1);
                };

                END {
                  if (length(errors)) {
                    print "Errors found for:\n";
                      for (i in errors) {
                        print rebuild[i] ":";
                        for (j in errors[i]) {
                          print errors[i][j]
                      };
                      print ""
                    }
                  }
                }' build_output.txt 
Errors found for:

SecurityHelper:
    C:\Program Files\Microsoft Visual Studio\2022\Professional\MSBuild\Current\Bin\amd64\Microsoft.Common.CurrentVersion.targets(6041,5): error MSB3073: ...

TicketPrinting:
    C:\Program Files\Microsoft Visual Studio\2022\Professional\MSBuild\Current\Bin\amd64\Microsoft.Common.CurrentVersion.targets(6041,5): error MSB3073: ...

SecurityProxy:
    C:\...\source.cpp(11,1): error C1083: Cannot open type library file: 'securityhelper.tlb': No such file or directory

Honestly, I'd rather have done this in perl (it has lots of useful functions for working with and manipulating arrays, as well as extracting portions of text from a line), but I'm not sure if WSL comes with perl by default. A perl version would look very similar, with a few small but significant differences.

With zsh and GNU grep:

failed_jobs=( $(grep -Po '^\d+(?=>.*: (fatal|error))') < build_output) )
(( $#failing_jobs == 0 )) ||
  grep -Po "^(${(j[|])failed_jobs})>.*?Rebuild All started: Project: \K[^,]+" build_output