Release 2.282.1 runner

Prepare 2.282.1 release (#1345 )
* Revert "Recreate VssConnection on retry (#1316)" (#1343) This reverts commit 4359dd605b. * Prepare 2.282.1 release
2025-12-10 12:36:23 +00:00 · 2021-09-15 14:00:06 -04:00 · 2021-09-15 13:49:24 -04:00 · 2021-09-13 14:12:48 -04:00 · 2021-09-13 14:08:46 -04:00 · 2021-09-13 13:56:47 -04:00
49 changed files with 1181 additions and 279 deletions
--- a/docs/adrs/1144-composite-actions.md
+++ b/docs/adrs/1144-composite-actions.md
@@ -0,0 +1,92 @@
+**Date**: 2021-06-10
+
+**Status**: Accepted
+
+## Context
+
+We released [composite run steps](https://github.com/actions/runner/pull/554) last year which started our journey of reusing steps across different workflow files. To continue that journey, we want to expand composite run steps into composite actions.
+
+We want to support the `uses` steps from workflows in composite actions, including:
+  - Container actions
+  - Javascript actions
+  - Other Composite actions (up to a limit of course!)
+  - The pre and post steps these actions can generate
+
+## Guiding Principles
+
+- Composite Actions should function as a single step or action, no matter how many steps it is composed of or how many levels of recursion it has
+  - In the future we may add a configurable option to make this no longer the case
+- A workflow author should not need to understand the inner workings of a composite action in order to use it
+- Composite actions should leverage inputs to get values they need, they will not have full access to the `context` objects. The secrets context will **not** be available to composite actions, users will need to pass these values in as an input.
+- Other Actions should **just work** inside a composite action, without any code changes
+
+## Decisions
+
+### Composite Recursion Limit
+
+- We will start with supporting a recursion limit of `10` composite actions deep
+- We are free to bump this limit in the future, the code will be written to just require updating a variable. If the graph evaluates beyond the recursion limit, the job will fail in the pre-job phase (The `Set up job` step).
+- A composite actions interface is its inputs and outputs, nothing else is carried over when invoking recursively.
+
+### Pre/Post Steps in nested Actions
+
+- We do not plan on adding the ability to configure a customizable pre or post step for composite actions at this time. However, we will execute the pre and post steps of any actions referenced in a composite action.
+- Composite actions will generate a single pre-step and post-step for the entire composite action, even if there are multiple pre-steps and post-steps in the referenced actions.
+  - These steps will execute following the same ordering rules we have today, first to run has their pre step run first and their post step run last.
+  - For example, if you had a composite action with two pre steps and two posts steps:
+
+  ```
+  - uses: action1
+  - uses: composite1
+  - uses: action2
+  ```
+
+  The order of execution would be:
+
+  ```
+  - prestep-action1
+  - prestep-composite1
+    - prestep-composite1-first-action-referenced
+    - prestep-composite1-second-action-referenced
+  - prestep-action2
+  - the job steps
+  - poststep-action2
+  - poststep-composite1
+    - poststep-composite1-the-second-action-referenced
+    - poststep-composite1-first-action-referenced
+  - poststep-action1
+  ```
+
+#### Set-state
+
+- While the composite action has an individual combined pre/post action, the `set-state` command will not be shared.
+- If the `set-state` command is used during a composite step, only the action that originally called `set-state` will have access to the env variable during the post run step.
+  - This prevents multiple actions that set the same state from interfering with the execution of another action's post step.
+
+### Resolve Action Endpoint changes
+
+- The resolve actions endpoint will now validate policy to ensure that the given workflow run has access to download that action.
+  - Older GHES/GHAE customers with newer runners will be locked out of composite uses steps until they upgrade their instance.
+
+### Local actions
+- Local actions will expand the tree, perform policy checks, and download actions Just in Time when the step is running.
+- Like current local actions, we will not support presteps. If an action is running local, by the time we know that, the time to run presteps have already passed.
+
+### If, continue-on-error, timeout-minutes - Not being considered at this time
+
+- `if`, `continue-on-error`, `timeout-minutes` could be supported in composite run/uses steps. These values were not originally supported in our composite run steps implementation.
+  - Browsing the community forums and runner repo, there hasn't been a lot of noise asking for these features, so we will hold off on them.
+- These values passed as input into the composite action will **not** be carried over as input into the individual steps the composite action runs.
+
+### Defaults - Not being considered at this time
+
+- In actions, we have the idea of [defaults](https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#defaultsrun) , which allow you to specify a shell and working directory in one location, rather then on each step.
+- However, `shell` is currently required in composite run steps
+  - In regular run steps, it is optional, and defaults to a different value based on the OS.
+- We want to prioritize the right experience for the consumer, and make the action author continue to explicitly set these values. We can consider improving this experience in the future.
+
+## Consequences
+
+- Workflows are now more reusable across multiple workflow files
+- Composite actions implement most of the existing workflow run steps, with room to expand these in the future
+- Feature flags will control this rollout
--- a/docs/automate.md
+++ b/docs/automate.md
@@ -26,6 +26,23 @@ Run as a one-liner. NOTE: replace with yourorg/yourrepo (repo level) or just you
 curl -s https://raw.githubusercontent.com/actions/runner/main/scripts/create-latest-svc.sh | bash -s yourorg/yourrepo
 ```

+You can call the script with additional arguments:
+```bash
+#   Usage:
+#       export RUNNER_CFG_PAT=<yourPAT>
+#       ./create-latest-svc -s scope -g [ghe_domain] -n [name] -u [user] -l [labels]
+#       -s          required  scope: repo (:owner/:repo) or org (:organization)
+#       -g          optional  ghe_hostname: the fully qualified domain name of your GitHub Enterprise Server deployment
+#       -n          optional  name of the runner, defaults to hostname
+#       -u          optional  user svc will run as, defaults to current
+#       -l          optional  list of labels (split by comma) applied on the runner"
+```
+
+Use `--` to pass any number of optional named parameters:
+
+```
+curl -s https://raw.githubusercontent.com/actions/runner/main/scripts/create-latest-svc.sh | bash -s -- -s myorg/myrepo -n myname -l label1,label2
+```
 ### Why can't I use a container?

 The runner is installed as a service using `systemd` and `systemctl`. Docker does not support `systemd` for service configuration on a container.
--- a/docs/checks/network.md
+++ b/docs/checks/network.md
@@ -2,17 +2,19 @@

 ### Common things that can cause the runner to not working properly

- Bug in the runner or the dotnet framework that causes actions runner can't make Http request in a certain network environment.
+- A bug in the runner or the dotnet framework that causes the actions runner to be unable to make Http requests in a certain network environment.

- Proxy/Firewall block certain HTTP method, like it block all POST and PUT calls which the runner will use to upload logs.
+- A Proxy or Firewall may block certain HTTP method, such as blocking all POST and PUT calls which the runner will use to upload logs.

- Proxy/Firewall only allows requests with certain user-agent to pass through and the actions runner user-agent is not in the allow list.
+- A Proxy or Firewall may only allows requests with certain user-agent to pass through and the actions runner user-agent is not in the allow list.

- Proxy try to decrypt and exam HTTPS traffic for security purpose but cause the actions-runner to fail to finish SSL handshake due to the lack of trusting proxy's CA.
+- A Proxy try to decrypt and exam HTTPS traffic for security purpose but cause the actions-runner to fail to finish SSL handshake due to the lack of trusting proxy's CA.

- Proxy try to modify the HTTPS request (like add or change some http headers) and causes the request become incompatible with the Actions Service (ASP.NetCore), Ex: [Nginx](https://github.com/dotnet/aspnetcore/issues/17081)
+- The SSL handshake may fail if the client and server do not support the same TLS version, or the same cipher suites.

- Firewall rules that block action runner from accessing certain hosts, ex: `*.github.com`, `*.actions.githubusercontent.com`, etc.
+- A Proxy may try to modify the HTTPS request (like add or change some http headers) and causes the request become incompatible with the Actions Service (ASP.NetCore), Ex: [Nginx](https://github.com/dotnet/aspnetcore/issues/17081)
+
+- Firewall rules that block action runner from accessing certain hosts, ex: `*.github.com`, `*.actions.githubusercontent.com`, etc


 ### Identify and solve these problems
@@ -30,3 +32,30 @@ Use a 3rd party tool to make the same requests as the runner did would be a good
 If the 3rd party tool is also experiencing the same error as the runner does, then you might want to contact your network administrator for help.

 Otherwise, contact GitHub customer support or log an issue at https://github.com/actions/runner
+
+### Troubleshooting: Why can't I configure a runner?
+
+If you are having trouble connecting, try these steps:
+
+1. Validate you can reach our endpoints from your web browser. If not, double check your local network connection
+    - For hosted Github:
+      - https://api.github.com/
+      - https://vstoken.actions.githubusercontent.com/_apis/health
+      - https://pipelines.actions.githubusercontent.com/_apis/health
+    - For GHES/GHAE
+      - https://myGHES.com/_services/vstoken/_apis/health
+      - https://myGHES.com/_services/pipelines/_apis/health
+      - https://myGHES.com/api/v3
+2. Validate you can reach those endpoints in powershell core
+    - The runner runs on .net core, lets validate the local settings for that stack
+    - Open up `pwsh`
+    - Run the command using the urls above `Invoke-WebRequest {url}`
+3. If not, get a packet trace using a tool like wireshark and start looking at the TLS handshake. 
+    - If you see a Client Hello followed by a Server RST:
+      - You may need to configure your TLS settings to use the correct version
+        - You should support TLS version 1.2 or later
+      - You may need to configure your TLS settings to have up to date cipher suites, this may be solved by system updates and patches.
+      - Your firewall, proxy or network configuration may be blocking the connection
+      - You will want to reach out to whoever is in charge of your network with these pcap files to further troubleshoot
+    - If you see a failure later in the handshake:
+      - Try the fix in the [SSLCert Fix](./sslcert.md)
--- a/releaseNote.md
+++ b/releaseNote.md
@@ -1,22 +1,14 @@
 ## Features

- Add Job Message size to both Worker and Listener logs for debugging (#1100)
- Add notice annotation level (in addition to error and warning) and support more annotation fields (#1175)
+N/A

 ## Bugs

- Remove the `NODE_ICU_DATA` environment variable that may cause conflicts with node within the runner. (#1060)
- Handle cancelled jobs better to prevent orphaned processes (#1083)
- No longer fail to remove a `systemd` service with `svc.sh uninstall` if the script had previously been run from the wrong location (#1135)
- Send `SIGKILL` to the runner listener if it doesn't respond to `SIGINT` for 30 seconds
- Match runner group name when configuring even if there's only a single runner group 
-
+- Revert "More resilient VssConnection client retries in JobServer" (#1343)

 ## Misc
- Fix automation links in documentation (#1089)
- Improve developer and first contributor experience by improving tooling for VS Code (#1101, #1117, #1119, #1132)
- Fix bug where linux users are not able to run remove-svc.sh as root (#1127)

+N/A

 ## Windows x64
 We recommend configuring the runner in a root folder of the Windows drive (e.g. "C:\actions-runner"). This will help avoid issues related to service identity folder permissions and long file path restrictions on Windows.
--- a/2
+++ b/2
@@ -1 +1 @@
-<Update to ./src/runnerversion when creating release>
+2.282.1
--- a/scripts/create-latest-svc.sh
+++ b/scripts/create-latest-svc.sh
@@ -2,36 +2,68 @@

 set -e

-#
-# Downloads latest releases (not pre-release) runner
-# Configures as a service
-#
-# Examples:
-# RUNNER_CFG_PAT=<yourPAT> ./create-latest-svc.sh myuser/myrepo my.ghe.deployment.net
-# RUNNER_CFG_PAT=<yourPAT> ./create-latest-svc.sh myorg my.ghe.deployment.net
-#
-# Usage:
-#     export RUNNER_CFG_PAT=<yourPAT>
-#     ./create-latest-svc scope [ghe_domain] [name] [user] [labels]
-#
-#      scope       required  repo (:owner/:repo) or org (:organization)
-#      ghe_domain  optional  the fully qualified domain name of your GitHub Enterprise Server deployment
-#      name        optional  defaults to hostname
-#      user        optional  user svc will run as. defaults to current
-#      labels      optional  list of labels (split by comma) applied on the runner
-#
 # Notes:
 # PATS over envvars are more secure
+# Downloads latest runner release (not pre-release)
+# Configures it as a service more secure
 # Should be used on VMs and not containers
 # Works on OSX and Linux
 # Assumes x64 arch
-#
+# See EXAMPLES below

-runner_scope=${1}
-ghe_hostname=${2}
-runner_name=${3:-$(hostname)}
-svc_user=${4:-$USER}
-labels=${5}
+flags_found=false
+
+while getopts 's:g:n:u:l:' opt; do
+    flags_found=true
+
+    case $opt in
+    s)
+        runner_scope=$OPTARG
+        ;;
+    g)
+        ghe_hostname=$OPTARG
+        ;;
+    n)
+        runner_name=$OPTARG
+        ;;
+    u)
+        svc_user=$OPTARG
+        ;;
+    l)
+        labels=$OPTARG
+        ;;
+    *)
+        echo "
+Runner Service Installer
+Examples:
+RUNNER_CFG_PAT=<yourPAT> ./create-latest-svc.sh myuser/myrepo my.ghe.deployment.net
+RUNNER_CFG_PAT=<yourPAT> ./create-latest-svc.sh -s myorg -u user_name -l label1,label2
+Usage:
+    export RUNNER_CFG_PAT=<yourPAT>
+    ./create-latest-svc scope [ghe_domain] [name] [user] [labels]
+    -s          required  scope: repo (:owner/:repo) or org (:organization)
+    -g          optional  ghe_hostname: the fully qualified domain name of your GitHub Enterprise Server deployment
+    -n          optional  name of the runner, defaults to hostname
+    -u          optional  user svc will run as, defaults to current
+    -l          optional  list of labels (split by comma) applied on the runner"
+        exit 0
+        ;;
+    esac
+done
+
+shift "$((OPTIND - 1))"
+
+if ! "$flags_found"; then
+    runner_scope=${1}
+    ghe_hostname=${2}
+    runner_name=${3:-$(hostname)}
+    svc_user=${4:-$USER}
+    labels=${5}
+fi
+
+# apply defaults
+runner_name=${runner_name:-$(hostname)}
+svc_user=${svc_user:-$USER}

 echo "Configuring runner @ ${runner_scope}"
 sudo echo
@@ -142,7 +174,7 @@ echo
 echo "Configuring as a service ..."
 prefix=""
 if [ "${runner_plat}" == "linux" ]; then
-prefix="sudo "
+    prefix="sudo "
 fi

 ${prefix}./svc.sh install ${svc_user}
--- a/scripts/delete.sh
+++ b/scripts/delete.sh
@@ -51,7 +51,7 @@ fi
 # Ensure offline
 #--------------------------------------
 runner_status=$(curl -s -X GET ${base_api_url}/${runner_scope}/actions/runners?per_page=100  -H "accept: application/vnd.github.everest-preview+json" -H "authorization: token ${RUNNER_CFG_PAT}" \
-        | jq -M -j ".runners | .[] | [select(.name == \"${runner_name}\")] | .[0].status")
+        | jq -M -j ".runners | .[] | select(.name == \"${runner_name}\") | .status")

 if [ -z "${runner_status}" ]; then 
    fatal "Could not find runner with name ${runner_name}"
@@ -67,7 +67,7 @@ fi
 # Get id of runner to remove
 #--------------------------------------
 runner_id=$(curl -s -X GET ${base_api_url}/${runner_scope}/actions/runners?per_page=100  -H "accept: application/vnd.github.everest-preview+json" -H "authorization: token ${RUNNER_CFG_PAT}" \
-        | jq -M -j ".runners | .[] | [select(.name == \"${runner_name}\")] | .[0].id")
+        | jq -M -j ".runners | .[] | select(.name == \"${runner_name}\") | .id")

 if [ -z "${runner_id}" ]; then 
    fatal "Could not find runner with name ${runner_name}"
--- a/src/Misc/expressionFunc/hashFiles/package-lock.json
+++ b/src/Misc/expressionFunc/hashFiles/package-lock.json
@@ -1291,9 +1291,9 @@
      }
    },
    "glob-parent": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.1.tgz",
-      "integrity": "sha512-FnI+VGOpnlGHWZxthPGR+QhR78fuiK0sNLkHQv+bL9fQi57lNNdquIbna/WrfROrolq8GK5Ek6BiMwqL/voRYQ==",
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
      "dev": true,
      "requires": {
        "is-glob": "^4.0.1"
@@ -1374,9 +1374,9 @@
      "dev": true
    },
    "hosted-git-info": {
-      "version": "2.8.8",
-      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.8.tgz",
-      "integrity": "sha512-f/wzC2QaWBs7t9IYqB4T3sR1xviIViXJRJTWBlx2Gf3g0Xi5vI7Yy4koXQ1c9OYDGHN9sBy1DQ2AB8fqZBWhUg==",
+      "version": "2.8.9",
+      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz",
+      "integrity": "sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==",
      "dev": true
    },
    "iconv-lite": {
@@ -1683,9 +1683,9 @@
      }
    },
    "lodash": {
-      "version": "4.17.19",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.19.tgz",
-      "integrity": "sha512-JNvd8XER9GQX0v2qJgsaN/mzFCNA5BRe/j8JN9d+tWyGLSodKQHKFicdwNYzWwI3wjRnaKPsGj1XkBjx/F96DQ==",
+      "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
      "dev": true
    },
    "lodash.unescape": {
@@ -1947,9 +1947,9 @@
      "dev": true
    },
    "path-parse": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
-      "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==",
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
      "dev": true
    },
    "path-type": {
--- a/src/Misc/layoutbin/installdependencies.sh
+++ b/src/Misc/layoutbin/installdependencies.sh
@@ -94,7 +94,6 @@ then
            fi
        }

-        # libssl version prefer: libssl1.1 -> libssl1.0.2 -> libssl1.0.0
        apt_get_with_fallbacks libssl1.1$ libssl1.0.2$ libssl1.0.0$
        if [ $? -ne 0 ]
        then
@@ -103,8 +102,7 @@ then
            exit 1
        fi

-        # libicu version prefer: libicu66 -> libicu63 -> libicu60 -> libicu57 -> libicu55 -> libicu52
-        apt_get_with_fallbacks libicu66 libicu63 libicu60 libicu57 libicu55 libicu52
+        apt_get_with_fallbacks libicu72 libicu71 libicu70 libicu69 libicu68 libicu67 libicu66 libicu65 libicu63 libicu60 libicu57 libicu55 libicu52
        if [ $? -ne 0 ]
        then
            echo "'$apt_get' failed with exit code '$?'"
--- a/src/Misc/layoutbin/update.sh.template
+++ b/src/Misc/layoutbin/update.sh.template
@@ -118,6 +118,43 @@ then
    exit 1
 fi

+# fix upgrade issue with macOS
+currentplatform=$(uname | awk '{print tolower($0)}')
+if [[ "$currentplatform" == 'darwin' ]]; then
+    # need a short-term fix for https://github.com/actions/runner/issues/743
+    # we will recreate all the ./externals/node12/bin/node of the past 5 versions
+    # v2.280.3 v2.280.2 v2.280.1 v2.279.0 v2.278.0
+    if [[ ! -e "$rootfolder/externals.2.280.3/node12/bin/node" ]]
+    then
+        mkdir -p "$rootfolder/externals.2.280.3/node12/bin"
+        cp "$rootfolder/externals/node12/bin/node" "$rootfolder/externals.2.280.3/node12/bin/node"
+    fi
+
+    if [[ ! -e "$rootfolder/externals.2.280.2/node12/bin/node" ]]
+    then
+        mkdir -p "$rootfolder/externals.2.280.2/node12/bin"
+        cp "$rootfolder/externals/node12/bin/node" "$rootfolder/externals.2.280.2/node12/bin/node"
+    fi
+
+    if [[ ! -e "$rootfolder/externals.2.280.1/node12/bin/node" ]]
+    then
+        mkdir -p "$rootfolder/externals.2.280.1/node12/bin"
+        cp "$rootfolder/externals/node12/bin/node" "$rootfolder/externals.2.280.1/node12/bin/node"
+    fi
+
+    if [[ ! -e "$rootfolder/externals.2.279.0/node12/bin/node" ]]
+    then
+        mkdir -p "$rootfolder/externals.2.279.0/node12/bin"
+        cp "$rootfolder/externals/node12/bin/node" "$rootfolder/externals.2.279.0/node12/bin/node"
+    fi
+
+    if [[ ! -e "$rootfolder/externals.2.278.0/node12/bin/node" ]]
+    then
+        mkdir -p "$rootfolder/externals.2.278.0/node12/bin"
+        cp "$rootfolder/externals/node12/bin/node" "$rootfolder/externals.2.278.0/node12/bin/node"
+    fi
+fi
+
 date "+[%F %T-%4N] Update succeed" >> "$logfile"

 # rename the update log file with %logfile%.succeed/.failed/succeedneedrestart
--- a/src/Runner.Common/ConfigurationStore.cs
+++ b/src/Runner.Common/ConfigurationStore.cs
@@ -33,6 +33,9 @@ namespace GitHub.Runner.Common
        [DataMember(EmitDefaultValue = false)]
        public string PoolName { get; set; }

+        [DataMember(EmitDefaultValue = false)]
+        public bool Ephemeral { get; set; }
+
        [DataMember(EmitDefaultValue = false)]
        public string ServerUrl { get; set; }

--- a/src/Runner.Common/Constants.cs
+++ b/src/Runner.Common/Constants.cs
@@ -125,9 +125,10 @@ namespace GitHub.Runner.Common
                {
                    public static readonly string Check = "check";
                    public static readonly string Commit = "commit";
+                    public static readonly string Ephemeral = "ephemeral";
                    public static readonly string Help = "help";
                    public static readonly string Replace = "replace";
-                    public static readonly string Once = "once";
+                    public static readonly string Once = "once"; // TODO: Remove in 10/2021
                    public static readonly string RunAsService = "runasservice";
                    public static readonly string Unattended = "unattended";
                    public static readonly string Version = "version";
--- a/src/Runner.Common/HostContext.cs
+++ b/src/Runner.Common/HostContext.cs
@@ -90,6 +90,8 @@ namespace GitHub.Runner.Common
            this.SecretMasker.AddValueEncoder(ValueEncoders.UriDataEscape);
            this.SecretMasker.AddValueEncoder(ValueEncoders.XmlDataEscape);
            this.SecretMasker.AddValueEncoder(ValueEncoders.TrimDoubleQuotes);
+            this.SecretMasker.AddValueEncoder(ValueEncoders.PowerShellPreAmpersandEscape);
+            this.SecretMasker.AddValueEncoder(ValueEncoders.PowerShellPostAmpersandEscape);

            // Create the trace manager.
            if (string.IsNullOrEmpty(logFile))
--- a/src/Runner.Common/JobServerQueue.cs
+++ b/src/Runner.Common/JobServerQueue.cs
@@ -15,6 +15,7 @@ namespace GitHub.Runner.Common
    [ServiceLocator(Default = typeof(JobServerQueue))]
    public interface IJobServerQueue : IRunnerService, IThrottlingReporter
    {
+        TaskCompletionSource<int> JobRecordUpdated { get; }
        event EventHandler<ThrottlingEventArgs> JobServerQueueThrottling;
        Task ShutdownAsync();
        void Start(Pipelines.AgentJobRequestMessage jobRequest);
@@ -62,8 +63,11 @@ namespace GitHub.Runner.Common
        private IJobServer _jobServer;
        private Task[] _allDequeueTasks;
        private readonly TaskCompletionSource<int> _jobCompletionSource = new TaskCompletionSource<int>();
+        private readonly TaskCompletionSource<int> _jobRecordUpdated = new TaskCompletionSource<int>();
        private bool _queueInProcess = false;

+        public TaskCompletionSource<int> JobRecordUpdated => _jobRecordUpdated;
+
        public event EventHandler<ThrottlingEventArgs> JobServerQueueThrottling;

        // Web console dequeue will start with process queue every 250ms for the first 60*4 times (~60 seconds).
@@ -455,6 +459,14 @@ namespace GitHub.Runner.Common
                            {
                                Trace.Verbose("Cleanup buffered timeline record for timeline: {0}.", update.TimelineId);
                            }
+
+                            if (!_jobRecordUpdated.Task.IsCompleted &&
+                                update.PendingRecords.Any(x => x.Id == _jobTimelineRecordId && x.State != null))
+                            {
+                                // We have changed the state of the job
+                                Trace.Info("Job timeline record has been updated for the first time.");
+                                _jobRecordUpdated.TrySetResult(0);
+                            }
                        }
                        catch (Exception ex)
                        {
--- a/src/Runner.Common/Terminal.cs
+++ b/src/Runner.Common/Terminal.cs
@@ -164,9 +164,8 @@ namespace GitHub.Runner.Common
            if (!Silent)
            {
                Console.WriteLine();
-                Console.ForegroundColor = ConsoleColor.White;
-                Console.WriteLine($"# {message}");
                Console.ResetColor();
+                Console.WriteLine($"# {message}");
                Console.WriteLine();
            }
        }
@@ -177,9 +176,8 @@ namespace GitHub.Runner.Common
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.Write("√ ");
-                Console.ForegroundColor = ConsoleColor.White;
-                Console.WriteLine(message);
                Console.ResetColor();
+                Console.WriteLine(message);
            }
        }

--- a/src/Runner.Listener/CommandSettings.cs
+++ b/src/Runner.Listener/CommandSettings.cs
@@ -29,10 +29,10 @@ namespace GitHub.Runner.Listener
        {
            Constants.Runner.CommandLine.Flags.Check,
            Constants.Runner.CommandLine.Flags.Commit,
+            Constants.Runner.CommandLine.Flags.Ephemeral,
            Constants.Runner.CommandLine.Flags.Help,
            Constants.Runner.CommandLine.Flags.Replace,
            Constants.Runner.CommandLine.Flags.RunAsService,
-            Constants.Runner.CommandLine.Flags.Once,
            Constants.Runner.CommandLine.Flags.Unattended,
            Constants.Runner.CommandLine.Flags.Version
        };
@@ -66,7 +66,9 @@ namespace GitHub.Runner.Listener
        public bool Help => TestFlag(Constants.Runner.CommandLine.Flags.Help);
        public bool Unattended => TestFlag(Constants.Runner.CommandLine.Flags.Unattended);
        public bool Version => TestFlag(Constants.Runner.CommandLine.Flags.Version);
+        public bool Ephemeral => TestFlag(Constants.Runner.CommandLine.Flags.Ephemeral);

+        // TODO: Remove in 10/2021
        public bool RunOnce => TestFlag(Constants.Runner.CommandLine.Flags.Once);

        // Constructor.
--- a/src/Runner.Listener/Configuration/ConfigurationManager.cs
+++ b/src/Runner.Listener/Configuration/ConfigurationManager.cs
@@ -65,18 +65,18 @@ namespace GitHub.Runner.Listener.Configuration
        public async Task ConfigureAsync(CommandSettings command)
        {
            _term.WriteLine();
-            _term.WriteLine("--------------------------------------------------------------------------------", ConsoleColor.White);
-            _term.WriteLine("|        ____ _ _   _   _       _          _        _   _                      |", ConsoleColor.White);
-            _term.WriteLine("|       / ___(_) |_| | | |_   _| |__      / \\   ___| |_(_) ___  _ __  ___      |", ConsoleColor.White);
-            _term.WriteLine("|      | |  _| | __| |_| | | | | '_ \\    / _ \\ / __| __| |/ _ \\| '_ \\/ __|     |", ConsoleColor.White);
-            _term.WriteLine("|      | |_| | | |_|  _  | |_| | |_) |  / ___ \\ (__| |_| | (_) | | | \\__ \\     |", ConsoleColor.White);
-            _term.WriteLine("|       \\____|_|\\__|_| |_|\\__,_|_.__/  /_/   \\_\\___|\\__|_|\\___/|_| |_|___/     |", ConsoleColor.White);
-            _term.WriteLine("|                                                                              |", ConsoleColor.White);
-            _term.Write("|                       ", ConsoleColor.White);
+            _term.WriteLine("--------------------------------------------------------------------------------");
+            _term.WriteLine("|        ____ _ _   _   _       _          _        _   _                      |");
+            _term.WriteLine("|       / ___(_) |_| | | |_   _| |__      / \\   ___| |_(_) ___  _ __  ___      |");
+            _term.WriteLine("|      | |  _| | __| |_| | | | | '_ \\    / _ \\ / __| __| |/ _ \\| '_ \\/ __|     |");
+            _term.WriteLine("|      | |_| | | |_|  _  | |_| | |_) |  / ___ \\ (__| |_| | (_) | | | \\__ \\     |");
+            _term.WriteLine("|       \\____|_|\\__|_| |_|\\__,_|_.__/  /_/   \\_\\___|\\__|_|\\___/|_| |_|___/     |");
+            _term.WriteLine("|                                                                              |");
+            _term.Write("|                       ");
            _term.Write("Self-hosted runner registration", ConsoleColor.Cyan);
-            _term.WriteLine("                        |", ConsoleColor.White);
-            _term.WriteLine("|                                                                              |", ConsoleColor.White);
-            _term.WriteLine("--------------------------------------------------------------------------------", ConsoleColor.White);
+            _term.WriteLine("                        |");
+            _term.WriteLine("|                                                                              |");
+            _term.WriteLine("--------------------------------------------------------------------------------");

            Trace.Info(nameof(ConfigureAsync));
            if (IsConfigured())
@@ -117,6 +117,7 @@ namespace GitHub.Runner.Listener.Configuration
                try
                {
                    // Determine the service deployment type based on connection data. (Hosted/OnPremises)
+                    // Hosted usually means github.com or localhost, while OnPremises means GHES or GHAE
                    runnerSettings.IsHostedServer = runnerSettings.GitHubUrl == null || UrlUtil.IsHostedServer(new UriBuilder(runnerSettings.GitHubUrl));

                    // Warn if the Actions server url and GHES server url has different Host
@@ -186,7 +187,7 @@ namespace GitHub.Runner.Listener.Configuration
            }
            else
            {
-                Trace.Info("Found a self-hosted runner group with id {1} and name {2}", agentPool.Id, agentPool.Name);
+                Trace.Info($"Found a self-hosted runner group with id {agentPool.Id} and name {agentPool.Name}");
                runnerSettings.PoolId = agentPool.Id;
                runnerSettings.PoolName = agentPool.Name;
            }
@@ -194,6 +195,7 @@ namespace GitHub.Runner.Listener.Configuration
            TaskAgent agent;
            while (true)
            {
+                runnerSettings.Ephemeral = command.Ephemeral;
                runnerSettings.AgentName = command.GetRunnerName();

                _term.WriteLine();
@@ -210,7 +212,7 @@ namespace GitHub.Runner.Listener.Configuration
                    if (command.GetReplace())
                    {
                        // Update existing agent with new PublicKey, agent version.
-                        agent = UpdateExistingAgent(agent, publicKey, userLabels);
+                        agent = UpdateExistingAgent(agent, publicKey, userLabels, runnerSettings.Ephemeral);

                        try
                        {
@@ -233,7 +235,7 @@ namespace GitHub.Runner.Listener.Configuration
                else
                {
                    // Create a new agent.
-                    agent = CreateNewAgent(runnerSettings.AgentName, publicKey, userLabels);
+                    agent = CreateNewAgent(runnerSettings.AgentName, publicKey, userLabels, runnerSettings.Ephemeral);

                    try
                    {
@@ -346,12 +348,9 @@ namespace GitHub.Runner.Listener.Configuration

                    _term.WriteLine();
                    _term.WriteSuccessMessage("Runner service removed");
-#elif OS_LINUX
-                    // unconfig system D service first
-                    throw new Exception("Unconfigure service first");
-#elif OS_OSX
-                    // unconfig osx service first
-                    throw new Exception("Unconfigure service first");
+#else
+                    // unconfig systemd or osx service first
+                    throw new Exception("Uninstall service first");
 #endif
                }

@@ -458,7 +457,7 @@ namespace GitHub.Runner.Listener.Configuration
        }


-        private TaskAgent UpdateExistingAgent(TaskAgent agent, RSAParameters publicKey, ISet<string> userLabels)
+        private TaskAgent UpdateExistingAgent(TaskAgent agent, RSAParameters publicKey, ISet<string> userLabels, bool ephemeral)
        {
            ArgUtil.NotNull(agent, nameof(agent));
            agent.Authorization = new TaskAgentAuthorization
@@ -469,6 +468,8 @@ namespace GitHub.Runner.Listener.Configuration
            // update should replace the existing labels
            agent.Version = BuildConstants.RunnerPackage.Version;
            agent.OSDescription = RuntimeInformation.OSDescription;
+            agent.Ephemeral = ephemeral;
+            agent.MaxParallelism = 1;

            agent.Labels.Clear();

@@ -484,7 +485,7 @@ namespace GitHub.Runner.Listener.Configuration
            return agent;
        }

-        private TaskAgent CreateNewAgent(string agentName, RSAParameters publicKey, ISet<string> userLabels)
+        private TaskAgent CreateNewAgent(string agentName, RSAParameters publicKey, ISet<string> userLabels, bool ephemeral)
        {
            TaskAgent agent = new TaskAgent(agentName)
            {
@@ -495,6 +496,7 @@ namespace GitHub.Runner.Listener.Configuration
                MaxParallelism = 1,
                Version = BuildConstants.RunnerPackage.Version,
                OSDescription = RuntimeInformation.OSDescription,
+                Ephemeral = ephemeral,
            };

            agent.Labels.Add(new AgentLabel("self-hosted", LabelType.System));
--- a/src/Runner.Listener/Configuration/PromptManager.cs
+++ b/src/Runner.Listener/Configuration/PromptManager.cs
@@ -85,7 +85,7 @@ namespace GitHub.Runner.Listener.Configuration
            while (true)
            {
                // Write the message prompt.
-                _terminal.Write($"{description} ", ConsoleColor.White);
+                _terminal.Write($"{description} ");

                if(!string.IsNullOrEmpty(defaultValue))
                {
--- a/src/Runner.Listener/JobDispatcher.cs
+++ b/src/Runner.Listener/JobDispatcher.cs
@@ -507,7 +507,20 @@ namespace GitHub.Runner.Listener
                                {
                                    detailInfo = string.Join(Environment.NewLine, workerOutput);
                                    Trace.Info($"Return code {returnCode} indicate worker encounter an unhandled exception or app crash, attach worker stdout/stderr to JobRequest result.");
-                                    await LogWorkerProcessUnhandledException(message, detailInfo);
+
+                                    var jobServer = HostContext.GetService<IJobServer>();
+                                    VssCredentials jobServerCredential = VssUtil.GetVssCredential(systemConnection);
+                                    VssConnection jobConnection = VssUtil.CreateConnection(systemConnection.Url, jobServerCredential);
+                                    await jobServer.ConnectAsync(jobConnection);
+
+                                    await LogWorkerProcessUnhandledException(jobServer, message, detailInfo);
+
+                                    // Go ahead to finish the job with result 'Failed' if the STDERR from worker is System.IO.IOException, since it typically means we are running out of disk space.
+                                    if (detailInfo.Contains(typeof(System.IO.IOException).ToString(), StringComparison.OrdinalIgnoreCase))
+                                    {
+                                        Trace.Info($"Finish job with result 'Failed' due to IOException.");
+                                        await ForceFailJob(jobServer, message);
+                                    }
                                }

                                TaskResult result = TaskResultUtil.TranslateFromReturnCode(returnCode);
@@ -915,53 +928,16 @@ namespace GitHub.Runner.Listener
        }

        // log an error issue to job level timeline record
-        private async Task LogWorkerProcessUnhandledException(Pipelines.AgentJobRequestMessage message, string errorMessage)
+        private async Task LogWorkerProcessUnhandledException(IJobServer jobServer, Pipelines.AgentJobRequestMessage message, string errorMessage)
        {
            try
            {
-                var systemConnection = message.Resources.Endpoints.SingleOrDefault(x => string.Equals(x.Name, WellKnownServiceEndpointNames.SystemVssConnection));
-                ArgUtil.NotNull(systemConnection, nameof(systemConnection));
-
-                var jobServer = HostContext.GetService<IJobServer>();
-                VssCredentials jobServerCredential = VssUtil.GetVssCredential(systemConnection);
-                VssConnection jobConnection = VssUtil.CreateConnection(systemConnection.Url, jobServerCredential);
-
-                /* Below is the legacy 'OnPremises' code that is currently unused by the runner
-                   ToDo: re-implement code as appropriate once GHES support is added.
-                // Make sure SystemConnection Url match Config Url base for OnPremises server	
-                if (!message.Variables.ContainsKey(Constants.Variables.System.ServerType) ||	
-                    string.Equals(message.Variables[Constants.Variables.System.ServerType]?.Value, "OnPremises", StringComparison.OrdinalIgnoreCase))	
-                {	
-                    try	
-                    {	
-                        Uri result = null;	
-                        Uri configUri = new Uri(_runnerSetting.ServerUrl);	
-                        if (Uri.TryCreate(new Uri(configUri.GetComponents(UriComponents.SchemeAndServer, UriFormat.Unescaped)), jobServerUrl.PathAndQuery, out result))	
-                        {	
-                            //replace the schema and host portion of messageUri with the host from the	
-                            //server URI (which was set at config time)	
-                            jobServerUrl = result;	
-                        }	
-                    }	
-                    catch (InvalidOperationException ex)	
-                    {	
-                        //cannot parse the Uri - not a fatal error	
-                        Trace.Error(ex);	
-                    }	
-                    catch (UriFormatException ex)	
-                    {	
-                        //cannot parse the Uri - not a fatal error	
-                        Trace.Error(ex);	
-                    }	
-                } */
-
-                await jobServer.ConnectAsync(jobConnection);
-
                var timeline = await jobServer.GetTimelineAsync(message.Plan.ScopeIdentifier, message.Plan.PlanType, message.Plan.PlanId, message.Timeline.Id, CancellationToken.None);
-
                ArgUtil.NotNull(timeline, nameof(timeline));
+
                TimelineRecord jobRecord = timeline.Records.FirstOrDefault(x => x.Id == message.JobId && x.RecordType == "Job");
                ArgUtil.NotNull(jobRecord, nameof(jobRecord));
+
                var unhandledExceptionIssue = new Issue() { Type = IssueType.Error, Message = errorMessage };
                unhandledExceptionIssue.Data[Constants.Runner.InternalTelemetryIssueDataKey] = Constants.Runner.WorkerCrash;
                jobRecord.ErrorCount++;
@@ -975,6 +951,21 @@ namespace GitHub.Runner.Listener
            }
        }

+        // raise job completed event to fail the job.
+        private async Task ForceFailJob(IJobServer jobServer, Pipelines.AgentJobRequestMessage message)
+        {
+            try
+            {
+                var jobCompletedEvent = new JobCompletedEvent(message.RequestId, message.JobId, TaskResult.Failed);
+                await jobServer.RaisePlanEventAsync<JobCompletedEvent>(message.Plan.ScopeIdentifier, message.Plan.PlanType, message.Plan.PlanId, jobCompletedEvent, CancellationToken.None);
+            }
+            catch (Exception ex)
+            {
+                Trace.Error("Fail to raise JobCompletedEvent back to service.");
+                Trace.Error(ex);
+            }
+        }
+
        private class WorkerDispatcher : IDisposable
        {
            public long RequestId { get; }
--- a/src/Runner.Listener/Runner.cs
+++ b/src/Runner.Listener/Runner.cs
@@ -234,7 +234,7 @@ namespace GitHub.Runner.Listener
                    HostContext.StartupType = startType;

                    // Run the runner interactively or as service
-                    return await RunAsync(settings, command.RunOnce);
+                    return await RunAsync(settings, command.RunOnce || settings.Ephemeral);  // TODO: Remove RunOnce later.
                }
                else
                {
@@ -466,8 +466,16 @@ namespace GitHub.Runner.Listener
                        await jobDispatcher.ShutdownAsync();
                    }

-                    //TODO: make sure we don't mask more important exception
+                    try
+                    {
                        await _listener.DeleteSessionAsync();
+                    }
+                    catch (Exception ex) when (runOnce)
+                    {
+                        // ignore exception during delete session for ephemeral runner since the runner might already be deleted from the server side
+                        // and the delete session call will ends up with 401.
+                        Trace.Info($"Ignore any exception during DeleteSession for an ephemeral runner. {ex}");
+                    }

                    messageQueueLoopTokenSource.Dispose();
                }
@@ -512,7 +520,9 @@ Config Options:
 --labels string        Extra labels in addition to the default: 'self-hosted,{Constants.Runner.Platform},{Constants.Runner.PlatformArchitecture}'
 --work string          Relative runner work directory (default {Constants.Path.WorkDirectory})
 --replace              Replace any existing runner with the same name (default false)
- --pat                  GitHub personal access token used for checking network connectivity when executing `.{separator}run.{ext} --check`");
+ --pat                  GitHub personal access token used for checking network connectivity when executing `.{separator}run.{ext} --check`
+ --ephemeral            Configure the runner to only take one job and then let the service un-configure the runner after the job finishes (default false)");
+
 #if OS_WINDOWS
    _term.WriteLine($@" --runasservice   Run the runner as a service");
    _term.WriteLine($@" --windowslogonaccount string   Account to run the service as. Requires runasservice");
--- a/src/Runner.Listener/SelfUpdater.cs
+++ b/src/Runner.Listener/SelfUpdater.cs
@@ -74,10 +74,12 @@ namespace GitHub.Runner.Listener
                await jobDispatcher.WaitAsync(token);
                Trace.Info($"All running job has exited.");

+                // We need to keep runner backup around for macOS until we fixed https://github.com/actions/runner/issues/743
+#if !OS_OSX
                // delete runner backup
                DeletePreviousVersionRunnerBackup(token);
                Trace.Info($"Delete old version runner backup.");
-
+#endif
                // generate update script from template
                await UpdateRunnerUpdateStateAsync("Generate and execute update script.");

@@ -96,7 +98,7 @@ namespace GitHub.Runner.Listener
                invokeScript.Start();
                Trace.Info($"Update script start running");

-                await UpdateRunnerUpdateStateAsync("Runner will exit shortly for update, should back online within 10 seconds.");
+                await UpdateRunnerUpdateStateAsync("Runner will exit shortly for update, should be back online within 10 seconds.");

                return true;
            }
--- a/src/Runner.Worker/ActionCommandManager.cs
+++ b/src/Runner.Worker/ActionCommandManager.cs
@@ -295,8 +295,21 @@ namespace GitHub.Runner.Worker
            {
                throw new Exception("Required field 'name' is missing in ##[save-state] command.");
            }
-
+            // Embedded steps (composite) keep track of the state at the root level
+            if (context.IsEmbedded)
+            {
+                var id = context.EmbeddedId;
+                if (!context.Root.EmbeddedIntraActionState.ContainsKey(id))
+                {
+                    context.Root.EmbeddedIntraActionState[id] = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                }
+                context.Root.EmbeddedIntraActionState[id][stateName] = command.Data;
+            }
+            // Otherwise modify the ExecutionContext
+            else
+            {
                context.IntraActionState[stateName] = command.Data;
+            }
            context.Debug($"Save intra-action state {stateName} = {command.Data}");
        }

--- a/src/Runner.Worker/ActionManager.cs
+++ b/src/Runner.Worker/ActionManager.cs
@@ -37,7 +37,10 @@ namespace GitHub.Runner.Worker
    public interface IActionManager : IRunnerService
    {
        Dictionary<Guid, ContainerInfo> CachedActionContainers { get; }
-        Task<PrepareResult> PrepareActionsAsync(IExecutionContext executionContext, IEnumerable<Pipelines.JobStep> steps);
+        Dictionary<Guid, List<Pipelines.ActionStep>> CachedEmbeddedPreSteps { get; }
+        Dictionary<Guid, List<Guid>> CachedEmbeddedStepIds { get; }
+        Dictionary<Guid, Stack<Pipelines.ActionStep>> CachedEmbeddedPostSteps { get; }
+        Task<PrepareResult> PrepareActionsAsync(IExecutionContext executionContext, IEnumerable<Pipelines.JobStep> steps, Guid rootStepId = default(Guid));
        Definition LoadAction(IExecutionContext executionContext, Pipelines.ActionStep action);
    }

@@ -48,10 +51,20 @@ namespace GitHub.Runner.Worker
        //81920 is the default used by System.IO.Stream.CopyTo and is under the large object heap threshold (85k).
        private const int _defaultCopyBufferSize = 81920;
        private const string _dotcomApiUrl = "https://api.github.com";
-        private readonly Dictionary<Guid, ContainerInfo> _cachedActionContainers = new Dictionary<Guid, ContainerInfo>();

+        private readonly Dictionary<Guid, ContainerInfo> _cachedActionContainers = new Dictionary<Guid, ContainerInfo>();
        public Dictionary<Guid, ContainerInfo> CachedActionContainers => _cachedActionContainers;
-        public async Task<PrepareResult> PrepareActionsAsync(IExecutionContext executionContext, IEnumerable<Pipelines.JobStep> steps)
+
+        private readonly Dictionary<Guid, List<Pipelines.ActionStep>> _cachedEmbeddedPreSteps = new Dictionary<Guid, List<Pipelines.ActionStep>>();
+        public Dictionary<Guid, List<Pipelines.ActionStep>> CachedEmbeddedPreSteps => _cachedEmbeddedPreSteps;
+
+        private readonly Dictionary<Guid, List<Guid>> _cachedEmbeddedStepIds = new Dictionary<Guid, List<Guid>>();
+        public Dictionary<Guid, List<Guid>> CachedEmbeddedStepIds => _cachedEmbeddedStepIds;
+
+        private readonly Dictionary<Guid, Stack<Pipelines.ActionStep>> _cachedEmbeddedPostSteps = new Dictionary<Guid, Stack<Pipelines.ActionStep>>();
+        public Dictionary<Guid, Stack<Pipelines.ActionStep>> CachedEmbeddedPostSteps => _cachedEmbeddedPostSteps;
+
+        public async Task<PrepareResult> PrepareActionsAsync(IExecutionContext executionContext, IEnumerable<Pipelines.JobStep> steps, Guid rootStepId = default(Guid))
        {
            // Assert inputs
            ArgUtil.NotNull(executionContext, nameof(executionContext));
@@ -64,10 +77,30 @@ namespace GitHub.Runner.Worker
                PreStepTracker = new Dictionary<Guid, IActionRunner>()
            };
            var containerSetupSteps = new List<JobExtensionRunner>();
+            var depth = 0;
+            // We are running at the start of a job
+            if (rootStepId == default(Guid))
+            {
                IOUtil.DeleteDirectory(HostContext.GetDirectory(WellKnownDirectory.Actions), executionContext.CancellationToken);
+            }
+            // We are running mid job due to a local composite action
+            else
+            {
+                if (!_cachedEmbeddedStepIds.ContainsKey(rootStepId))
+                {
+                    _cachedEmbeddedStepIds[rootStepId] = new List<Guid>();
+                    foreach (var compositeStep in steps)
+                    {
+                        var guid = Guid.NewGuid();
+                        compositeStep.Id = guid;
+                        _cachedEmbeddedStepIds[rootStepId].Add(guid);
+                    }
+                }
+                depth = 1;
+            }
            IEnumerable<Pipelines.ActionStep> actions = steps.OfType<Pipelines.ActionStep>();
            executionContext.Output("Prepare all required actions");
-            var result = await PrepareActionsRecursiveAsync(executionContext, state, actions, 0);
+            var result = await PrepareActionsRecursiveAsync(executionContext, state, actions, depth, rootStepId);
            if (state.ImagesToPull.Count > 0)
            {
                foreach (var imageToPull in result.ImagesToPull)
@@ -103,7 +136,7 @@ namespace GitHub.Runner.Worker
            return new PrepareResult(containerSetupSteps, result.PreStepTracker);
        }

-        private async Task<PrepareActionsState> PrepareActionsRecursiveAsync(IExecutionContext executionContext, PrepareActionsState state, IEnumerable<Pipelines.ActionStep> actions, Int32 depth = 0)
+        private async Task<PrepareActionsState> PrepareActionsRecursiveAsync(IExecutionContext executionContext, PrepareActionsState state, IEnumerable<Pipelines.ActionStep> actions, Int32 depth = 0, Guid parentStepId = default(Guid))
        {
            ArgUtil.NotNull(executionContext, nameof(executionContext));
            if (depth > Constants.CompositeActionsMaxDepth)
@@ -187,25 +220,52 @@ namespace GitHub.Runner.Worker
                            state.ImagesToBuildInfo[setupInfo.Container.ActionRepository] = setupInfo.Container;
                        }
                    }
-                    else if(setupInfo != null && setupInfo.Steps != null && setupInfo.Steps.Count > 0)
+                    else if (setupInfo != null && setupInfo.Steps != null && setupInfo.Steps.Count > 0)
                    {
-                        state = await PrepareActionsRecursiveAsync(executionContext, state, setupInfo.Steps, depth + 1);
+                        state = await PrepareActionsRecursiveAsync(executionContext, state, setupInfo.Steps, depth + 1, action.Id);
                    }
                    var repoAction = action.Reference as Pipelines.RepositoryPathReference;
                    if (repoAction.RepositoryType != Pipelines.PipelineConstants.SelfAlias)
                    {
                        var definition = LoadAction(executionContext, action);
-                        // TODO: Support pre's in composite actions
-                        if (definition.Data.Execution.HasPre && depth < 1)
+                        if (definition.Data.Execution.HasPre)
+                        {
+                            Trace.Info($"Add 'pre' execution for {action.Id}");
+                            // Root Step
+                            if (depth < 1)
                            {
                                var actionRunner = HostContext.CreateService<IActionRunner>();
                                actionRunner.Action = action;
                                actionRunner.Stage = ActionRunStage.Pre;
                                actionRunner.Condition = definition.Data.Execution.InitCondition;
-
-                            Trace.Info($"Add 'pre' execution for {action.Id}");
                                state.PreStepTracker[action.Id] = actionRunner;
                            }
+                            // Embedded Step
+                            else
+                            {
+                                if (!_cachedEmbeddedPreSteps.ContainsKey(parentStepId))
+                                {
+                                    _cachedEmbeddedPreSteps[parentStepId] = new List<Pipelines.ActionStep>();
+                                }
+                                // Clone action so we can modify the condition without affecting the original
+                                var clonedAction = action.Clone() as Pipelines.ActionStep;
+                                clonedAction.Condition = definition.Data.Execution.InitCondition;
+                                _cachedEmbeddedPreSteps[parentStepId].Add(clonedAction);
+                            }
+                        }
+
+                        if (definition.Data.Execution.HasPost && depth > 0)
+                        {
+                            if (!_cachedEmbeddedPostSteps.ContainsKey(parentStepId))
+                            {
+                                // If we haven't done so already, add the parent to the post steps
+                                _cachedEmbeddedPostSteps[parentStepId] = new Stack<Pipelines.ActionStep>();
+                            }
+                            // Clone action so we can modify the condition without affecting the original
+                            var clonedAction = action.Clone() as Pipelines.ActionStep;
+                            clonedAction.Condition = definition.Data.Execution.CleanupCondition;
+                            _cachedEmbeddedPostSteps[parentStepId].Push(clonedAction);
+                        }
                    }
                }
            }
@@ -355,6 +415,29 @@ namespace GitHub.Runner.Worker
                        Trace.Verbose($"Details: {StringUtil.ConvertToJson(compositeAction?.Steps)}");
                        Trace.Info($"Load: {compositeAction.Outputs?.Count ?? 0} number of outputs");
                        Trace.Info($"Details: {StringUtil.ConvertToJson(compositeAction?.Outputs)}");
+
+                        if (CachedEmbeddedPreSteps.TryGetValue(action.Id, out var preSteps))
+                        {
+                            compositeAction.PreSteps = preSteps;
+                        }
+
+                        if (CachedEmbeddedPostSteps.TryGetValue(action.Id, out var postSteps))
+                        {
+                            compositeAction.PostSteps = postSteps;
+                        }
+
+                        if (_cachedEmbeddedStepIds.ContainsKey(action.Id))
+                        {
+                            for (var i = 0; i < compositeAction.Steps.Count; i++)
+                            {
+                                // Store Id's for later load actions
+                                compositeAction.Steps[i].Id = _cachedEmbeddedStepIds[action.Id][i];
+                                if (string.IsNullOrEmpty(executionContext.Global.Variables.Get("DistributedTask.EnableCompositeActions")) && compositeAction.Steps[i].Reference.Type != Pipelines.ActionSourceType.Script)
+                                {
+                                    throw new Exception("`uses:` keyword is not currently supported.");
+                                }
+                            }
+                        }
                    }
                    else
                    {
@@ -527,6 +610,7 @@ namespace GitHub.Runner.Worker
                    {
                        NameWithOwner = repositoryReference.Name,
                        Ref = repositoryReference.Ref,
+                        Path = repositoryReference.Path,
                    };
                })
                .ToList();
@@ -620,7 +704,7 @@ namespace GitHub.Runner.Worker
                // make sure we get a clean folder ready to use.
                IOUtil.DeleteDirectory(destDirectory, executionContext.CancellationToken);
                Directory.CreateDirectory(destDirectory);
-                executionContext.Output($"Download action repository '{downloadInfo.NameWithOwner}@{downloadInfo.Ref}'");
+                executionContext.Output($"Download action repository '{downloadInfo.NameWithOwner}@{downloadInfo.Ref}' (SHA:{downloadInfo.ResolvedSha})");
            }

            await DownloadRepositoryActionAsync(executionContext, downloadInfo, destDirectory);
@@ -928,20 +1012,30 @@ namespace GitHub.Runner.Worker
                }
                else if (actionDefinitionData.Execution.ExecutionType == ActionExecutionType.Composite)
                {
-                    // TODO: we need to generate unique Id's for composite steps
                    Trace.Info($"Loading Composite steps");
                    var compositeAction = actionDefinitionData.Execution as CompositeActionExecutionData;
                    setupInfo.Steps = compositeAction.Steps;

+                    // cache steps ids if not done so already
+                    if (!_cachedEmbeddedStepIds.ContainsKey(repositoryAction.Id))
+                    {
+                        _cachedEmbeddedStepIds[repositoryAction.Id] = new List<Guid>();
+                        foreach (var compositeStep in compositeAction.Steps)
+                        {
+                            var guid = Guid.NewGuid();
+                            compositeStep.Id = guid;
+                            _cachedEmbeddedStepIds[repositoryAction.Id].Add(guid);
+                        }
+                    }
+
+                    // TODO: remove once we remove the DistributedTask.EnableCompositeActions FF
                    foreach (var step in compositeAction.Steps)
                    {
-                        step.Id = Guid.NewGuid();
                        if (string.IsNullOrEmpty(executionContext.Global.Variables.Get("DistributedTask.EnableCompositeActions")) && step.Reference.Type != Pipelines.ActionSourceType.Script)
                        {
                            throw new Exception("`uses:` keyword is not currently supported.");
                        }
                    }
-
                    return setupInfo;
                }
                else
@@ -1102,9 +1196,11 @@ namespace GitHub.Runner.Worker
    public sealed class CompositeActionExecutionData : ActionExecutionData
    {
        public override ActionExecutionType ExecutionType => ActionExecutionType.Composite;
-        public override bool HasPre => false;
-        public override bool HasPost => false;
+        public override bool HasPre => PreSteps.Count > 0;
+        public override bool HasPost => PostSteps.Count > 0;
+        public List<Pipelines.ActionStep> PreSteps { get; set; }
        public List<Pipelines.ActionStep> Steps { get; set; }
+        public Stack<Pipelines.ActionStep> PostSteps { get; set; }
        public MappingToken Outputs { get; set; }
    }

@@ -1168,7 +1264,7 @@ namespace GitHub.Runner.Worker
    public class ActionSetupInfo
    {
        public ActionContainer Container { get; set; }
-        public List<Pipelines.ActionStep> Steps {get; set;}
+        public List<Pipelines.ActionStep> Steps { get; set; }
    }

    public class PrepareActionsState
--- a/src/Runner.Worker/ActionManifestManager.cs
+++ b/src/Runner.Worker/ActionManifestManager.cs
@@ -480,6 +480,10 @@ namespace GitHub.Runner.Worker
                        return new CompositeActionExecutionData()
                        {
                            Steps = steps.Cast<Pipelines.ActionStep>().ToList(),
+                            PreSteps = new List<Pipelines.ActionStep>(),
+                            PostSteps = new Stack<Pipelines.ActionStep>(),
+                            InitCondition = "always()",
+                            CleanupCondition = "always()",
                            Outputs = outputs
                        };
                    }
--- a/src/Runner.Worker/ActionRunner.cs
+++ b/src/Runner.Worker/ActionRunner.cs
@@ -82,6 +82,28 @@ namespace GitHub.Runner.Worker
            ActionExecutionData handlerData = definition.Data?.Execution;
            ArgUtil.NotNull(handlerData, nameof(handlerData));

+            List<JobExtensionRunner> localActionContainerSetupSteps = null;
+            // Handle Composite Local Actions
+            // Need to download and expand the tree of referenced actions
+            if (handlerData.ExecutionType == ActionExecutionType.Composite &&
+                handlerData is CompositeActionExecutionData compositeHandlerData &&
+                Stage == ActionRunStage.Main &&
+                Action.Reference is Pipelines.RepositoryPathReference localAction &&
+                string.Equals(localAction.RepositoryType, Pipelines.PipelineConstants.SelfAlias, StringComparison.OrdinalIgnoreCase))
+            {
+                var actionManager = HostContext.GetService<IActionManager>();
+                var prepareResult = await actionManager.PrepareActionsAsync(ExecutionContext, compositeHandlerData.Steps, ExecutionContext.Id);
+
+                // Reload definition since post may exist now (from embedded steps that were JIT downloaded)
+                definition = taskManager.LoadAction(ExecutionContext, Action);
+                ArgUtil.NotNull(definition, nameof(definition));
+                handlerData = definition.Data?.Execution;
+                ArgUtil.NotNull(handlerData, nameof(handlerData));
+
+                // Save container setup steps so we can reference them later
+                localActionContainerSetupSteps = prepareResult.ContainerSetupSteps;
+            }
+
            if (handlerData.HasPre &&
                Action.Reference is Pipelines.RepositoryPathReference repoAction &&
                string.Equals(repoAction.RepositoryType, Pipelines.PipelineConstants.SelfAlias, StringComparison.OrdinalIgnoreCase))
@@ -249,7 +271,8 @@ namespace GitHub.Runner.Worker
                            inputs,
                            environment,
                            ExecutionContext.Global.Variables,
-                            actionDirectory: definition.Directory);
+                            actionDirectory: definition.Directory,
+                            localActionContainerSetupSteps: localActionContainerSetupSteps);

            // Print out action details
            handler.PrintActionDetails(Stage);
--- a/src/Runner.Worker/ConditionTraceWriter.cs
+++ b/src/Runner.Worker/ConditionTraceWriter.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Text;
+using GitHub.DistributedTask.Pipelines;
+using GitHub.Runner.Common;
+using GitHub.Runner.Sdk;
+using ObjectTemplating = GitHub.DistributedTask.ObjectTemplating;
+
+namespace GitHub.Runner.Worker
+{
+    public sealed class ConditionTraceWriter : ObjectTemplating::ITraceWriter
+    {
+        private readonly IExecutionContext _executionContext;
+        private readonly Tracing _trace;
+        private readonly StringBuilder _traceBuilder = new StringBuilder();
+
+        public string Trace => _traceBuilder.ToString();
+
+        public ConditionTraceWriter(Tracing trace, IExecutionContext executionContext)
+        {
+            ArgUtil.NotNull(trace, nameof(trace));
+            _trace = trace;
+            _executionContext = executionContext;
+        }
+
+        public void Error(string format, params Object[] args)
+        {
+            var message = StringUtil.Format(format, args);
+            _trace.Error(message);
+            _executionContext?.Debug(message);
+        }
+
+        public void Info(string format, params Object[] args)
+        {
+            var message = StringUtil.Format(format, args);
+            _trace.Info(message);
+            _executionContext?.Debug(message);
+            _traceBuilder.AppendLine(message);
+        }
+
+        public void Verbose(string format, params Object[] args)
+        {
+            var message = StringUtil.Format(format, args);
+            _trace.Verbose(message);
+            _executionContext?.Debug(message);
+        }
+    }
+}
--- a/src/Runner.Worker/ContainerOperationProvider.cs
+++ b/src/Runner.Worker/ContainerOperationProvider.cs
@@ -494,7 +494,8 @@ namespace GitHub.Runner.Worker
        private void UpdateRegistryAuthForGitHubToken(IExecutionContext executionContext, ContainerInfo container)
        {
            var registryIsTokenCompatible = container.RegistryServer.Equals("ghcr.io", StringComparison.OrdinalIgnoreCase) || container.RegistryServer.Equals("containers.pkg.github.com", StringComparison.OrdinalIgnoreCase);
-            if (!registryIsTokenCompatible)
+            var isFallbackTokenFromHostedGithub = HostContext.GetService<IConfigurationStore>().GetSettings().IsHostedServer;
+            if (!registryIsTokenCompatible || !isFallbackTokenFromHostedGithub)
            {
                return;
            }
--- a/src/Runner.Worker/ExecutionContext.cs
+++ b/src/Runner.Worker/ExecutionContext.cs
@@ -36,7 +36,9 @@ namespace GitHub.Runner.Worker
    public interface IExecutionContext : IRunnerService
    {
        Guid Id { get; }
+        Guid EmbeddedId { get; }
        string ScopeName { get; }
+        string SiblingScopeName { get; }
        string ContextName { get; }
        Task ForceCompleted { get; }
        TaskResult? Result { get; set; }
@@ -49,6 +51,7 @@ namespace GitHub.Runner.Worker
        Dictionary<string, string> IntraActionState { get; }
        Dictionary<string, VariableValue> JobOutputs { get; }
        ActionsEnvironmentReference ActionsEnvironment { get; }
+        List<ActionsStepTelemetry> ActionsStepsTelemetry { get; }
        DictionaryContextData ExpressionValues { get; }
        IList<IFunctionInfo> ExpressionFunctions { get; }
        JobContext JobContext { get; }
@@ -58,6 +61,10 @@ namespace GitHub.Runner.Worker

        // Only job level ExecutionContext has PostJobSteps
        Stack<IStep> PostJobSteps { get; }
+        HashSet<Guid> EmbeddedStepsWithPostRegistered{ get; }
+
+        // Keep track of embedded steps states
+        Dictionary<Guid, Dictionary<string, string>> EmbeddedIntraActionState { get; }

        bool EchoOnActionCommand { get; set; }

@@ -68,8 +75,8 @@ namespace GitHub.Runner.Worker
        // Initialize
        void InitializeJob(Pipelines.AgentJobRequestMessage message, CancellationToken token);
        void CancelToken();
-        IExecutionContext CreateChild(Guid recordId, string displayName, string refName, string scopeName, string contextName, Dictionary<string, string> intraActionState = null, int? recordOrder = null, IPagingLogger logger = null, bool isEmbedded = false, CancellationTokenSource cancellationTokenSource = null);
-        IExecutionContext CreateEmbeddedChild(string scopeName, string contextName);
+        IExecutionContext CreateChild(Guid recordId, string displayName, string refName, string scopeName, string contextName, Dictionary<string, string> intraActionState = null, int? recordOrder = null, IPagingLogger logger = null, bool isEmbedded = false, CancellationTokenSource cancellationTokenSource = null, Guid embeddedId = default(Guid), string siblingScopeName = null);
+        IExecutionContext CreateEmbeddedChild(string scopeName, string contextName, Guid embeddedId, Dictionary<string, string> intraActionState = null, string siblingScopeName = null);

        // logging
        long Write(string tag, string message);
@@ -132,7 +139,9 @@ namespace GitHub.Runner.Worker
        private long _totalThrottlingDelayInMilliseconds = 0;

        public Guid Id => _record.Id;
+        public Guid EmbeddedId { get; private set; }
        public string ScopeName { get; private set; }
+        public string SiblingScopeName { get; private set; }
        public string ContextName { get; private set; }
        public Task ForceCompleted => _forceCompleted.Task;
        public CancellationToken CancellationToken => _cancellationTokenSource.Token;
@@ -140,6 +149,7 @@ namespace GitHub.Runner.Worker
        public Dictionary<string, VariableValue> JobOutputs { get; private set; }

        public ActionsEnvironmentReference ActionsEnvironment { get; private set; }
+        public List<ActionsStepTelemetry> ActionsStepsTelemetry { get; private set; }
        public DictionaryContextData ExpressionValues { get; } = new DictionaryContextData();
        public IList<IFunctionInfo> ExpressionFunctions { get; } = new List<IFunctionInfo>();

@@ -155,6 +165,11 @@ namespace GitHub.Runner.Worker
        // Only job level ExecutionContext has StepsWithPostRegistered
        public HashSet<Guid> StepsWithPostRegistered { get; private set; }

+        // Only job level ExecutionContext has EmbeddedStepsWithPostRegistered
+        public HashSet<Guid> EmbeddedStepsWithPostRegistered { get; private set; }
+
+        public Dictionary<Guid, Dictionary<string, string>> EmbeddedIntraActionState { get; private set; }
+
        public bool EchoOnActionCommand { get; set; }

        // An embedded execution context shares the same record ID, record name, and logger
@@ -245,23 +260,30 @@ namespace GitHub.Runner.Worker

        public void RegisterPostJobStep(IStep step)
        {
-            // TODO: Remove when we support composite post job steps
+            string siblingScopeName = null;
            if (this.IsEmbedded)
            {
-                throw new Exception("Composite actions do not currently support post steps");
-
+                if (step is IActionRunner actionRunner && !Root.EmbeddedStepsWithPostRegistered.Add(actionRunner.Action.Id))
+                {
+                    Trace.Info($"'post' of '{actionRunner.DisplayName}' already push to child post step stack.");
                }
-            if (step is IActionRunner actionRunner && !Root.StepsWithPostRegistered.Add(actionRunner.Action.Id))
+                return;
+            } 
+            else if (step is IActionRunner actionRunner && !Root.StepsWithPostRegistered.Add(actionRunner.Action.Id))
            {
                Trace.Info($"'post' of '{actionRunner.DisplayName}' already push to post step stack.");
                return;
            }
+            if (step is IActionRunner runner)
+            {
+                siblingScopeName = runner.Action.ContextName;
+            }

-            step.ExecutionContext = Root.CreatePostChild(step.DisplayName, IntraActionState);
+            step.ExecutionContext = Root.CreatePostChild(step.DisplayName, IntraActionState, siblingScopeName);
            Root.PostJobSteps.Push(step);
        }

-        public IExecutionContext CreateChild(Guid recordId, string displayName, string refName, string scopeName, string contextName, Dictionary<string, string> intraActionState = null, int? recordOrder = null, IPagingLogger logger = null, bool isEmbedded = false, CancellationTokenSource cancellationTokenSource = null)
+        public IExecutionContext CreateChild(Guid recordId, string displayName, string refName, string scopeName, string contextName, Dictionary<string, string> intraActionState = null, int? recordOrder = null, IPagingLogger logger = null, bool isEmbedded = false, CancellationTokenSource cancellationTokenSource = null, Guid embeddedId = default(Guid), string siblingScopeName = null)
        {
            Trace.Entering();

@@ -270,6 +292,8 @@ namespace GitHub.Runner.Worker
            child.Global = Global;
            child.ScopeName = scopeName;
            child.ContextName = contextName;
+            child.EmbeddedId = embeddedId;
+            child.SiblingScopeName = siblingScopeName;
            if (intraActionState == null)
            {
                child.IntraActionState = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
@@ -317,9 +341,9 @@ namespace GitHub.Runner.Worker
        /// An embedded execution context shares the same record ID, record name, logger,
        /// and a linked cancellation token.
        /// </summary>
-        public IExecutionContext CreateEmbeddedChild(string scopeName, string contextName)
+        public IExecutionContext CreateEmbeddedChild(string scopeName, string contextName, Guid embeddedId, Dictionary<string, string> intraActionState = null, string siblingScopeName = null)
        {
-            return Root.CreateChild(_record.Id, _record.Name, _record.Id.ToString("N"), scopeName, contextName, logger: _logger, isEmbedded: true, cancellationTokenSource: CancellationTokenSource.CreateLinkedTokenSource(_cancellationTokenSource.Token));
+            return Root.CreateChild(_record.Id, _record.Name, _record.Id.ToString("N"), scopeName, contextName, logger: _logger, isEmbedded: true, cancellationTokenSource: CancellationTokenSource.CreateLinkedTokenSource(_cancellationTokenSource.Token), intraActionState: intraActionState, embeddedId: embeddedId, siblingScopeName: siblingScopeName);
        }

        public void Start(string currentOperation = null)
@@ -375,7 +399,7 @@ namespace GitHub.Runner.Worker

            _logger.End();

-            // Skip if generated context name. Generated context names start with "__". After M271-ish the server will never send an empty context name.
+            // Skip if generated context name. Generated context names start with "__". After 3.2 the server will never send an empty context name.
            if (!string.IsNullOrEmpty(ContextName) && !ContextName.StartsWith("__", StringComparison.Ordinal))
            {
                Global.StepsContext.SetOutcome(ScopeName, ContextName, (Outcome ?? Result ?? TaskResult.Succeeded).ToActionResult());
@@ -438,7 +462,7 @@ namespace GitHub.Runner.Worker
        {
            ArgUtil.NotNullOrEmpty(name, nameof(name));

-            // Skip if generated context name. Generated context names start with "__". After M271-ish the server will never send an empty context name.
+            // Skip if generated context name. Generated context names start with "__". After 3.2 the server will never send an empty context name.
            if (string.IsNullOrEmpty(ContextName) || ContextName.StartsWith("__", StringComparison.Ordinal))
            {
                reference = null;
@@ -623,6 +647,9 @@ namespace GitHub.Runner.Worker
            // Actions environment
            ActionsEnvironment = message.ActionsEnvironment;

+            // ActionsStepTelemetry
+            ActionsStepsTelemetry = new List<ActionsStepTelemetry>();
+
            // Service container info
            Global.ServiceContainers = new List<ContainerInfo>();

@@ -683,6 +710,12 @@ namespace GitHub.Runner.Worker
            // StepsWithPostRegistered for job ExecutionContext
            StepsWithPostRegistered = new HashSet<Guid>();

+            // EmbeddedStepsWithPostRegistered for job ExecutionContext
+            EmbeddedStepsWithPostRegistered = new HashSet<Guid>();
+
+            // EmbeddedIntraActionState for job ExecutionContext
+            EmbeddedIntraActionState = new Dictionary<Guid, Dictionary<string,string>>();
+
            // Job timeline record.
            InitializeTimelineRecord(
                timelineId: message.Timeline.Id,
@@ -889,7 +922,7 @@ namespace GitHub.Runner.Worker
            }
        }

-        private IExecutionContext CreatePostChild(string displayName, Dictionary<string, string> intraActionState)
+        private IExecutionContext CreatePostChild(string displayName, Dictionary<string, string> intraActionState, string siblingScopeName = null)
        {
            if (!_expandedForPostJob)
            {
@@ -899,7 +932,7 @@ namespace GitHub.Runner.Worker
            }

            var newGuid = Guid.NewGuid();
-            return CreateChild(newGuid, displayName, newGuid.ToString("N"), null, null, intraActionState, _childTimelineRecordOrder - Root.PostJobSteps.Count);
+            return CreateChild(newGuid, displayName, newGuid.ToString("N"), null, null, intraActionState, _childTimelineRecordOrder - Root.PostJobSteps.Count, siblingScopeName: siblingScopeName);
        }
    }

--- a/src/Runner.Worker/Handlers/CompositeActionHandler.cs
+++ b/src/Runner.Worker/Handlers/CompositeActionHandler.cs
@@ -11,6 +11,7 @@ using GitHub.DistributedTask.Pipelines.ContextData;
 using GitHub.DistributedTask.Pipelines.ObjectTemplating;
 using GitHub.DistributedTask.WebApi;
 using GitHub.Runner.Common;
+using GitHub.Runner.Common.Util;
 using GitHub.Runner.Sdk;
 using GitHub.Runner.Worker;
 using GitHub.Runner.Worker.Expressions;
@@ -34,7 +35,66 @@ namespace GitHub.Runner.Worker.Handlers
            Trace.Entering();
            ArgUtil.NotNull(ExecutionContext, nameof(ExecutionContext));
            ArgUtil.NotNull(Inputs, nameof(Inputs));
+
+            List<Pipelines.ActionStep> steps;
+
+            if (stage == ActionRunStage.Pre)
+            {
+                ArgUtil.NotNull(Data.PreSteps, nameof(Data.PreSteps));
+                steps = Data.PreSteps;
+            } 
+            else if (stage == ActionRunStage.Post)
+            {
+                ArgUtil.NotNull(Data.PostSteps, nameof(Data.PostSteps));
+                steps = new List<Pipelines.ActionStep>();
+                // Only register post steps for steps that actually ran
+                foreach (var step in Data.PostSteps.ToList())
+                {
+                    if (ExecutionContext.Root.EmbeddedStepsWithPostRegistered.Contains(step.Id))
+                    {
+                        steps.Add(step);
+                    }
+                    else
+                    {
+                        Trace.Info($"Skipping executing post step id: {step.Id}, name: ${step.DisplayName}");
+                    }
+                }
+            }  
+            else
+            {
                ArgUtil.NotNull(Data.Steps, nameof(Data.Steps));
+                steps = Data.Steps;
+            }
+
+            // Add Telemetry to JobContext to send with JobCompleteMessage
+            if (stage == ActionRunStage.Main)
+            {
+                var hasRunsStep = false;
+                var hasUsesStep = false;
+                foreach (var step in steps)
+                {
+                    if (step.Reference.Type == Pipelines.ActionSourceType.Script)
+                    {
+                        hasRunsStep = true;
+                    }
+                    else
+                    {
+                        hasUsesStep = true;
+                    }
+                }
+                var pathReference = Action as Pipelines.RepositoryPathReference;
+                var telemetry = new ActionsStepTelemetry {
+                    Ref = GetActionRef(),
+                    HasPreStep = Data.HasPre,
+                    HasPostStep = Data.HasPost,
+                    IsEmbedded = ExecutionContext.IsEmbedded,
+                    Type = "composite",
+                    HasRunsStep = hasRunsStep,
+                    HasUsesStep = hasUsesStep,
+                    StepCount = steps.Count
+                };
+                ExecutionContext.Root.ActionsStepsTelemetry.Add(telemetry);
+            }
            
            try
            {
@@ -45,7 +105,7 @@ namespace GitHub.Runner.Worker.Handlers
                    inputsData[i.Key] = new StringContextData(i.Value);
                }

-                // Temporary hack until after M271-ish. After M271-ish the server will never send an empty
+                // Temporary hack until after 3.2. After 3.2 the server will never send an empty
                // context name. Generated context names start with "__"
                var childScopeName = ExecutionContext.GetFullyQualifiedContextName();
                if (string.IsNullOrEmpty(childScopeName))
@@ -55,15 +115,44 @@ namespace GitHub.Runner.Worker.Handlers

                // Create embedded steps
                var embeddedSteps = new List<IStep>();
-                foreach (Pipelines.ActionStep stepData in Data.Steps)
+
+                 // If we need to setup containers beforehand, do it
+                // only relevant for local composite actions that need to JIT download/setup containers
+                if (LocalActionContainerSetupSteps != null && LocalActionContainerSetupSteps.Count > 0)
                {
+                    foreach (var step in LocalActionContainerSetupSteps)
+                    {
+                        ArgUtil.NotNull(step, step.DisplayName);
+                        var stepId = $"__{Guid.NewGuid()}";
+                        step.ExecutionContext = ExecutionContext.CreateEmbeddedChild(childScopeName, stepId, Guid.NewGuid());
+                        embeddedSteps.Add(step);
+                    }
+                }
+                foreach (Pipelines.ActionStep stepData in steps)
+                {
+                    // Compute child sibling scope names for post steps
+                    // We need to use the main's scope to keep step context correct, makes inputs flow correctly
+                    string siblingScopeName = null;
+                    if (!String.IsNullOrEmpty(ExecutionContext.SiblingScopeName) && stage == ActionRunStage.Post)
+                    {
+                        siblingScopeName = $"{ExecutionContext.SiblingScopeName}.{stepData.ContextName}";
+                    }
+
                    var step = HostContext.CreateService<IActionRunner>();
                    step.Action = stepData;
                    step.Stage = stage;
                    step.Condition = stepData.Condition;
-                    step.ExecutionContext = ExecutionContext.CreateEmbeddedChild(childScopeName, stepData.ContextName);
+                    ExecutionContext.Root.EmbeddedIntraActionState.TryGetValue(step.Action.Id, out var intraActionState);
+                    step.ExecutionContext = ExecutionContext.CreateEmbeddedChild(childScopeName, stepData.ContextName, step.Action.Id, intraActionState: intraActionState, siblingScopeName: siblingScopeName);
                    step.ExecutionContext.ExpressionValues["inputs"] = inputsData;
+                    if (!String.IsNullOrEmpty(ExecutionContext.SiblingScopeName))
+                    {
+                        step.ExecutionContext.ExpressionValues["steps"] = ExecutionContext.Global.StepsContext.GetScope(ExecutionContext.SiblingScopeName);
+                    }
+                    else
+                    {
                        step.ExecutionContext.ExpressionValues["steps"] = ExecutionContext.Global.StepsContext.GetScope(childScopeName);   
+                    }

                    // Shallow copy github context
                    var gitHubContext = step.ExecutionContext.ExpressionValues["github"] as GitHubContext;
@@ -78,13 +167,12 @@ namespace GitHub.Runner.Worker.Handlers
                }

                // Run embedded steps
-                await RunStepsAsync(embeddedSteps);
+                await RunStepsAsync(embeddedSteps, stage);

                // Set outputs
                ExecutionContext.ExpressionValues["inputs"] = inputsData;
                ExecutionContext.ExpressionValues["steps"] = ExecutionContext.Global.StepsContext.GetScope(childScopeName);
                ProcessOutputs();
-                ExecutionContext.Global.StepsContext.ClearScope(childScopeName);
            }
            catch (Exception ex)
            {
@@ -138,7 +226,7 @@ namespace GitHub.Runner.Worker.Handlers
            }
        }

-        private async Task RunStepsAsync(List<IStep> embeddedSteps)
+        private async Task RunStepsAsync(List<IStep> embeddedSteps, ActionRunStage stage)
        {
            ArgUtil.NotNull(embeddedSteps, nameof(embeddedSteps));

@@ -148,6 +236,10 @@ namespace GitHub.Runner.Worker.Handlers

                // Add Expression Functions
                step.ExecutionContext.ExpressionFunctions.Add(new FunctionInfo<HashFilesFunction>(PipelineTemplateConstants.HashFiles, 1, byte.MaxValue));
+                step.ExecutionContext.ExpressionFunctions.Add(new FunctionInfo<AlwaysFunction>(PipelineTemplateConstants.Always, 0, 0));
+                step.ExecutionContext.ExpressionFunctions.Add(new FunctionInfo<CancelledFunction>(PipelineTemplateConstants.Cancelled, 0, 0));
+                step.ExecutionContext.ExpressionFunctions.Add(new FunctionInfo<FailureFunction>(PipelineTemplateConstants.Failure, 0, 0));
+                step.ExecutionContext.ExpressionFunctions.Add(new FunctionInfo<SuccessFunction>(PipelineTemplateConstants.Success, 0, 0));

                // Initialize env context
                Trace.Info("Initialize Env context for embedded step");
@@ -178,9 +270,9 @@ namespace GitHub.Runner.Worker.Handlers
                    }
                }

-                var actionStep = step as IActionRunner;
-
                try
+                {
+                    if (step is IActionRunner actionStep)
                    {
                        // Evaluate and merge embedded-step env
                        var templateEvaluator = step.ExecutionContext.ToPipelineTemplateEvaluator();
@@ -190,6 +282,7 @@ namespace GitHub.Runner.Worker.Handlers
                            envContext[env.Key] = new StringContextData(env.Value ?? string.Empty);
                        }
                    }
+                }
                catch (Exception ex)
                {
                    // Evaluation error
@@ -198,16 +291,136 @@ namespace GitHub.Runner.Worker.Handlers
                    step.ExecutionContext.Complete(TaskResult.Failed);
                }

+                // Register Callback
+                CancellationTokenRegistration? jobCancelRegister = null;
+                try
+                {
+                    // For main steps just run the action
+                    if (stage == ActionRunStage.Main)
+                    {
                        await RunStepAsync(step);
+                    }
+                    // We need to evaluate conditions for pre/post steps
+                    else
+                    {
+                        // Register job cancellation call back only if job cancellation token not been fire before each step run
+                        if (!ExecutionContext.Root.CancellationToken.IsCancellationRequested)
+                        {
+                            // Test the condition again. The job was canceled after the condition was originally evaluated.
+                            jobCancelRegister = ExecutionContext.Root.CancellationToken.Register(() =>
+                            {
+                                // Mark job as cancelled
+                                ExecutionContext.Root.Result = TaskResult.Canceled;
+                                ExecutionContext.Root.JobContext.Status = ExecutionContext.Root.Result?.ToActionResult();
+
+                                step.ExecutionContext.Debug($"Re-evaluate condition on job cancellation for step: '{step.DisplayName}'.");
+                                var conditionReTestTraceWriter = new ConditionTraceWriter(Trace, null); // host tracing only
+                                var conditionReTestResult = false;
+                                if (HostContext.RunnerShutdownToken.IsCancellationRequested)
+                                {
+                                    step.ExecutionContext.Debug($"Skip Re-evaluate condition on runner shutdown.");
+                                }
+                                else
+                                {
+                                    try
+                                    {
+                                        var templateEvaluator = step.ExecutionContext.ToPipelineTemplateEvaluator(conditionReTestTraceWriter);
+                                        var condition = new BasicExpressionToken(null, null, null, step.Condition);
+                                        conditionReTestResult = templateEvaluator.EvaluateStepIf(condition, step.ExecutionContext.ExpressionValues, step.ExecutionContext.ExpressionFunctions, step.ExecutionContext.ToExpressionState());
+                                    }
+                                    catch (Exception ex)
+                                    {
+                                        // Cancel the step since we get exception while re-evaluate step condition
+                                        Trace.Info("Caught exception from expression when re-test condition on job cancellation.");
+                                        step.ExecutionContext.Error(ex);
+                                    }
+                                }
+
+                                if (!conditionReTestResult)
+                                {
+                                    // Cancel the step
+                                    Trace.Info("Cancel current running step.");
+                                    step.ExecutionContext.CancelToken();
+                                }
+                            });
+                        }
+                        else
+                        {
+                            if (ExecutionContext.Root.Result != TaskResult.Canceled)
+                            {
+                                // Mark job as cancelled
+                                ExecutionContext.Root.Result = TaskResult.Canceled;
+                                ExecutionContext.Root.JobContext.Status = ExecutionContext.Root.Result?.ToActionResult();
+                            }
+                        }
+                        // Evaluate condition
+                        step.ExecutionContext.Debug($"Evaluating condition for step: '{step.DisplayName}'");
+                        var conditionTraceWriter = new ConditionTraceWriter(Trace, step.ExecutionContext);
+                        var conditionResult = false;
+                        var conditionEvaluateError = default(Exception);
+                        if (HostContext.RunnerShutdownToken.IsCancellationRequested)
+                        {
+                            step.ExecutionContext.Debug($"Skip evaluate condition on runner shutdown.");
+                        }
+                        else
+                        {
+                            try
+                            {
+                                var templateEvaluator = step.ExecutionContext.ToPipelineTemplateEvaluator(conditionTraceWriter);
+                                var condition = new BasicExpressionToken(null, null, null, step.Condition);
+                                conditionResult = templateEvaluator.EvaluateStepIf(condition, step.ExecutionContext.ExpressionValues, step.ExecutionContext.ExpressionFunctions, step.ExecutionContext.ToExpressionState());
+                            }
+                            catch (Exception ex)
+                            {
+                                Trace.Info("Caught exception from expression.");
+                                Trace.Error(ex);
+                                conditionEvaluateError = ex;
+                            }
+                        }
+                        if (!conditionResult && conditionEvaluateError == null)
+                        {
+                            // Condition is false
+                            Trace.Info("Skipping step due to condition evaluation.");
+                            step.ExecutionContext.Result = TaskResult.Skipped;
+                            continue;
+                        }
+                        else if (conditionEvaluateError != null)
+                        {
+                            // Condition error
+                            step.ExecutionContext.Error(conditionEvaluateError);
+                            step.ExecutionContext.Result = TaskResult.Failed;
+                            ExecutionContext.Result = TaskResult.Failed;
+                            break;
+                        }
+                        else
+                        {
+                            await RunStepAsync(step);
+                        }
+                    }
+                }
+                finally
+                {
+                    if (jobCancelRegister != null)
+                    {
+                        jobCancelRegister?.Dispose();
+                        jobCancelRegister = null;
+                    }
+                }

                // Check failed or canceled
                if (step.ExecutionContext.Result == TaskResult.Failed || step.ExecutionContext.Result == TaskResult.Canceled)
                {
-                    ExecutionContext.Result = step.ExecutionContext.Result;
+                    Trace.Info($"Update job result with current composite step result '{step.ExecutionContext.Result}'.");
+                    ExecutionContext.Result = TaskResultUtil.MergeTaskResults(ExecutionContext.Result, step.ExecutionContext.Result.Value);
+
+                    // We should run cleanup even if one of the cleanup step fails
+                    if (stage != ActionRunStage.Post)
+                    {
                        break;
                    }
                }
            }
+        }

        private async Task RunStepAsync(IStep step)
        {
--- a/src/Runner.Worker/Handlers/ContainerActionHandler.cs
+++ b/src/Runner.Worker/Handlers/ContainerActionHandler.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using System.Threading.Tasks;
 using System;
@@ -69,6 +69,20 @@ namespace GitHub.Runner.Worker.Handlers
                Data.Image = imageName;
            }

+            string type = Action.Type == Pipelines.ActionSourceType.Repository ? "Dockerfile" : "DockerHub";
+            // Add Telemetry to JobContext to send with JobCompleteMessage
+            if (stage == ActionRunStage.Main)
+            {
+                var telemetry = new ActionsStepTelemetry {
+                    Ref = GetActionRef(),
+                    HasPreStep = Data.HasPre,
+                    HasPostStep = Data.HasPost,
+                    IsEmbedded = ExecutionContext.IsEmbedded,
+                    Type = type
+                };
+                ExecutionContext.Root.ActionsStepsTelemetry.Add(telemetry);
+            }
+
            // run container
            var container = new ContainerInfo(HostContext)
            {
@@ -200,6 +214,11 @@ namespace GitHub.Runner.Worker.Handlers
            {
                Environment["ACTIONS_CACHE_URL"] = cacheUrl;
            }
+            if (systemConnection.Data.TryGetValue("GenerateIdTokenUrl", out var generateIdTokenUrl) && !string.IsNullOrEmpty(generateIdTokenUrl))
+            {
+                Environment["ACTIONS_ID_TOKEN_REQUEST_URL"] = generateIdTokenUrl;
+                Environment["ACTIONS_ID_TOKEN_REQUEST_TOKEN"] = systemConnection.Authorization.Parameters[EndpointAuthorizationParameters.AccessToken];
+            }

            foreach (var variable in this.Environment)
            {
--- a/src/Runner.Worker/Handlers/Handler.cs
+++ b/src/Runner.Worker/Handlers/Handler.cs
@@ -20,6 +20,7 @@ namespace GitHub.Runner.Worker.Handlers
        IStepHost StepHost { get; set; }
        Dictionary<string, string> Inputs { get; set; }
        string ActionDirectory { get; set; }
+        List<JobExtensionRunner> LocalActionContainerSetupSteps { get; set; }
        Task RunAsync(ActionRunStage stage);
        void PrintActionDetails(ActionRunStage stage);
    }
@@ -41,9 +42,44 @@ namespace GitHub.Runner.Worker.Handlers
        public IStepHost StepHost { get; set; }
        public Dictionary<string, string> Inputs { get; set; }
        public string ActionDirectory { get; set; }
+        public List<JobExtensionRunner> LocalActionContainerSetupSteps { get; set; }

+        public virtual string GetActionRef()
+        {
+            if (Action.Type == Pipelines.ActionSourceType.ContainerRegistry)
+            {
+                var registryAction = Action as Pipelines.ContainerRegistryReference;
+                return registryAction.Image;
+            }
+            else if (Action.Type == Pipelines.ActionSourceType.Repository)
+            {
+                var repoAction = Action as Pipelines.RepositoryPathReference;
+                if (string.Equals(repoAction.RepositoryType, Pipelines.PipelineConstants.SelfAlias, StringComparison.OrdinalIgnoreCase))
+                {
+                    return repoAction.Path;
+                }
+                else
+                {
+                    if (string.IsNullOrEmpty(repoAction.Path))
+                    {
+                        return $"{repoAction.Name}@{repoAction.Ref}";
+                    }
+                    else
+                    {
+                        return $"{repoAction.Name}/{repoAction.Path}@{repoAction.Ref}";
+                    }
+                }
+            }
+            else
+            {
+                // this should never happen
+                Trace.Error($"Can't generate ref for {Action.Type.ToString()}");
+            }
+            return "";
+        }
        public virtual void PrintActionDetails(ActionRunStage stage)
        {
+            
            if (stage == ActionRunStage.Post)
            {
                ExecutionContext.Output($"Post job cleanup.");
--- a/src/Runner.Worker/Handlers/HandlerFactory.cs
+++ b/src/Runner.Worker/Handlers/HandlerFactory.cs
@@ -19,7 +19,8 @@ namespace GitHub.Runner.Worker.Handlers
            Dictionary<string, string> inputs,
            Dictionary<string, string> environment,
            Variables runtimeVariables,
-            string actionDirectory);
+            string actionDirectory,
+            List<JobExtensionRunner> localActionContainerSetupSteps);
    }

    public sealed class HandlerFactory : RunnerService, IHandlerFactory
@@ -32,7 +33,8 @@ namespace GitHub.Runner.Worker.Handlers
            Dictionary<string, string> inputs,
            Dictionary<string, string> environment,
            Variables runtimeVariables,
-            string actionDirectory)
+            string actionDirectory,
+            List<JobExtensionRunner> localActionContainerSetupSteps)
        {
            // Validate args.
            Trace.Entering();
@@ -84,6 +86,7 @@ namespace GitHub.Runner.Worker.Handlers
            handler.StepHost = stepHost;
            handler.Inputs = inputs;
            handler.ActionDirectory = actionDirectory;
+            handler.LocalActionContainerSetupSteps = localActionContainerSetupSteps;
            return handler;
        }
    }
--- a/src/Runner.Worker/Handlers/NodeScriptActionHandler.cs
+++ b/src/Runner.Worker/Handlers/NodeScriptActionHandler.cs
@@ -53,6 +53,11 @@ namespace GitHub.Runner.Worker.Handlers
            {
                Environment["ACTIONS_CACHE_URL"] = cacheUrl;
            }
+            if (systemConnection.Data.TryGetValue("GenerateIdTokenUrl", out var generateIdTokenUrl) && !string.IsNullOrEmpty(generateIdTokenUrl))
+            {
+                Environment["ACTIONS_ID_TOKEN_REQUEST_URL"] = generateIdTokenUrl;
+                Environment["ACTIONS_ID_TOKEN_REQUEST_TOKEN"] = systemConnection.Authorization.Parameters[EndpointAuthorizationParameters.AccessToken];
+            }

            // Resolve the target script.
            string target = null;
@@ -69,6 +74,20 @@ namespace GitHub.Runner.Worker.Handlers
                target = Data.Post;
            }

+            // Add Telemetry to JobContext to send with JobCompleteMessage
+            if (stage == ActionRunStage.Main)
+            {
+                var telemetry = new ActionsStepTelemetry
+                {
+                    Ref = GetActionRef(),
+                    HasPreStep = Data.HasPre,
+                    HasPostStep = Data.HasPost,
+                    IsEmbedded = ExecutionContext.IsEmbedded,
+                    Type = "node12"
+                };
+                ExecutionContext.Root.ActionsStepsTelemetry.Add(telemetry);
+            }
+
            ArgUtil.NotNullOrEmpty(target, nameof(target));
            target = Path.Combine(ActionDirectory, target);
            ArgUtil.File(target, nameof(target));
--- a/src/Runner.Worker/Handlers/ScriptHandler.cs
+++ b/src/Runner.Worker/Handlers/ScriptHandler.cs
@@ -23,18 +23,6 @@ namespace GitHub.Runner.Worker.Handlers

        public override void PrintActionDetails(ActionRunStage stage)
        {
-            // We don't want to display the internal workings if composite (similar/equivalent information can be found in debug)
-            void writeDetails(string message)
-            {
-                if (ExecutionContext.IsEmbedded)
-                {
-                    ExecutionContext.Debug(message);
-                }
-                else
-                {
-                    ExecutionContext.Output(message);
-                }
-            }

            if (stage == ActionRunStage.Post)
            {
@@ -52,7 +40,7 @@ namespace GitHub.Runner.Worker.Handlers
                    firstLine = firstLine.Substring(0, firstNewLine);
                }

-                writeDetails(ExecutionContext.IsEmbedded ? $"Run {firstLine}" : $"##[group]Run {firstLine}");
+                ExecutionContext.Output($"##[group]Run {firstLine}");
            }
            else
            {
@@ -63,7 +51,7 @@ namespace GitHub.Runner.Worker.Handlers
            foreach (var line in multiLines)
            {
                // Bright Cyan color
-                writeDetails($"\x1b[36;1m{line}\x1b[0m");
+                ExecutionContext.Output($"\x1b[36;1m{line}\x1b[0m");
            }

            string argFormat;
@@ -122,23 +110,23 @@ namespace GitHub.Runner.Worker.Handlers

            if (!string.IsNullOrEmpty(shellCommandPath))
            {
-                writeDetails($"shell: {shellCommandPath} {argFormat}");
+                ExecutionContext.Output($"shell: {shellCommandPath} {argFormat}");
            }
            else
            {
-                writeDetails($"shell: {shellCommand} {argFormat}");
+                ExecutionContext.Output($"shell: {shellCommand} {argFormat}");
            }

            if (this.Environment?.Count > 0)
            {
-                writeDetails("env:");
+                ExecutionContext.Output("env:");
                foreach (var env in this.Environment)
                {
-                    writeDetails($"  {env.Key}: {env.Value}");
+                    ExecutionContext.Output($"  {env.Key}: {env.Value}");
                }
            }

-            writeDetails(ExecutionContext.IsEmbedded ? "" : "##[endgroup]");
+            ExecutionContext.Output("##[endgroup]");
        }

        public async Task RunAsync(ActionRunStage stage)
@@ -156,6 +144,17 @@ namespace GitHub.Runner.Worker.Handlers
            var githubContext = ExecutionContext.ExpressionValues["github"] as GitHubContext;
            ArgUtil.NotNull(githubContext, nameof(githubContext));

+            // Add Telemetry to JobContext to send with JobCompleteMessage
+            if (stage == ActionRunStage.Main)
+            {
+                var telemetry = new ActionsStepTelemetry
+                {
+                    IsEmbedded = ExecutionContext.IsEmbedded,
+                    Type = "run",
+                };
+                ExecutionContext.Root.ActionsStepsTelemetry.Add(telemetry);
+            }
+
            var tempDirectory = HostContext.GetDirectory(WellKnownDirectory.Temp);

            Inputs.TryGetValue("script", out var contents);
@@ -278,6 +277,13 @@ namespace GitHub.Runner.Worker.Handlers
                fileName = node12;
            }
 #endif
+            var systemConnection = ExecutionContext.Global.Endpoints.Single(x => string.Equals(x.Name, WellKnownServiceEndpointNames.SystemVssConnection, StringComparison.OrdinalIgnoreCase));
+            if (systemConnection.Data.TryGetValue("GenerateIdTokenUrl", out var generateIdTokenUrl) && !string.IsNullOrEmpty(generateIdTokenUrl))
+            {
+                Environment["ACTIONS_ID_TOKEN_REQUEST_URL"] = generateIdTokenUrl;
+                Environment["ACTIONS_ID_TOKEN_REQUEST_TOKEN"] = systemConnection.Authorization.Parameters[EndpointAuthorizationParameters.AccessToken];
+            }
+
            ExecutionContext.Debug($"{fileName} {arguments}");

            using (var stdoutManager = new OutputManager(ExecutionContext, ActionCommandManager))
--- a/src/Runner.Worker/IssueMatcher.cs
+++ b/src/Runner.Worker/IssueMatcher.cs
@@ -350,6 +350,7 @@ namespace GitHub.Runner.Worker
                case "":
                case "ERROR":
                case "WARNING":
+                case "NOTICE":
                    break;
                default:
                    throw new ArgumentException($"Matcher '{_owner}' contains unexpected default severity '{_severity}'");
--- a/src/Runner.Worker/JobRunner.cs
+++ b/src/Runner.Worker/JobRunner.cs
@@ -145,6 +145,16 @@ namespace GitHub.Runner.Worker
                Trace.Verbose($"Job steps: '{string.Join(", ", jobSteps.Select(x => x.DisplayName))}'");
                HostContext.WritePerfCounter($"WorkerJobInitialized_{message.RequestId.ToString()}");

+                if (systemConnection.Data.TryGetValue("GenerateIdTokenUrl", out var generateIdTokenUrl) &&
+                    !string.IsNullOrEmpty(generateIdTokenUrl))
+                {
+                    // Server won't issue ID_TOKEN for non-inprogress job.
+                    // If the job is trying to use OIDC feature, we want the job to be marked as in-progress before running any customer's steps as much as we can.
+                    // Timeline record update background process runs every 500ms, so delay 1000ms is enough for most of the cases
+                    Trace.Info($"Waiting for job to be marked as started.");
+                    await Task.WhenAny(_jobServerQueue.JobRecordUpdated.Task, Task.Delay(1000));
+                }
+
                // Run all job steps
                Trace.Info("Run all job steps.");
                var stepsRunner = HostContext.GetService<IStepsRunner>();
@@ -216,7 +226,7 @@ namespace GitHub.Runner.Worker
            }

            Trace.Info("Raising job completed event.");
-            var jobCompletedEvent = new JobCompletedEvent(message.RequestId, message.JobId, result, jobContext.JobOutputs, jobContext.ActionsEnvironment);
+            var jobCompletedEvent = new JobCompletedEvent(message.RequestId, message.JobId, result, jobContext.JobOutputs, jobContext.ActionsEnvironment, jobContext.ActionsStepsTelemetry);

            var completeJobRetryLimit = 5;
            var exceptions = new List<Exception>();
--- a/src/Runner.Worker/StepsRunner.cs
+++ b/src/Runner.Worker/StepsRunner.cs
@@ -354,43 +354,5 @@ namespace GitHub.Runner.Worker

            executionContext.Complete(result, resultCode: resultCode);
        }
-
-        private sealed class ConditionTraceWriter : ObjectTemplating::ITraceWriter
-        {
-            private readonly IExecutionContext _executionContext;
-            private readonly Tracing _trace;
-            private readonly StringBuilder _traceBuilder = new StringBuilder();
-
-            public string Trace => _traceBuilder.ToString();
-
-            public ConditionTraceWriter(Tracing trace, IExecutionContext executionContext)
-            {
-                ArgUtil.NotNull(trace, nameof(trace));
-                _trace = trace;
-                _executionContext = executionContext;
-            }
-
-            public void Error(string format, params Object[] args)
-            {
-                var message = StringUtil.Format(format, args);
-                _trace.Error(message);
-                _executionContext?.Debug(message);
-            }
-
-            public void Info(string format, params Object[] args)
-            {
-                var message = StringUtil.Format(format, args);
-                _trace.Info(message);
-                _executionContext?.Debug(message);
-                _traceBuilder.AppendLine(message);
-            }
-
-            public void Verbose(string format, params Object[] args)
-            {
-                var message = StringUtil.Format(format, args);
-                _trace.Verbose(message);
-                _executionContext?.Debug(message);
-            }
-        }
    }
 }
--- a/src/Sdk/DTLogging/Logging/ValueEncoders.cs
+++ b/src/Sdk/DTLogging/Logging/ValueEncoders.cs
@@ -2,6 +2,7 @@
 using System.ComponentModel;
 using System.Security;
 using System.Text;
+using System.Text.RegularExpressions;
 using Newtonsoft.Json;

 namespace GitHub.DistributedTask.Logging
@@ -80,6 +81,65 @@ namespace GitHub.DistributedTask.Logging
            return trimmed;
        }

+        public static String PowerShellPreAmpersandEscape(String value)
+        {
+            // if the secret is passed to PS as a command and it causes an error, sections of it can be surrounded by color codes
+            // or printed individually. 
+            
+            // The secret secretpart1&secretpart2&secretpart3 would be split into 2 sections:
+            // 'secretpart1&secretpart2&' and 'secretpart3'. This method masks for the first section.
+            
+            // The secret secretpart1&+secretpart2&secretpart3 would be split into 2 sections:
+            // 'secretpart1&+' and (no 's') 'ecretpart2&secretpart3'. This method masks for the first section.
+
+            var trimmed = string.Empty;
+            if (!string.IsNullOrEmpty(value) && value.Contains("&"))
+            {
+                var secretSection = string.Empty;
+                if (value.Contains("&+"))
+                {
+                    secretSection = value.Substring(0, value.IndexOf("&+") + "&+".Length);
+                }
+                else
+                {
+                    secretSection = value.Substring(0, value.LastIndexOf("&") + "&".Length);
+                }
+
+                // Don't mask short secrets
+                if (secretSection.Length >= 6)
+                {
+                    trimmed = secretSection;
+                }
+            }
+
+            return trimmed;
+        }
+
+        public static String PowerShellPostAmpersandEscape(String value)
+        {
+            var trimmed = string.Empty;
+            if (!string.IsNullOrEmpty(value) && value.Contains("&"))
+            {
+                var secretSection = string.Empty;
+                if (value.Contains("&+"))
+                {
+                    // +1 to skip the letter that got colored
+                    secretSection = value.Substring(value.IndexOf("&+") + "&+".Length + 1);
+                }
+                else
+                {
+                    secretSection = value.Substring(value.LastIndexOf("&") + "&".Length);
+                }
+
+                if (secretSection.Length >= 6)
+                {
+                    trimmed = secretSection;
+                }
+            }
+
+            return trimmed;
+        }
+
        private static string Base64StringEscapeShift(String value, int shift)
        {
            var bytes = Encoding.UTF8.GetBytes(value);
--- a/src/Sdk/DTWebApi/WebApi/ActionReference.cs
+++ b/src/Sdk/DTWebApi/WebApi/ActionReference.cs
@@ -18,5 +18,12 @@ namespace GitHub.DistributedTask.WebApi
            get;
            set;
        }
+
+        [DataMember]
+        public string Path
+        {
+            get;
+            set;
+        }
    }
 }
--- a/src/Sdk/DTWebApi/WebApi/ActionsStepTelemetry.cs
+++ b/src/Sdk/DTWebApi/WebApi/ActionsStepTelemetry.cs
@@ -0,0 +1,36 @@
+using System.Runtime.Serialization;
+
+namespace GitHub.DistributedTask.WebApi
+{
+    /// <summary>
+    /// Information about a step run on the runner
+    /// </summary>
+    [DataContract]
+    public class ActionsStepTelemetry
+    {
+
+        [DataMember(EmitDefaultValue = false)]
+        public string Ref { get; set; }
+
+        [DataMember(EmitDefaultValue = false)]
+        public string Type { get; set; }
+
+        [DataMember(EmitDefaultValue = false)]
+        public bool? HasRunsStep { get; set; }
+                
+        [DataMember(EmitDefaultValue = false)]
+        public bool? HasUsesStep { get; set; }
+
+        [DataMember(EmitDefaultValue = false)]
+        public bool IsEmbedded { get; set; }
+
+        [DataMember(EmitDefaultValue = false)]
+        public bool? HasPreStep { get; set; }
+
+        [DataMember(EmitDefaultValue = false)]
+        public bool? HasPostStep { get; set; }
+
+        [DataMember(EmitDefaultValue = false)]
+        public int? StepCount { get; set; }
+    }
+}
--- a/src/Sdk/DTWebApi/WebApi/JobEvent.cs
+++ b/src/Sdk/DTWebApi/WebApi/JobEvent.cs
@@ -142,6 +142,19 @@ namespace GitHub.DistributedTask.WebApi
            this.ActionsEnvironment = actionsEnvironment;
        }

+        public JobCompletedEvent(
+            Int64 requestId,
+            Guid jobId,
+            TaskResult result,
+            Dictionary<String, VariableValue> outputs,
+            ActionsEnvironmentReference actionsEnvironment,
+            List<ActionsStepTelemetry> actionsStepsTelemetry)
+            : this(requestId, jobId, result, outputs)
+        {
+            this.ActionsEnvironment = actionsEnvironment;
+            this.ActionsStepsTelemetry = actionsStepsTelemetry;
+        }
+
        [DataMember(EmitDefaultValue = false)]
        public Int64 RequestId
        {
@@ -169,6 +182,13 @@ namespace GitHub.DistributedTask.WebApi
            get;
            set;
        }
+
+        [DataMember(EmitDefaultValue = false)]
+        public List<ActionsStepTelemetry> ActionsStepsTelemetry
+        {
+            get;
+            set;
+        }
    }

    [DataContract]
--- a/src/Sdk/DTWebApi/WebApi/TaskAgentReference.cs
+++ b/src/Sdk/DTWebApi/WebApi/TaskAgentReference.cs
@@ -24,6 +24,7 @@ namespace GitHub.DistributedTask.WebApi
            this.OSDescription = referenceToBeCloned.OSDescription;
            this.ProvisioningState = referenceToBeCloned.ProvisioningState;
            this.AccessPoint = referenceToBeCloned.AccessPoint;
+            this.Ephemeral = referenceToBeCloned.Ephemeral;

            if (referenceToBeCloned.m_links != null)
            {
@@ -81,6 +82,16 @@ namespace GitHub.DistributedTask.WebApi
            set;
        }

+        /// <summary>
+        /// Signifies that this Agent can only run one job and will be removed by the server after that one job finish.
+        /// </summary>
+        [DataMember]
+        public bool? Ephemeral
+        {
+            get;
+            set;
+        }
+
        /// <summary>
        /// Whether or not the agent is online.
        /// </summary>
--- a/src/Test/L0/HostContextL0.cs
+++ b/src/Test/L0/HostContextL0.cs
@@ -112,6 +112,36 @@ namespace GitHub.Runner.Common.Tests
            }
        }

+        [Theory]
+        [InlineData("secret&secret&secret", "secret&secret&\x0033[96msecret\x0033[0m", "***\x0033[96m***\x0033[0m")]
+        [InlineData("secret&secret+secret", "secret&\x0033[96msecret+secret\x0033[0m", "***\x0033[96m***\x0033[0m")]
+        [InlineData("secret+secret&secret", "secret+secret&\x0033[96msecret\x0033[0m", "***\x0033[96m***\x0033[0m")]
+        [InlineData("secret&secret&+secretsecret", "secret&secret&+\x0033[96ms\x0033[0mecretsecret", "***\x0033[96ms\x0033[0m***")]
+        [InlineData("secret&+secret&secret", "secret&+\x0033[96ms\x0033[0mecret&secret", "***\x0033[96ms\x0033[0m***")]
+        [InlineData("secret&+secret&+secret", "secret&+\x0033[96ms\x0033[0mecret&+secret", "***\x0033[96ms\x0033[0m***")]
+        [InlineData("secret&+secret&secret&+secret", "secret&+\x0033[96ms\x0033[0mecret&secret&+secret", "***\x0033[96ms\x0033[0m***")]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Common")]
+        public void SecretSectionMasking(string secret, string rawOutput, string maskedOutput)
+        {
+            try
+            {
+                // Arrange.
+                Setup();
+
+                // Act.
+                _hc.SecretMasker.AddValue(secret);
+
+                // Assert.
+                Assert.Equal(maskedOutput, _hc.SecretMasker.MaskSecrets(rawOutput));
+            }
+            finally
+            {
+                // Cleanup.
+                Teardown();
+            }
+        }
+
        [Fact]
        [Trait("Level", "L0")]
        [Trait("Category", "Common")]
--- a/src/Test/L0/Listener/RunnerL0.cs
+++ b/src/Test/L0/Listener/RunnerL0.cs
@@ -243,7 +243,8 @@ namespace GitHub.Runner.Common.Tests.Listener
                runner.Initialize(hc);
                var settings = new RunnerSettings
                {
-                    PoolId = 43242
+                    PoolId = 43242,
+                    Ephemeral = true
                };

                var message = new TaskAgentMessage()
@@ -294,7 +295,7 @@ namespace GitHub.Runner.Common.Tests.Listener

                _configStore.Setup(x => x.IsServiceConfigured()).Returns(false);
                //Act
-                var command = new CommandSettings(hc, new string[] { "run", "--once" });
+                var command = new CommandSettings(hc, new string[] { "run" });
                Task<int> runnerTask = runner.ExecuteCommand(command);

                //Assert
@@ -332,7 +333,8 @@ namespace GitHub.Runner.Common.Tests.Listener
                runner.Initialize(hc);
                var settings = new RunnerSettings
                {
-                    PoolId = 43242
+                    PoolId = 43242,
+                    Ephemeral = true
                };

                var message1 = new TaskAgentMessage()
@@ -390,7 +392,7 @@ namespace GitHub.Runner.Common.Tests.Listener

                _configStore.Setup(x => x.IsServiceConfigured()).Returns(false);
                //Act
-                var command = new CommandSettings(hc, new string[] { "run", "--once" });
+                var command = new CommandSettings(hc, new string[] { "run" });
                Task<int> runnerTask = runner.ExecuteCommand(command);

                //Assert
@@ -431,7 +433,8 @@ namespace GitHub.Runner.Common.Tests.Listener
                var settings = new RunnerSettings
                {
                    PoolId = 43242,
-                    AgentId = 5678
+                    AgentId = 5678,
+                    Ephemeral = true
                };

                var message1 = new TaskAgentMessage()
@@ -475,7 +478,7 @@ namespace GitHub.Runner.Common.Tests.Listener

                _configStore.Setup(x => x.IsServiceConfigured()).Returns(false);
                //Act
-                var command = new CommandSettings(hc, new string[] { "run", "--once" });
+                var command = new CommandSettings(hc, new string[] { "run" });
                Task<int> runnerTask = runner.ExecuteCommand(command);

                //Assert
--- a/src/Test/L0/Worker/ActionManagerL0.cs
+++ b/src/Test/L0/Worker/ActionManagerL0.cs
@@ -877,6 +877,7 @@ namespace GitHub.Runner.Common.Tests.Worker
                        }
                    }
                };
+                _hc.EnqueueInstance<IActionRunner>(new Mock<IActionRunner>().Object);

                //Act
                var steps = (await _actionManager.PrepareActionsAsync(_ec.Object, actions)).ContainerSetupSteps;
@@ -967,8 +968,7 @@ namespace GitHub.Runner.Common.Tests.Worker
                var result =  await _actionManager.PrepareActionsAsync(_ec.Object, actions);

                //Assert
-                // TODO: Update this test
-                Assert.Equal(0, result.PreStepTracker.Count);
+                Assert.Equal(1, result.PreStepTracker.Count);

            }
            finally
--- a/src/Test/L0/Worker/ActionRunnerL0.cs
+++ b/src/Test/L0/Worker/ActionRunnerL0.cs
@@ -61,8 +61,8 @@ namespace GitHub.Runner.Common.Tests.Worker
            _actionRunner.Action = action;

            Dictionary<string, string> finialInputs = new Dictionary<string, string>();
-            _handlerFactory.Setup(x => x.Create(It.IsAny<IExecutionContext>(), It.IsAny<ActionStepDefinitionReference>(), It.IsAny<IStepHost>(), It.IsAny<ActionExecutionData>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Variables>(), It.IsAny<string>()))
-                           .Callback((IExecutionContext executionContext, Pipelines.ActionStepDefinitionReference actionReference, IStepHost stepHost, ActionExecutionData data, Dictionary<string, string> inputs, Dictionary<string, string> environment, Variables runtimeVariables, string taskDirectory) =>
+            _handlerFactory.Setup(x => x.Create(It.IsAny<IExecutionContext>(), It.IsAny<ActionStepDefinitionReference>(), It.IsAny<IStepHost>(), It.IsAny<ActionExecutionData>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Variables>(), It.IsAny<string>(), It.IsAny<List<JobExtensionRunner>>()))
+                           .Callback((IExecutionContext executionContext, Pipelines.ActionStepDefinitionReference actionReference, IStepHost stepHost, ActionExecutionData data, Dictionary<string, string> inputs, Dictionary<string, string> environment, Variables runtimeVariables, string taskDirectory, List<JobExtensionRunner> localActionContainerSetupSteps) =>
                           {
                               finialInputs = inputs;
                           })
@@ -107,8 +107,8 @@ namespace GitHub.Runner.Common.Tests.Worker
            _actionRunner.Action = action;

            Dictionary<string, string> finialInputs = new Dictionary<string, string>();
-            _handlerFactory.Setup(x => x.Create(It.IsAny<IExecutionContext>(), It.IsAny<ActionStepDefinitionReference>(), It.IsAny<IStepHost>(), It.IsAny<ActionExecutionData>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Variables>(), It.IsAny<string>()))
-                           .Callback((IExecutionContext executionContext, Pipelines.ActionStepDefinitionReference actionReference, IStepHost stepHost, ActionExecutionData data, Dictionary<string, string> inputs, Dictionary<string, string> environment, Variables runtimeVariables, string taskDirectory) =>
+            _handlerFactory.Setup(x => x.Create(It.IsAny<IExecutionContext>(), It.IsAny<ActionStepDefinitionReference>(), It.IsAny<IStepHost>(), It.IsAny<ActionExecutionData>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Variables>(), It.IsAny<string>(), It.IsAny<List<JobExtensionRunner>>()))
+                           .Callback((IExecutionContext executionContext, Pipelines.ActionStepDefinitionReference actionReference, IStepHost stepHost, ActionExecutionData data, Dictionary<string, string> inputs, Dictionary<string, string> environment, Variables runtimeVariables, string taskDirectory, List<JobExtensionRunner> localActionContainerSetupSteps) =>
                           {
                               finialInputs = inputs;
                           })
@@ -308,8 +308,8 @@ namespace GitHub.Runner.Common.Tests.Worker
            _actionRunner.Action = action;

            Dictionary<string, string> finialInputs = new Dictionary<string, string>();
-            _handlerFactory.Setup(x => x.Create(It.IsAny<IExecutionContext>(), It.IsAny<ActionStepDefinitionReference>(), It.IsAny<IStepHost>(), It.IsAny<ActionExecutionData>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Variables>(), It.IsAny<string>()))
-                           .Callback((IExecutionContext executionContext, Pipelines.ActionStepDefinitionReference actionReference, IStepHost stepHost, ActionExecutionData data, Dictionary<string, string> inputs, Dictionary<string, string> environment, Variables runtimeVariables, string taskDirectory) =>
+            _handlerFactory.Setup(x => x.Create(It.IsAny<IExecutionContext>(), It.IsAny<ActionStepDefinitionReference>(), It.IsAny<IStepHost>(), It.IsAny<ActionExecutionData>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Variables>(), It.IsAny<string>(), It.IsAny<List<JobExtensionRunner>>()))
+                           .Callback((IExecutionContext executionContext, Pipelines.ActionStepDefinitionReference actionReference, IStepHost stepHost, ActionExecutionData data, Dictionary<string, string> inputs, Dictionary<string, string> environment, Variables runtimeVariables, string taskDirectory, List<JobExtensionRunner> localActionContainerSetupSteps) =>
                           {
                               finialInputs = inputs;
                           })
@@ -359,8 +359,8 @@ namespace GitHub.Runner.Common.Tests.Worker
            _actionRunner.Action = action;

            Dictionary<string, string> finialInputs = new Dictionary<string, string>();
-            _handlerFactory.Setup(x => x.Create(It.IsAny<IExecutionContext>(), It.IsAny<ActionStepDefinitionReference>(), It.IsAny<IStepHost>(), It.IsAny<ActionExecutionData>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Variables>(), It.IsAny<string>()))
-                           .Callback((IExecutionContext executionContext, Pipelines.ActionStepDefinitionReference actionReference, IStepHost stepHost, ActionExecutionData data, Dictionary<string, string> inputs, Dictionary<string, string> environment, Variables runtimeVariables, string taskDirectory) =>
+            _handlerFactory.Setup(x => x.Create(It.IsAny<IExecutionContext>(), It.IsAny<ActionStepDefinitionReference>(), It.IsAny<IStepHost>(), It.IsAny<ActionExecutionData>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Dictionary<string, string>>(), It.IsAny<Variables>(), It.IsAny<string>(), It.IsAny<List<JobExtensionRunner>>()))
+                           .Callback((IExecutionContext executionContext, Pipelines.ActionStepDefinitionReference actionReference, IStepHost stepHost, ActionExecutionData data, Dictionary<string, string> inputs, Dictionary<string, string> environment, Variables runtimeVariables, string taskDirectory, List<JobExtensionRunner> localActionContainerSetupSteps) =>
                           {
                               finialInputs = inputs;
                           })
--- a/src/Test/L0/Worker/IssueMatcherL0.cs
+++ b/src/Test/L0/Worker/IssueMatcherL0.cs
@@ -392,6 +392,35 @@ namespace GitHub.Runner.Common.Tests.Worker
            Assert.Equal("not-working", match.Message);
        }

+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void Matcher_MultiplePatterns_DefaultSeverityNotice()
+        {
+            var config = JsonUtility.FromString<IssueMatchersConfig>(@"
+{
+  ""problemMatcher"": [
+    {
+      ""owner"": ""myMatcher"",
+      ""severity"": ""notice"",
+      ""pattern"": [
+        {
+          ""regexp"": ""^(.+)$"",
+          ""message"": 1
+        }
+      ]
+    }
+  ]
+}
+");
+            config.Validate();
+            var matcher = new IssueMatcher(config.Matchers[0], TimeSpan.FromSeconds(1));
+
+            var match = matcher.Match("just-a-notice");
+            Assert.Equal("notice", match.Severity);
+            Assert.Equal("just-a-notice", match.Message);
+        }
+
        [Fact]
        [Trait("Level", "L0")]
        [Trait("Category", "Worker")]
--- a/src/Test/L0/Worker/JobExtensionL0.cs
+++ b/src/Test/L0/Worker/JobExtensionL0.cs
@@ -141,7 +141,7 @@ namespace GitHub.Runner.Common.Tests.Worker
                var jobExtension = new JobExtension();
                jobExtension.Initialize(hc);

-                _actionManager.Setup(x => x.PrepareActionsAsync(It.IsAny<IExecutionContext>(), It.IsAny<IEnumerable<Pipelines.JobStep>>()))
+                _actionManager.Setup(x => x.PrepareActionsAsync(It.IsAny<IExecutionContext>(), It.IsAny<IEnumerable<Pipelines.JobStep>>(), It.IsAny<Guid>()))
                              .Returns(Task.FromResult(new PrepareResult(new List<JobExtensionRunner>(), new Dictionary<Guid, IActionRunner>())));

                List<IStep> result = await jobExtension.InitializeJob(_jobEc, _message);
@@ -176,7 +176,7 @@ namespace GitHub.Runner.Common.Tests.Worker
                var jobExtension = new JobExtension();
                jobExtension.Initialize(hc);

-                _actionManager.Setup(x => x.PrepareActionsAsync(It.IsAny<IExecutionContext>(), It.IsAny<IEnumerable<Pipelines.JobStep>>()))
+                _actionManager.Setup(x => x.PrepareActionsAsync(It.IsAny<IExecutionContext>(), It.IsAny<IEnumerable<Pipelines.JobStep>>(), It.IsAny<Guid>()))
                              .Returns(Task.FromResult(new PrepareResult(new List<JobExtensionRunner>() { new JobExtensionRunner(null, "", "prepare1", null), new JobExtensionRunner(null, "", "prepare2", null) }, new Dictionary<Guid, IActionRunner>())));

                List<IStep> result = await jobExtension.InitializeJob(_jobEc, _message);
--- a/src/runnerversion
+++ b/src/runnerversion
@@ -1 +1 @@
-2.279.0
+2.282.1
Author	SHA1	Message	Date
Julio Barba	f9ce10da6d	Release 2.282.1 runner	2021-09-15 14:00:06 -04:00
Julio Barba	c3649406e8	Prepare 2.282.1 release (#1345 ) * Revert "Recreate VssConnection on retry (#1316)" (#1343) This reverts commit `4359dd605b`. * Prepare 2.282.1 release	2021-09-15 13:49:24 -04:00
Patrick Ellis	f954835f54	Update releaseVersion to 2.282.0	2021-09-13 14:12:48 -04:00
Patrick Ellis	512cd2b4f8	Release 2.282.0	2021-09-13 14:08:46 -04:00
Patrick Ellis	404b3418b7	Prepare 2.282.0 release (#1327 )	2021-09-13 13:56:47 -04:00
Tingluo Huang	7ffd9af644	Support `--ephemeral` flag (#660 ) This optional flag will configure the runner to only take one job, and let the service un-configure the runner after that job finishes.	2021-09-13 11:28:09 -04:00
Thomas Boop	1b69c279f5	Networking TSG (#1325 ) * Update Network Troubleshooting doc * fix list * Update network.md	2021-09-13 09:53:20 +02:00
Liviu Ionescu	567870dbb8	Avoid ConsoleColor.White, it is unreadable on light themes (#1295 ) (#1319 ) * Avoid white, it is unreadable on light themes (#1295) * remove ', ConsoleColor.White' from banner * remove ', ConsoleColor.White' from prompt * cleanups	2021-09-13 07:50:52 +00:00
Tingluo Huang	72fa2a8a0d	Wait for job record updated before running steps. (#1320 ) * Wait for job record updated before running steps. * only oidc	2021-09-09 21:55:15 -04:00
Julio Barba	4359dd605b	Recreate VssConnection on retry (#1316 )	2021-09-09 19:09:17 -04:00
dependabot[bot]	aab936d081	Bump path-parse in /src/Misc/expressionFunc/hashFiles (#1256 ) Bumps [path-parse](https://github.com/jbgutierrez/path-parse) from 1.0.6 to 1.0.7. - [Release notes](https://github.com/jbgutierrez/path-parse/releases) - [Commits](https://github.com/jbgutierrez/path-parse/commits/v1.0.7) --- updated-dependencies: - dependency-name: path-parse dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-09-01 16:48:41 -04:00
Nancy Hsieh	777ce5a0dc	ignore empty arrays in jq select (#1269 ) * ignore empty arrays in jq select * Update delete.sh Co-authored-by: Ferenc Hammerl <31069338+fhammerl@users.noreply.github.com>	2021-09-01 20:39:45 +00:00
Tingluo Huang	1a62162708	Prepare 2.281.1 runner release. (#1305 )	2021-09-01 16:15:08 -04:00
Thomas Boop	9a829995e0	Show More Step Information in composite Actions (#1279 )	2021-09-01 16:04:27 -04:00
Vladimir Panteleev	c5ce52641c	Allow setting default severity to "notice" (#1213 )	2021-09-01 16:01:23 -04:00
Nick Fields	e82725b580	Update error to say 'uninstall' not 'unconfigure' (#1179 ) * Update error to say 'uninstall' not 'unconfigure' * Say uninstall service in *nix config error msgs Co-authored-by: Ferenc Hammerl <31069338+fhammerl@users.noreply.github.com>	2021-09-01 16:00:19 -04:00
Daniel Asztalos	0464f77de3	Typo fixed (#1289 )	2021-09-01 15:59:18 -04:00
Tingluo Huang	1fc159e0df	Temporary fix for macOS runner upgrade crash loop. (#1304 )	2021-09-01 15:39:17 -04:00
Ferenc Hammerl	3615fb6923	Runner 2.281.0 (#1298 ) * Add generateIdTokenUrl as an env var * Add generateIdTokenUrl to env vars * Update runnerversion * Remove old relese notes * Update releaseNote.md	2021-08-30 18:57:24 +02:00
Ferenc Hammerl	f61dcad5bb	Don't try to login to ghcr.io with GHES tokens (#1291 ) * Don't try GHXX tokens for ghcr.io login * Explain hosted / onpremise in comment * Nitfix variable name	2021-08-30 11:52:12 +02:00
Tingluo Huang	62d568674c	Add `ACTIONS_ID_TOKEN_REQUEST_URL/Token` to script as well. (#1287 )	2021-08-26 13:29:02 -04:00
Ferenc Hammerl	07c00f6a8a	PowerShell secret masking (#1258 ) * Trim pwsh special chars when masking secrets * Add pwsh valueEncoder * Explain regex * Update ValueEncoders.cs * Add tests for pwsh color codes in secrets * Formatting * Group tests into theories * Split secret on PS chars and mask for them * Clean up comments * Remove unused unittest * Rename escape methods	2021-08-25 23:07:19 +02:00
Tingluo Huang	05b84297b7	Add extra env for the Token log-in action is going to use to request ID_TOKEN. (#1270 )	2021-08-23 14:50:35 -04:00
Thomas Boop	04679b56a9	Runner 2.280.3 Release (#1276 )	2021-08-19 08:40:11 -04:00
Thomas Boop	d2ca24fa43	For Main Steps, just run the step, don't check condition (#1273 ) * For Main Steps, just run the step, don't check condition * fix whitespace * pr feedback	2021-08-18 16:40:25 -04:00
Thomas Boop	abdaacfa6e	Runner release 2.280.2 (#1259 ) * Runner release 2.280.2 * update * update	2021-08-12 12:55:45 -04:00
Thomas Boop	53fd7161e2	send path when resolving actions (#1250 )	2021-08-11 09:48:32 -04:00
Ferenc Hammerl	ce68f3b167	Allow the use of flags in scripts/create-latest-svc.sh in a backwards compatible way (#1220 ) * Use flags in svc creation script * Refactor regex and add comments * Fix indentation and typo in user matching * Consistency use flags in automation scripts * Update documentation to reflect new usage * Make example more readable * Remove test echos from script * Remove test echo * Format scripts and remove test script * Remove tar * Use getopts and single letter flags * Update docs to show flag usage * Update usage of create svc * Revert svc to not use flags * Revert delete script * Update docs * Readd deleted comments	2021-08-09 10:22:19 +02:00
Thomas Boop	e2c7329292	Release notes for 2.280.1 runner (#1244 )	2021-08-04 13:28:32 -04:00
Thomas Boop	22a9d89772	Correctly set post step step context (#1243 )	2021-08-04 11:39:22 -04:00
Thomas Boop	3851acd0cf	fix continue on error (#1238 )	2021-08-03 17:44:58 -04:00
Tingluo Huang	aab4aca8f7	Finish job when worker crashed with IOException. (#1239 )	2021-08-03 16:21:39 -04:00
Thomas Boop	5af7b87074	Release notes for runner release 2.290.0 (#1237 )	2021-08-03 11:12:43 -04:00
Tingluo Huang	110eb3a5de	Add generateIdTokenUrl to env vars for actions. (#1234 )	2021-08-02 14:47:50 -07:00
Tingluo Huang	bd1341e580	Print out resolved SHA for each action. (#1233 )	2021-08-02 15:59:09 -04:00
Thomas Boop	85ce33b1d3	Composite Code Cleanup (#1232 ) * composite polish * Cleanup Condition Handling * Refactor ConditionTraceWriter * pr feedback * cleanup	2021-08-02 14:57:25 -04:00
Thomas Boop	92ec3d0f29	Add better step telemetry and tracing for composite Actions (#1229 ) * Add Step Telemetry * better telemetry and tracing * cleanup	2021-07-30 10:45:49 -04:00
Thomas Boop	4e95d0d6ad	Support pre/post/container/composite actions within composite actions (#1222 ) Support Composite Actions with uses: steps	2021-07-28 15:35:21 -04:00
Thomas Boop	5281434f3f	Composite Actions Support ADR (#1144 ) Composite Actions ADR	2021-07-27 09:29:50 -04:00
Ferenc Hammerl	e9a8bf29df	Prefer higher libicu versions in installDependencies.sh (#1228 ) * Update libicu dependencies * Remove redundant comments (methodname is enough)	2021-07-27 14:30:53 +02:00
dependabot[bot]	a65331e887	Bump lodash in /src/Misc/expressionFunc/hashFiles (#1082 ) Bumps [lodash](https://github.com/lodash/lodash) from 4.17.19 to 4.17.21. - [Release notes](https://github.com/lodash/lodash/releases) - [Commits](https://github.com/lodash/lodash/compare/4.17.19...4.17.21) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-07-26 23:34:52 -04:00
dependabot[bot]	908a082527	Bump hosted-git-info in /src/Misc/expressionFunc/hashFiles (#1087 ) Bumps [hosted-git-info](https://github.com/npm/hosted-git-info) from 2.8.8 to 2.8.9. - [Release notes](https://github.com/npm/hosted-git-info/releases) - [Changelog](https://github.com/npm/hosted-git-info/blob/v2.8.9/CHANGELOG.md) - [Commits](https://github.com/npm/hosted-git-info/compare/v2.8.8...v2.8.9) Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-07-26 23:33:21 -04:00
dependabot[bot]	10ba74f59b	Bump glob-parent in /src/Misc/expressionFunc/hashFiles (#1147 ) Bumps [glob-parent](https://github.com/gulpjs/glob-parent) from 5.1.1 to 5.1.2. - [Release notes](https://github.com/gulpjs/glob-parent/releases) - [Changelog](https://github.com/gulpjs/glob-parent/blob/main/CHANGELOG.md) - [Commits](https://github.com/gulpjs/glob-parent/compare/v5.1.1...v5.1.2) --- updated-dependencies: - dependency-name: glob-parent dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-07-26 22:55:26 -04:00
@@ -1 +1 @@
 .279.0
 .282.1