Highlight Complete job step in execution view on job-completed pause

When the debugger pauses after job completion, surface the synthetic
"Complete job" entry as the active stack frame so clients highlight
the cleanup line. Previously the position stayed on the last real step.

Threads CompleteJobLine through RenderResult / JobExecutionView and
gates HandleStackTrace on a new _jobCompleted flag set when
OnJobCompletedAsync enters its inspection pause.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

.devcontainer/devcontainer.json

@@ -4,7 +4,7 @@
   "features": {
     "ghcr.io/devcontainers/features/docker-in-docker:2": {},
     "ghcr.io/devcontainers/features/dotnet": {
-      "version": "8.0.420"
+      "version": "8.0.421"
     },
     "ghcr.io/devcontainers/features/node:1": {
       "version": "20"

.gitignore

@@ -27,4 +27,5 @@ TestResults
 TestLogs
 .DS_Store
 .mono
-**/*.DotSettings.user
+**/*.DotSettings.user
+**/*.lscache

docs/start/envlinux.md

@@ -25,11 +25,11 @@ The `installdependencies.sh` script should install all required dependencies on
 
 Debian based OS (Debian, Ubuntu, Linux Mint)
 
-- liblttng-ust1 or liblttng-ust0
+- liblttng-ust1t64, liblttng-ust1 or liblttng-ust0
 - libkrb5-3
 - zlib1g
 - libssl3t64, libssl3, libssl1.1, libssl1.0.2 or libssl1.0.0
-- libicu76, libicu75, ..., libicu66, libicu65, libicu63, libicu60, libicu57, libicu55, or libicu52
+- libicu80, libicu79, ..., libicu66, libicu65, libicu63, libicu60, libicu57, libicu55, or libicu52
 
 Fedora based OS (Fedora, Red Hat Enterprise Linux, CentOS, Oracle Linux 7)
 

images/Dockerfile

@@ -5,8 +5,8 @@ ARG TARGETOS
 ARG TARGETARCH
 ARG RUNNER_VERSION
 ARG RUNNER_CONTAINER_HOOKS_VERSION=0.7.0
-ARG DOCKER_VERSION=29.4.0
-ARG BUILDX_VERSION=0.33.0
+ARG DOCKER_VERSION=29.5.0
+ARG BUILDX_VERSION=0.34.0
 
 RUN apt update -y && apt install curl unzip -y
 

src/Misc/externals.sh

@@ -7,7 +7,7 @@ NODE_ALPINE_URL=https://github.com/actions/alpine_nodejs/releases/download
 # When you update Node versions you must also create a new release of alpine_nodejs at that updated version.
 # Follow the instructions here: https://github.com/actions/alpine_nodejs?tab=readme-ov-file#getting-started
 NODE20_VERSION="20.20.2"
-NODE24_VERSION="24.15.0"
+NODE24_VERSION="24.16.0"
 
 get_abs_path() {
   # exploits the fact that pwd will print abs path when no args

src/Misc/layoutbin/installdependencies.sh

@@ -94,7 +94,7 @@ then
             fi
         }
 
-        apt_get_with_fallbacks liblttng-ust1 liblttng-ust0
+        apt_get_with_fallbacks liblttng-ust1t64 liblttng-ust1 liblttng-ust0
         if [ $? -ne 0 ]
         then
             echo "'$apt_get' failed with exit code '$?'"
@@ -110,7 +110,7 @@ then
             exit 1
         fi
 
-        apt_get_with_fallbacks libicu76 libicu75 libicu74 libicu73 libicu72 libicu71 libicu70 libicu69 libicu68 libicu67 libicu66 libicu65 libicu63 libicu60 libicu57 libicu55 libicu52
+        apt_get_with_fallbacks libicu80 libicu79 libicu78 libicu77 libicu76 libicu75 libicu74 libicu73 libicu72 libicu71 libicu70 libicu69 libicu68 libicu67 libicu66 libicu65 libicu63 libicu60 libicu57 libicu55 libicu52
         if [ $? -ne 0 ]
         then
             echo "'$apt_get' failed with exit code '$?'"

src/Runner.Common/Constants.cs

@@ -179,6 +179,7 @@ namespace GitHub.Runner.Common
                 public static readonly string EmitCompositeMarkers = "actions_runner_emit_composite_markers";
                 public static readonly string BatchActionResolution = "actions_batch_action_resolution";
                 public static readonly string UseBearerTokenForCodeload = "actions_use_bearer_token_for_codeload";
+                public static readonly string OverrideDebuggerWelcomeMessage = "actions_runner_override_debugger_welcome_message";
             }
 
             // Node version migration related constants

src/Runner.Worker/Dap/DapDebugger.cs

@@ -58,6 +58,7 @@ namespace GitHub.Runner.Worker.Dap
         private volatile DapSessionState _state = DapSessionState.NotStarted;
         private CancellationTokenRegistration? _cancellationRegistration;
         private bool _isFirstStep = true;
+        private bool _welcomeMessageSent;
 
         // Dev Tunnel relay host for remote debugging
         private TunnelRelayTunnelHost _tunnelRelayHost;
@@ -88,6 +89,11 @@ namespace GitHub.Runner.Worker.Dap
         private IStep _currentStep;
         private IExecutionContext _jobContext;
 
+        // Set true once OnJobCompletedAsync begins its inspection pause.
+        // While set, HandleStackTrace surfaces the synthetic "Complete job"
+        // frame so the client highlights the cleanup line.
+        private bool _jobCompleted;
+
         // Client connection tracking for reconnection support
         private volatile bool _isClientConnected;
 
@@ -243,6 +249,10 @@ namespace GitHub.Runner.Worker.Dap
                     {
                         if (_jobContext != null)
                         {
+                            lock (_stateLock)
+                            {
+                                _jobCompleted = true;
+                            }
                             Trace.Info("Job completed — pausing for inspection");
                             SendStoppedEvent("completed", "Job completed — inspect variables before the session ends.");
 
@@ -395,7 +405,6 @@ namespace GitHub.Runner.Worker.Dap
             try
             {
                 Trace.Info("Step completed");
-                JobExecutionView view;
                 lock (_stateLock)
                 {
                     if (_state != DapSessionState.Ready &&
@@ -411,23 +420,6 @@ namespace GitHub.Runner.Worker.Dap
                     {
                         _currentStep = null;
                     }
-                    view = _executionView;
-                }
-
-                // If the skipped step was a Main IActionRunner with a predicted
-                // Post-step placeholder, mark that placeholder as skipped so
-                // the view does not advertise a step that will never run.
-                if (view != null &&
-                    step is IActionRunner actionRunner &&
-                    actionRunner.Stage == ActionRunStage.Main &&
-                    actionRunner.Action != null &&
-                    step.ExecutionContext?.Result == TaskResult.Skipped)
-                {
-                    var matchKey = MatchKeyFor(actionRunner.Action.Id);
-                    if (view.TryMarkSkipped(matchKey))
-                    {
-                        SendLoadedSourceEvent("changed");
-                    }
                 }
             }
             catch (Exception ex)
@@ -818,6 +810,11 @@ namespace GitHub.Runner.Worker.Dap
                     });
                     Trace.Info("Sent initialized event");
                 }
+
+                if (request.Command == "configurationDone")
+                {
+                    SendWelcomeMessage();
+                }
             }
             catch (Exception ex)
             {
@@ -836,6 +833,7 @@ namespace GitHub.Runner.Worker.Dap
         internal void HandleClientConnected()
         {
             _isClientConnected = true;
+            _welcomeMessageSent = false;
             Trace.Info("Client connected to debug session");
 
             // If we're paused, re-send the stopped event so the new client
@@ -1146,6 +1144,34 @@ namespace GitHub.Runner.Worker.Dap
             });
         }
 
+        internal void SendWelcomeMessage()
+        {
+            if (_welcomeMessageSent)
+            {
+                return;
+            }
+            _welcomeMessageSent = true;
+
+            var debuggerConfig = _jobContext?.Global?.Debugger;
+            if (debuggerConfig?.OverrideWelcomeMessage == true)
+            {
+                if (!string.IsNullOrEmpty(debuggerConfig.WelcomeMessage))
+                {
+                    SendOutput("console", debuggerConfig.WelcomeMessage);
+                    Trace.Info("Sent custom welcome message");
+                }
+                else
+                {
+                    Trace.Info("Welcome message suppressed by override");
+                }
+            }
+            else
+            {
+                SendOutput("console", DapReplParser.GetGeneralHelp());
+                Trace.Info("Sent default welcome message");
+            }
+        }
+
         internal async Task OnStepStartingAsync(IStep step, bool isFirstStep)
         {
             bool shouldPause;
@@ -1184,6 +1210,9 @@ namespace GitHub.Runner.Worker.Dap
             // Send stopped event to debugger (only if client is connected)
             SendStoppedEvent(reason, description);
 
+            // Emit a banner so the user knows where REPL commands will execute
+            SendExecutionContextBanner();
+
             // Wait for debugger command
             await WaitForCommandAsync(cancellationToken);
         }
@@ -1360,10 +1389,12 @@ namespace GitHub.Runner.Worker.Dap
         {
             IStep currentStep;
             JobExecutionView view;
+            bool jobCompleted;
             lock (_stateLock)
             {
                 currentStep = _currentStep;
                 view = _executionView;
+                jobCompleted = _jobCompleted;
             }
 
             var frames = new List<StackFrame>();
@@ -1372,9 +1403,23 @@ namespace GitHub.Runner.Worker.Dap
             {
                 var source = BuildExecutionViewSource(view.JobId);
 
-                // Frame 0: the currently-executing step (only when one is set).
-                if (currentStep != null)
+                if (jobCompleted)
                 {
+                    // Surface the synthetic Complete job step so the client
+                    // highlights the cleanup line at end-of-job pause.
+                    frames.Add(new StackFrame
+                    {
+                        Id = _currentFrameId,
+                        Name = MaskUserVisibleText("Complete job"),
+                        Line = view.CompleteJobLine,
+                        Column = 1,
+                        Source = source,
+                        PresentationHint = "normal",
+                    });
+                }
+                else if (currentStep != null)
+                {
+                    // Frame 0: the currently-executing step (only when one is set).
                     var stepLine = view.TryGetLineForStep(currentStep) ?? 1;
                     frames.Add(new StackFrame
                     {
@@ -1625,7 +1670,12 @@ namespace GitHub.Runner.Worker.Dap
 
                 case RunCommand run:
                     var context = GetExecutionContextForFrame(frameId);
-                    return await _replExecutor.ExecuteRunCommandAsync(run, context, cancellationToken);
+                    bool isActionStep;
+                    lock (_stateLock)
+                    {
+                        isActionStep = _currentStep is IActionRunner;
+                    }
+                    return await _replExecutor.ExecuteRunCommandAsync(run, context, isActionStep, cancellationToken);
 
                 default:
                     return new EvaluateResponseBody
@@ -1865,6 +1915,40 @@ namespace GitHub.Runner.Worker.Dap
             });
         }
 
+        /// <summary>
+        /// Emits a console output banner telling the user whether REPL
+        /// commands will execute on the host or inside the job container.
+        /// </summary>
+        private void SendExecutionContextBanner()
+        {
+            if (!_isClientConnected)
+            {
+                return;
+            }
+
+            bool isActionStep = _currentStep is IActionRunner;
+            var container = _jobContext?.Global?.Container;
+
+            string target;
+            if (isActionStep && container != null &&
+                (!string.IsNullOrEmpty(container.ContainerId) ||
+                 FeatureManager.IsContainerHooksEnabled(_jobContext?.Global?.Variables)))
+            {
+                var image = container.ContainerImage ?? "container";
+                var shortId = !string.IsNullOrEmpty(container.ContainerId) && container.ContainerId.Length >= 12
+                    ? container.ContainerId.Substring(0, 12)
+                    : container.ContainerId ?? "";
+                var idSuffix = !string.IsNullOrEmpty(shortId) ? $" ({shortId})" : "";
+                target = $"job container: {image}{idSuffix}";
+            }
+            else
+            {
+                target = "runner host";
+            }
+
+            SendOutput("console", $"\nCommands will run on {target}\n");
+        }
+
         /// <summary>
         /// Sends a loadedSource event with the current execution view's source.
         /// No-op if the view has not been built yet.

src/Runner.Worker/Dap/DapReplExecutor.cs

@@ -9,6 +9,7 @@ using GitHub.DistributedTask.Pipelines.ContextData;
 using GitHub.Runner.Common;
 using GitHub.Runner.Common.Util;
 using GitHub.Runner.Sdk;
+using GitHub.Runner.Worker.Container;
 using GitHub.Runner.Worker.Handlers;
 
 namespace GitHub.Runner.Worker.Dap
@@ -43,6 +44,7 @@ namespace GitHub.Runner.Worker.Dap
         public async Task<EvaluateResponseBody> ExecuteRunCommandAsync(
             RunCommand command,
             IExecutionContext context,
+            bool isActionStep,
             CancellationToken cancellationToken)
         {
             if (context == null)
@@ -52,7 +54,7 @@ namespace GitHub.Runner.Worker.Dap
 
             try
             {
-                return await ExecuteScriptAsync(command, context, cancellationToken);
+                return await ExecuteScriptAsync(command, context, isActionStep, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -65,9 +67,17 @@ namespace GitHub.Runner.Worker.Dap
         private async Task<EvaluateResponseBody> ExecuteScriptAsync(
             RunCommand command,
             IExecutionContext context,
+            bool isActionStep,
             CancellationToken cancellationToken)
         {
-            // 1. Resolve shell — same logic as ScriptHandler
+            // 1. Resolve step host — container or host, same as ActionRunner.
+            //    Only action steps (user-defined run:/uses:) execute inside the
+            //    container.  Infrastructure steps (Set up job, Initialize
+            //    containers, Complete job, etc.) always run on the host.
+            var stepHost = CreateStepHost(context, isActionStep);
+            var isContainerStepHost = stepHost is IContainerStepHost;
+
+            // 2. Resolve shell — same logic as ScriptHandler
             string shellCommand;
             string argFormat;
 
@@ -87,9 +97,9 @@ namespace GitHub.Runner.Worker.Dap
                 argFormat = ScriptHandlerHelpers.GetScriptArgumentsFormat(shellCommand);
             }
 
-            _trace.Info("Resolved REPL shell");
+            _trace.Info($"Resolved REPL shell (container={isContainerStepHost})");
 
-            // 2. Expand ${{ }} expressions in the script body, just like
+            // 3. Expand ${{ }} expressions in the script body, just like
             //    ActionRunner evaluates step inputs before ScriptHandler sees them
             var contents = ExpandExpressions(command.Script, context);
             contents = ScriptHandlerHelpers.FixUpScriptContents(shellCommand, contents);
@@ -111,25 +121,47 @@ namespace GitHub.Runner.Worker.Dap
 
             try
             {
-                // 3. Format arguments with script path
-                var resolvedPath = scriptFilePath.Replace("\"", "\\\"");
+                // 4. Resolve script path — translate for container if needed
+                var resolvedPath = stepHost.ResolvePathForStepHost(context, scriptFilePath).Replace("\"", "\\\"");
                 if (string.IsNullOrEmpty(argFormat) || !argFormat.Contains("{0}"))
                 {
                     return ErrorResult($"Invalid shell option '{shellCommand}'. Shell must be a valid built-in (bash, sh, cmd, powershell, pwsh) or a format string containing '{{0}}'");
                 }
                 var arguments = string.Format(argFormat, resolvedPath);
 
-                // 4. Resolve shell command path
+                // 5. Resolve shell command path — for containers, use the shell
+                //    name directly (it will be resolved inside the container);
+                //    for host execution, resolve the full path on the host.
                 string prependPath = string.Join(
                     Path.PathSeparator.ToString(),
                     Enumerable.Reverse(context.Global.PrependPath));
-                var commandPath = WhichUtil.Which(shellCommand, false, _trace, prependPath)
-                    ?? shellCommand;
+                var fileName = isContainerStepHost
+                    ? shellCommand
+                    : WhichUtil.Which(shellCommand, false, _trace, prependPath) ?? shellCommand;
 
-                // 5. Build environment — merge from execution context like a real step
+                // 6. Build environment — merge from execution context like a real step
                 var environment = BuildEnvironment(context, command.Env);
 
-                // 6. Resolve working directory
+                // 7. Handle PrependPath — mirrors Handler.AddPrependPathToEnvironment
+                if (context.Global.PrependPath.Count > 0)
+                {
+                    if (stepHost is IContainerStepHost containerHost)
+                    {
+                        containerHost.PrependPath = prependPath;
+                    }
+                    else
+                    {
+                        string taskEnvPATH;
+                        environment.TryGetValue(Constants.PathVariable, out taskEnvPATH);
+                        string originalPath = context.Global.Variables?.Get(Constants.PathVariable) ?? // Prefer a job variable.
+                            taskEnvPATH ?? // Then a task-environment variable.
+                            System.Environment.GetEnvironmentVariable(Constants.PathVariable) ?? // Then an environment variable.
+                            string.Empty;
+                        environment[Constants.PathVariable] = PathUtil.PrependPath(prependPath, originalPath);
+                    }
+                }
+
+                // 8. Resolve working directory — translate for container
                 var workingDirectory = command.WorkingDirectory;
                 if (string.IsNullOrEmpty(workingDirectory))
                 {
@@ -141,48 +173,60 @@ namespace GitHub.Runner.Worker.Dap
                         : null;
                     workingDirectory = workspace ?? _hostContext.GetDirectory(WellKnownDirectory.Work);
                 }
+                workingDirectory = stepHost.ResolvePathForStepHost(context, workingDirectory);
 
                 _trace.Info("Executing REPL command");
 
                 // Stream execution info to debugger
                 SendOutput("console", $"$ {shellCommand} {command.Script.Substring(0, Math.Min(command.Script.Length, 80))}{(command.Script.Length > 80 ? "..." : "")}\n");
 
-                // 7. Execute via IProcessInvoker (same as DefaultStepHost)
-                int exitCode;
-                using (var processInvoker = _hostContext.CreateService<IProcessInvoker>())
+                // NOTE: When container hooks are enabled, ContainerStepHost routes
+                // execution through IContainerHookManager which does not raise
+                // OutputDataReceived/ErrorDataReceived events. Output will not be
+                // streamed to the debug console in that mode.
+                if (isContainerStepHost && FeatureManager.IsContainerHooksEnabled(context.Global?.Variables))
                 {
-                    processInvoker.OutputDataReceived += (sender, args) =>
-                    {
-                        if (!string.IsNullOrEmpty(args.Data))
-                        {
-                            var masked = _hostContext.SecretMasker.MaskSecrets(args.Data);
-                            SendOutput("stdout", masked + "\n");
-                        }
-                    };
-
-                    processInvoker.ErrorDataReceived += (sender, args) =>
-                    {
-                        if (!string.IsNullOrEmpty(args.Data))
-                        {
-                            var masked = _hostContext.SecretMasker.MaskSecrets(args.Data);
-                            SendOutput("stderr", masked + "\n");
-                        }
-                    };
-
-                    exitCode = await processInvoker.ExecuteAsync(
-                        workingDirectory: workingDirectory,
-                        fileName: commandPath,
-                        arguments: arguments,
-                        environment: environment,
-                        requireExitCodeZero: false,
-                        outputEncoding: null,
-                        killProcessOnCancel: true,
-                        cancellationToken: cancellationToken);
+                    const string hookWarning = "Container hooks are enabled. REPL output will not be streamed to the debug console for this command.";
+                    _trace.Warning(hookWarning);
+                    SendOutput("stderr", hookWarning + "\n");
                 }
 
+                // 9. Execute via IStepHost — handles docker exec for containers,
+                //    direct process execution for host, and container hooks
+                stepHost.OutputDataReceived += (sender, args) =>
+                {
+                    if (!string.IsNullOrEmpty(args.Data))
+                    {
+                        var masked = _hostContext.SecretMasker.MaskSecrets(args.Data);
+                        SendOutput("stdout", masked + "\n");
+                    }
+                };
+
+                stepHost.ErrorDataReceived += (sender, args) =>
+                {
+                    if (!string.IsNullOrEmpty(args.Data))
+                    {
+                        var masked = _hostContext.SecretMasker.MaskSecrets(args.Data);
+                        SendOutput("stderr", masked + "\n");
+                    }
+                };
+
+                int exitCode = await stepHost.ExecuteAsync(
+                    context: context,
+                    workingDirectory: workingDirectory,
+                    fileName: fileName,
+                    arguments: arguments,
+                    environment: environment,
+                    requireExitCodeZero: false,
+                    outputEncoding: null,
+                    killProcessOnCancel: true,
+                    inheritConsoleHandler: false,
+                    standardInInput: null,
+                    cancellationToken: cancellationToken);
+
                 _trace.Info($"REPL command exited with code {exitCode}");
 
-                // 8. Return only the exit code summary (output was already streamed)
+                // 10. Return only the exit code summary (output was already streamed)
                 return new EvaluateResponseBody
                 {
                     Result = exitCode == 0 ? $"(exit code: {exitCode})" : $"Process completed with exit code {exitCode}.",
@@ -198,6 +242,43 @@ namespace GitHub.Runner.Worker.Dap
             }
         }
 
+        /// <summary>
+        /// Creates the appropriate <see cref="IStepHost"/> for the current
+        /// execution context, mirroring how <see cref="ActionRunner"/> decides
+        /// between host and container execution.
+        ///
+        /// Only action steps (user-defined run:/uses: steps) run inside the
+        /// job container.  Infrastructure steps like "Set up job", "Initialize
+        /// containers", "Stop containers", and "Complete job" always execute
+        /// on the host regardless of whether a container is configured.
+        /// </summary>
+        internal IStepHost CreateStepHost(IExecutionContext context, bool isActionStep)
+        {
+            if (!isActionStep)
+            {
+                _trace.Info("Creating DefaultStepHost for REPL execution (infrastructure step)");
+                return _hostContext.CreateService<IDefaultStepHost>();
+            }
+
+            var container = context?.Global?.Container;
+            if (container != null)
+            {
+                // Container hooks don't always set ContainerId, but the container
+                // step host handles that internally
+                var hooksEnabled = FeatureManager.IsContainerHooksEnabled(context.Global?.Variables);
+                if (hooksEnabled || !string.IsNullOrEmpty(container.ContainerId))
+                {
+                    _trace.Info("Creating ContainerStepHost for REPL execution");
+                    var containerStepHost = _hostContext.CreateService<IContainerStepHost>();
+                    containerStepHost.Container = container;
+                    return containerStepHost;
+                }
+            }
+
+            _trace.Info("Creating DefaultStepHost for REPL execution");
+            return _hostContext.CreateService<IDefaultStepHost>();
+        }
+
         /// <summary>
         /// Expands <c>${{ }}</c> expressions in the input string using the
         /// runner's template evaluator — the same evaluation path that processes

src/Runner.Worker/Dap/DebuggerConfig.cs

@@ -1,4 +1,4 @@
-using GitHub.DistributedTask.Pipelines;
+using GitHub.DistributedTask.Pipelines;
 
 namespace GitHub.Runner.Worker.Dap
 {
@@ -8,10 +8,12 @@ namespace GitHub.Runner.Worker.Dap
     /// </summary>
     public sealed class DebuggerConfig
     {
-        public DebuggerConfig(bool enabled, DebuggerTunnelInfo tunnel)
+        public DebuggerConfig(bool enabled, DebuggerTunnelInfo tunnel, bool overrideWelcomeMessage = false, string welcomeMessage = null)
         {
             Enabled = enabled;
             Tunnel = tunnel;
+            OverrideWelcomeMessage = overrideWelcomeMessage;
+            WelcomeMessage = welcomeMessage;
         }
 
         /// <summary>Whether the debugger is enabled for this job.</summary>
@@ -23,6 +25,19 @@ namespace GitHub.Runner.Worker.Dap
         /// </summary>
         public DebuggerTunnelInfo Tunnel { get; }
 
+        /// <summary>
+        /// When true, the runner overrides the default welcome message with
+        /// <see cref="WelcomeMessage"/>. A null or empty <see cref="WelcomeMessage"/>
+        /// suppresses the message entirely. When false, the default help text is shown.
+        /// </summary>
+        public bool OverrideWelcomeMessage { get; }
+
+        /// <summary>
+        /// Optional welcome message content for the debugger console. Only used when
+        /// <see cref="OverrideWelcomeMessage"/> is true.
+        /// </summary>
+        public string WelcomeMessage { get; }
+
         /// <summary>Whether the tunnel configuration is complete and valid.</summary>
         public bool HasValidTunnel => Tunnel != null
             && !string.IsNullOrEmpty(Tunnel.TunnelId)

src/Runner.Worker/Dap/JobExecutionView.cs

@@ -10,9 +10,21 @@ namespace GitHub.Runner.Worker.Dap
     /// and provides O(1) lookup from <see cref="IStep"/> identity to the current line
     /// in the rendered YAML where that step's <c>- step:</c> key appears.
     ///
-    /// Append-only growth model: post-steps are discovered lazily during execution
-    /// and appended. Setup/pre/main entry line numbers are stable across appends —
-    /// only the synthetic Cleanup boundary (which is not tracked here) shifts.
+    /// Each <see cref="Append"/> can register the entry in one of three modes:
+    ///   - With a non-null <c>stepIdentity</c>: registers the IStep→line mapping
+    ///     immediately. Used for entries whose real <see cref="IStep"/> is already
+    ///     known at append time.
+    ///   - With a non-null <c>matchKey</c>: registers an unclaimed placeholder
+    ///     that a later <see cref="TryClaim"/> binds to a real <see cref="IStep"/>.
+    ///     Used for entries whose <see cref="IStep"/> is materialized later. A
+    ///     placeholder that is never claimed simply stays in the view and is never
+    ///     paused on — the IStep→line mapping is only populated on claim.
+    ///   - With neither: a static entry that needs no line lookup.
+    ///
+    /// <see cref="Append"/> and <see cref="AppendRange"/> never remove or reorder
+    /// existing entries. <see cref="TryClaim"/> does not re-render. The IStep→line
+    /// mapping is rebuilt on every render, so lookups stay accurate even if a later
+    /// Append happens to shift previously-emitted entries.
     /// </summary>
     internal sealed class JobExecutionView
     {
@@ -28,6 +40,7 @@ namespace GitHub.Runner.Worker.Dap
             new(StringComparer.Ordinal);
         private string _yaml;
         private IReadOnlyList<int> _entryStartLines = Array.Empty<int>();
+        private int _completeJobLine;
 
         public JobExecutionView(string jobId)
         {
@@ -60,6 +73,21 @@ namespace GitHub.Runner.Worker.Dap
             }
         }
 
+        /// <summary>
+        /// 1-based line where the synthetic <c>- step: Complete job</c> entry
+        /// appears in <see cref="Yaml"/>. Always non-zero — Cleanup is always emitted.
+        /// </summary>
+        public int CompleteJobLine
+        {
+            get
+            {
+                lock (_lock)
+                {
+                    return _completeJobLine;
+                }
+            }
+        }
+
         /// <summary>Number of entries (excludes synthetic Setup/Cleanup boundaries).</summary>
         public int EntryCount
         {
@@ -113,20 +141,25 @@ namespace GitHub.Runner.Worker.Dap
         }
 
         /// <summary>
-        /// Append a new entry. If <paramref name="stepIdentity"/> is non-null,
-        /// registers the IStep -> line mapping for later lookup. If
-        /// <paramref name="matchKey"/> is non-null, the entry is registered
-        /// as an unclaimed placeholder that a future
-        /// <see cref="TryClaim(string, IStep)"/> call can bind to a real
-        /// IStep (used by the predictive Post-step path). Re-renders the
-        /// YAML and updates the start-line table.
+        /// Append a new entry. Exactly one of <paramref name="stepIdentity"/>
+        /// or <paramref name="matchKey"/> may be non-null (or both may be
+        /// null for a static entry that needs no line lookup):
+        ///   - <paramref name="stepIdentity"/> non-null: registers the
+        ///     IStep→line mapping immediately. Use when the real
+        ///     <see cref="IStep"/> is known at append time.
+        ///   - <paramref name="matchKey"/> non-null: registers an unclaimed
+        ///     placeholder that a later <see cref="TryClaim"/> binds to a
+        ///     real <see cref="IStep"/>.
+        /// Re-renders the YAML and updates the start-line table.
         /// </summary>
         /// <returns>1-based line number of the newly-appended entry's <c>- step:</c> key.</returns>
         public int Append(JobExecutionViewEntry entry, IStep stepIdentity = null, string matchKey = null)
         {
-            if (entry == null)
+            ArgUtil.NotNull(entry, nameof(entry));
+            if (stepIdentity != null && matchKey != null)
             {
-                throw new ArgumentNullException(nameof(entry));
+                throw new ArgumentException(
+                    "Append cannot register both a step identity and a placeholder match key on the same entry; pass at most one.");
             }
 
             lock (_lock)
@@ -193,46 +226,6 @@ namespace GitHub.Runner.Worker.Dap
             }
         }
 
-        /// <summary>
-        /// Mark a previously-appended unclaimed placeholder as skipped. Used
-        /// when the predicting Main step never runs (skipped by <c>if:</c>),
-        /// so its predicted Post-step placeholder should not appear as a
-        /// step that will execute. Re-renders the view (inline comment only
-        /// — subsequent entry line numbers stay stable).
-        /// </summary>
-        /// <returns>
-        /// true if a matching unclaimed placeholder was marked; false when
-        /// no placeholder exists for <paramref name="matchKey"/>, or the
-        /// placeholder has already been claimed (claim wins).
-        /// </returns>
-        public bool TryMarkSkipped(string matchKey)
-        {
-            ArgUtil.NotNull(matchKey, nameof(matchKey));
-
-            lock (_lock)
-            {
-                if (!_unclaimedByKey.TryGetValue(matchKey, out int index))
-                {
-                    return false;
-                }
-                // Defensive: only mark if it's still an unclaimed placeholder.
-                if (_stepIdentities[index] != null)
-                {
-                    return false;
-                }
-
-                if (_entries[index].IsSkipped)
-                {
-                    // Idempotent — already marked.
-                    return true;
-                }
-                _entries[index].IsSkipped = true;
-                _unclaimedByKey.Remove(matchKey);
-                Render();
-                return true;
-            }
-        }
-
         /// <summary>
         /// Bulk-append for the initial population. Equivalent to calling
         /// <see cref="Append"/> once per pair, but renders only once at the end.
@@ -284,6 +277,7 @@ namespace GitHub.Runner.Worker.Dap
             var result = JobExecutionViewRenderer.Render(_jobId, _entries.AsReadOnly());
             _yaml = result.Yaml;
             _entryStartLines = result.EntryStartLines;
+            _completeJobLine = result.CompleteJobLine;
 
             _lineByStep.Clear();
             for (int i = 0; i < _stepIdentities.Count; i++)

src/Runner.Worker/Dap/JobExecutionViewRenderer.cs

@@ -1,11 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
-using System.IO;
 using System.Text;
 using GitHub.Runner.Sdk;
-using YamlDotNet.Core;
-using YamlDotNet.Core.Events;
 
 namespace GitHub.Runner.Worker.Dap
 {
@@ -88,15 +85,6 @@ namespace GitHub.Runner.Worker.Dap
         public string WithYaml { get; }
         public string Shell { get; }
         public string WorkingDirectory { get; }
-
-        /// <summary>
-        /// Set when the corresponding step was skipped (e.g. predicted Post
-        /// placeholder for a Main step that never executed because its
-        /// <c>if:</c> evaluated false). Rendered as an inline YAML comment
-        /// on the entry's <c>- step:</c> line so subsequent entry line
-        /// numbers stay stable.
-        /// </summary>
-        public bool IsSkipped { get; internal set; }
     }
 
     /// <summary>
@@ -107,14 +95,21 @@ namespace GitHub.Runner.Worker.Dap
     /// </summary>
     internal readonly struct RenderResult
     {
-        public RenderResult(string yaml, IReadOnlyList<int> entryStartLines)
+        public RenderResult(string yaml, IReadOnlyList<int> entryStartLines, int completeJobLine)
         {
             Yaml = yaml;
             EntryStartLines = entryStartLines;
+            CompleteJobLine = completeJobLine;
         }
 
         public string Yaml { get; }
         public IReadOnlyList<int> EntryStartLines { get; }
+
+        /// <summary>
+        /// 1-based line where the synthetic <c>- step: Complete job</c> entry
+        /// appears in <see cref="Yaml"/>. Always non-zero — Cleanup is always emitted.
+        /// </summary>
+        public int CompleteJobLine { get; }
     }
 
     /// <summary>
@@ -153,7 +148,7 @@ namespace GitHub.Runner.Worker.Dap
             int newlinesEmitted = 0;
 
             // Header (3 lines).
-            sb.Append("# Job: ").Append(FormatScalar(jobId)).Append('\n');
+            sb.Append("# Job: ").Append(YamlScalarFormatter.Format(jobId)).Append('\n');
             sb.Append("# Runner execution plan — read-only.\n");
             sb.Append('\n');
             newlinesEmitted += 3;
@@ -172,9 +167,11 @@ namespace GitHub.Runner.Worker.Dap
             // cleanup: section — always present, preceded by a blank line.
             sb.Append('\n');
             sb.Append("cleanup:\n");
+            newlinesEmitted += 2;
+            int completeJobLine = newlinesEmitted + 1;
             sb.Append("  - step: Complete job\n");
 
-            return new RenderResult(sb.ToString(), Array.AsReadOnly(startLines));
+            return new RenderResult(sb.ToString(), Array.AsReadOnly(startLines), completeJobLine);
         }
 
         private static void EmitPhaseSection(
@@ -212,12 +209,7 @@ namespace GitHub.Runner.Worker.Dap
                 // 1-based line of the `- step:` key for this entry.
                 startLines[i] = newlinesEmitted + 1;
 
-                sb.Append("  - step: ").Append(FormatScalar(entry.DisplayName));
-                if (entry.IsSkipped)
-                {
-                    // Inline comment — keeps following entry line numbers stable.
-                    sb.Append("  # (skipped — main step did not execute)");
-                }
+                sb.Append("  - step: ").Append(YamlScalarFormatter.Format(entry.DisplayName));
                 sb.Append('\n');
                 newlinesEmitted++;
 
@@ -227,7 +219,7 @@ namespace GitHub.Runner.Worker.Dap
                     case JobExecutionPhase.Post:
                         if (!string.IsNullOrEmpty(entry.Uses))
                         {
-                            sb.Append("    action: ").Append(FormatScalar(entry.Uses)).Append('\n');
+                            sb.Append("    action: ").Append(YamlScalarFormatter.Format(entry.Uses)).Append('\n');
                             newlinesEmitted++;
                         }
                         // No source: annotation for pre/post.
@@ -236,19 +228,19 @@ namespace GitHub.Runner.Worker.Dap
                     case JobExecutionPhase.Main:
                         if (!string.IsNullOrEmpty(entry.Id))
                         {
-                            sb.Append("    id: ").Append(FormatScalar(entry.Id)).Append('\n');
+                            sb.Append("    id: ").Append(YamlScalarFormatter.Format(entry.Id)).Append('\n');
                             newlinesEmitted++;
                         }
                         if (!string.IsNullOrEmpty(entry.Uses))
                         {
-                            sb.Append("    uses: ").Append(FormatScalar(entry.Uses)).Append('\n');
+                            sb.Append("    uses: ").Append(YamlScalarFormatter.Format(entry.Uses)).Append('\n');
                             newlinesEmitted++;
                         }
                         if (!string.IsNullOrEmpty(entry.Run))
                         {
                             if (entry.Run.IndexOf('\n') < 0)
                             {
-                                sb.Append("    run: ").Append(FormatScalar(entry.Run)).Append('\n');
+                                sb.Append("    run: ").Append(YamlScalarFormatter.Format(entry.Run)).Append('\n');
                                 newlinesEmitted++;
                             }
                             else
@@ -260,7 +252,7 @@ namespace GitHub.Runner.Worker.Dap
                         }
                         if (!string.IsNullOrEmpty(entry.If))
                         {
-                            sb.Append("    if: ").Append(FormatScalar(entry.If)).Append('\n');
+                            sb.Append("    if: ").Append(YamlScalarFormatter.Format(entry.If)).Append('\n');
                             newlinesEmitted++;
                         }
                         if (!string.IsNullOrEmpty(entry.ContinueOnError))
@@ -289,12 +281,12 @@ namespace GitHub.Runner.Worker.Dap
                         }
                         if (!string.IsNullOrEmpty(entry.Shell))
                         {
-                            sb.Append("    shell: ").Append(FormatScalar(entry.Shell)).Append('\n');
+                            sb.Append("    shell: ").Append(YamlScalarFormatter.Format(entry.Shell)).Append('\n');
                             newlinesEmitted++;
                         }
                         if (!string.IsNullOrEmpty(entry.WorkingDirectory))
                         {
-                            sb.Append("    working-directory: ").Append(FormatScalar(entry.WorkingDirectory)).Append('\n');
+                            sb.Append("    working-directory: ").Append(YamlScalarFormatter.Format(entry.WorkingDirectory)).Append('\n');
                             newlinesEmitted++;
                         }
                         if (entry.SourcePath != null)
@@ -349,43 +341,5 @@ namespace GitHub.Runner.Worker.Dap
             }
             return n;
         }
-
-        /// <summary>
-        /// Formats a single string as a YAML 1.x flow scalar, delegating
-        /// quoting/escaping decisions to YamlDotNet. This avoids maintaining
-        /// our own escape table for every YAML-significant character: we
-        /// just emit the value through the YAML library and use whichever
-        /// scalar style (plain, single-quoted, double-quoted) it picks.
-        /// A new <see cref="Emitter"/> is created per call, so the helper
-        /// is safe to invoke concurrently.
-        /// </summary>
-        internal static string FormatScalar(string value)
-        {
-            if (value == null)
-            {
-                throw new ArgumentNullException(nameof(value));
-            }
-
-            using var sw = new StringWriter(CultureInfo.InvariantCulture);
-            var emitter = new Emitter(sw);
-            emitter.Emit(new StreamStart());
-            emitter.Emit(new DocumentStart(null, null, true));
-            emitter.Emit(new Scalar(null, null, value, ScalarStyle.Any, true, true));
-            emitter.Emit(new DocumentEnd(true));
-            emitter.Emit(new StreamEnd());
-
-            string raw = sw.ToString();
-            if (raw.StartsWith("--- ", StringComparison.Ordinal))
-            {
-                raw = raw.Substring(4);
-            }
-            raw = raw.TrimEnd('\n');
-            const string DocEndMarker = "\n...";
-            if (raw.EndsWith(DocEndMarker, StringComparison.Ordinal))
-            {
-                raw = raw.Substring(0, raw.Length - DocEndMarker.Length);
-            }
-            return raw.TrimEnd('\n');
-        }
     }
 }

src/Runner.Worker/Dap/StepEntryTranslator.cs

@@ -16,12 +16,14 @@ namespace GitHub.Runner.Worker.Dap
     internal static class StepEntryTranslator
     {
         // Run-step internals carried on ActionStep.Inputs that are NOT
-        // user-authored `with:` entries.
+        // user-authored `with:` entries. The runner stores these under
+        // the keys defined in PipelineConstants.ScriptStepInputs, NOT
+        // their kebab-case workflow-YAML spellings.
         private static readonly HashSet<string> RunStepInternalKeys = new(StringComparer.Ordinal)
         {
-            "script",
-            "shell",
-            "working-directory",
+            PipelineConstants.ScriptStepInputs.Script,
+            PipelineConstants.ScriptStepInputs.Shell,
+            PipelineConstants.ScriptStepInputs.WorkingDirectory,
         };
 
         /// <summary>
@@ -116,11 +118,11 @@ namespace GitHub.Runner.Worker.Dap
                     var inputs = action.Inputs as MappingToken;
                     if (inputs != null)
                     {
-                        if (TryGetMapValue(inputs, "script", out var scriptTok) && scriptTok != null)
+                        if (TryGetMapValue(inputs, PipelineConstants.ScriptStepInputs.Script, out var scriptTok) && scriptTok != null)
                         {
                             run = scriptTok.ToString();
                         }
-                        if (TryGetMapValue(inputs, "shell", out var shellTok) && shellTok != null)
+                        if (TryGetMapValue(inputs, PipelineConstants.ScriptStepInputs.Shell, out var shellTok) && shellTok != null)
                         {
                             string shellText = shellTok.ToString();
                             if (!string.IsNullOrEmpty(shellText))
@@ -128,7 +130,7 @@ namespace GitHub.Runner.Worker.Dap
                                 shell = shellText;
                             }
                         }
-                        if (TryGetMapValue(inputs, "working-directory", out var wdTok) && wdTok != null)
+                        if (TryGetMapValue(inputs, PipelineConstants.ScriptStepInputs.WorkingDirectory, out var wdTok) && wdTok != null)
                         {
                             string wdText = wdTok.ToString();
                             if (!string.IsNullOrEmpty(wdText))

src/Runner.Worker/Dap/TemplateTokenYamlAdapter.cs

@@ -95,16 +95,32 @@ namespace GitHub.Runner.Worker.Dap
             }
 
             using var sw = new StringWriter(CultureInfo.InvariantCulture);
+            // Force LF line breaks; YamlDotNet's Emitter calls WriteLine,
+            // which would otherwise produce CRLF on Windows and corrupt
+            // both the document-end stripping below and the per-line
+            // indentation pass that follows.
+            sw.NewLine = "\n";
             var emitter = new Emitter(sw);
             var adapter = new TemplateTokenYamlAdapter(emitter);
-            TemplateWriter.Write(adapter, token);
+            adapter.WriteStart();
+            WriteToken(adapter, token);
+            adapter.WriteEnd();
 
             string raw = sw.ToString();
-            // Strip YAML document markers ("--- " prefix and "\n..." suffix).
+            // Strip YAML document markers. The Emitter most commonly elides
+            // these for our use (DocumentStart isImplicit=true), but emits
+            // them for some scalar edge cases (e.g. empty strings) and may
+            // emit them on their own line for collection roots under some
+            // settings. Strip both shapes defensively so callers never see
+            // a leaked marker leak into the embedded fragment.
             if (raw.StartsWith("--- ", StringComparison.Ordinal))
             {
                 raw = raw.Substring(4);
             }
+            else if (raw.StartsWith("---\n", StringComparison.Ordinal))
+            {
+                raw = raw.Substring(4);
+            }
             const string DocEndMarker = "\n...";
             if (raw.EndsWith(DocEndMarker + "\n", StringComparison.Ordinal))
             {
@@ -144,5 +160,64 @@ namespace GitHub.Runner.Worker.Dap
             }
             return sb.ToString();
         }
+
+        /// <summary>
+        /// Mirrors <see cref="TemplateWriter"/>'s recursive walk, with one
+        /// behavioural change: <see cref="BasicExpressionToken"/> is emitted
+        /// via <c>ToDisplayString()</c> instead of <c>ToString()</c>.
+        /// </summary>
+        /// <remarks>
+        /// The workflow parser tokenizes a mixed scalar like
+        /// <c>${{ runner.os }}-primes</c> as a single
+        /// <see cref="BasicExpressionToken"/> whose internal expression is
+        /// <c>format('{0}-primes', runner.os)</c>. <c>ToString()</c> emits
+        /// the normalized form verbatim; <c>ToDisplayString()</c> reverses
+        /// the <c>format(...)</c> rewrite so the user sees the original
+        /// authored form. Other token kinds delegate to the same writer
+        /// calls <see cref="TemplateWriter"/> would make.
+        /// </remarks>
+        private static void WriteToken(IObjectWriter writer, TemplateToken token)
+        {
+            switch (token?.Type ?? TokenType.Null)
+            {
+                case TokenType.Null:
+                    writer.WriteNull();
+                    break;
+                case TokenType.Boolean:
+                    writer.WriteBoolean(((BooleanToken)token).Value);
+                    break;
+                case TokenType.Number:
+                    writer.WriteNumber(((NumberToken)token).Value);
+                    break;
+                case TokenType.String:
+                    writer.WriteString(token.ToString());
+                    break;
+                case TokenType.BasicExpression:
+                    writer.WriteString(((BasicExpressionToken)token).ToDisplayString());
+                    break;
+                case TokenType.InsertExpression:
+                    writer.WriteString(token.ToString());
+                    break;
+                case TokenType.Mapping:
+                    writer.WriteMappingStart();
+                    foreach (var pair in (MappingToken)token)
+                    {
+                        WriteToken(writer, pair.Key);
+                        WriteToken(writer, pair.Value);
+                    }
+                    writer.WriteMappingEnd();
+                    break;
+                case TokenType.Sequence:
+                    writer.WriteSequenceStart();
+                    foreach (var item in (SequenceToken)token)
+                    {
+                        WriteToken(writer, item);
+                    }
+                    writer.WriteSequenceEnd();
+                    break;
+                default:
+                    throw new NotSupportedException($"Unexpected token type '{token.GetType()}'.");
+            }
+        }
     }
 }

src/Runner.Worker/Dap/YamlScalarFormatter.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Globalization;
+using System.IO;
+using GitHub.Runner.Sdk;
+using YamlDotNet.Core;
+using YamlDotNet.Core.Events;
+
+namespace GitHub.Runner.Worker.Dap
+{
+    /// <summary>
+    /// Formats a single string as a quote-safe YAML scalar by routing it
+    /// through YamlDotNet's <see cref="Emitter"/>. The returned text is
+    /// safe to splice into a hand-emitted YAML document fragment.
+    ///
+    /// Caller responsibility: this only handles the scalar value; it does
+    /// not emit a key, indent, or trailing newline.
+    /// </summary>
+    internal static class YamlScalarFormatter
+    {
+        /// <summary>
+        /// Return <paramref name="value"/> formatted as a YAML scalar:
+        /// plain, single-quoted, or double-quoted as the emitter chooses,
+        /// with no surrounding document markers or trailing newline.
+        /// </summary>
+        public static string Format(string value)
+        {
+            ArgUtil.NotNull(value, nameof(value));
+
+            using var sw = new StringWriter(CultureInfo.InvariantCulture);
+            // Force LF line breaks; YamlDotNet's Emitter calls WriteLine,
+            // which would otherwise produce CRLF on Windows and break
+            // both our document-end stripping below and downstream
+            // consumers that assume a single line-break convention.
+            sw.NewLine = "\n";
+            var emitter = new Emitter(sw);
+            emitter.Emit(new StreamStart());
+            emitter.Emit(new DocumentStart(null, null, true));
+            emitter.Emit(new Scalar(null, null, value, ScalarStyle.Any, true, true));
+            emitter.Emit(new DocumentEnd(true));
+            emitter.Emit(new StreamEnd());
+
+            string raw = sw.ToString();
+            // Strip YAML document markers. Emitter elides these for most
+            // scalars but emits "--- " (with space) for some edge cases
+            // (e.g. empty strings). Defensively handle "---\n" too.
+            if (raw.StartsWith("--- ", StringComparison.Ordinal))
+            {
+                raw = raw.Substring(4);
+            }
+            else if (raw.StartsWith("---\n", StringComparison.Ordinal))
+            {
+                raw = raw.Substring(4);
+            }
+            raw = raw.TrimEnd('\n');
+            const string DocEndMarker = "\n...";
+            if (raw.EndsWith(DocEndMarker, StringComparison.Ordinal))
+            {
+                raw = raw.Substring(0, raw.Length - DocEndMarker.Length);
+            }
+            return raw;
+        }
+    }
+}

src/Runner.Worker/ExecutionContext.cs

@@ -978,7 +978,8 @@ namespace GitHub.Runner.Worker
             Global.WriteDebug = Global.Variables.Step_Debug ?? false;
 
             // Debugger enabled flag (from acquire response).
-            Global.Debugger = new Dap.DebuggerConfig(message.EnableDebugger, message.DebuggerTunnel);
+            var overrideDebuggerWelcomeMessage = Global.Variables.GetBoolean(Constants.Runner.Features.OverrideDebuggerWelcomeMessage) ?? false;
+            Global.Debugger = new Dap.DebuggerConfig(message.EnableDebugger, message.DebuggerTunnel, overrideDebuggerWelcomeMessage, message.DebuggerWelcomeMessage);
 
             // Hook up JobServerQueueThrottling event, we will log warning on server tarpit.
             _jobServerQueue.JobServerQueueThrottling += JobServerQueueThrottling_EventReceived;

src/Runner.Worker/Handlers/NodeScriptActionHandler.cs

@@ -12,6 +12,7 @@ using GitHub.Runner.Common.Util;
 using GitHub.Runner.Sdk;
 using GitHub.Runner.Worker.Container;
 using GitHub.Runner.Worker.Container.ContainerHooks;
+using GitHub.Services.Common;
 
 namespace GitHub.Runner.Worker.Handlers
 {
@@ -128,6 +129,15 @@ namespace GitHub.Runner.Worker.Handlers
             // file name character on Linux.
             string arguments = StepHost.ResolvePathForStepHost(ExecutionContext, StringUtil.Format(@"""{0}""", target.Replace(@"""", @"\""")));
 
+            // Disable maglev jit compiler in node.js 24.x.x on x64 Windows until the node.js bug is fixed.
+            // https://github.com/nodejs/node/issues/62260
+            if (nodeRuntimeVersion.StartsWith("node24", StringComparison.OrdinalIgnoreCase) &&
+                (StringUtil.ConvertToBoolean(System.Environment.GetEnvironmentVariable("ACTIONS_RUNNER_DISABLE_NODE_MAGLEV")) || StringUtil.ConvertToBoolean(Environment.GetValueOrDefault("ACTIONS_RUNNER_DISABLE_NODE_MAGLEV"))))
+            {
+                Trace.Info("Disable maglev jit compiler in node.js");
+                arguments = $"--no-maglev {arguments}";
+            }
+
 #if OS_WINDOWS
             // It appears that node.exe outputs UTF8 when not in TTY mode.
             Encoding outputEncoding = Encoding.UTF8;

src/Runner.Worker/StepsRunner.cs

@@ -219,18 +219,12 @@ namespace GitHub.Runner.Worker
                             // Condition is false
                             Trace.Info("Skipping step due to condition evaluation.");
                             CompleteStep(step, TaskResult.Skipped, resultCode: conditionTraceWriter.Trace);
-                            // Notify the DAP debugger so any predicted Post-step
-                            // placeholder for this Main step can be marked as
-                            // skipped — otherwise the rendered view leaves a
-                            // stale "Post X" entry for a step that never ran.
-                            dapDebugger?.OnStepCompleted(step);
                         }
                         else if (conditionEvaluateError != null)
                         {
                             // Condition error
                             step.ExecutionContext.Error(conditionEvaluateError);
                             CompleteStep(step, TaskResult.Failed);
-                            dapDebugger?.OnStepCompleted(step);
                         }
                         else
                         {

src/Sdk/DTPipelines/Pipelines/AgentJobRequestMessage.cs

@@ -267,6 +267,21 @@ namespace GitHub.DistributedTask.Pipelines
             set;
         }
 
+        /// <summary>
+        /// Optional welcome message shown in the debugger console when a client connects.
+        /// Only used when the <c>actions_runner_override_debugger_welcome_message</c>
+        /// feature flag is set to <c>true</c> in the job variables. With the flag set,
+        /// a non-empty value is shown as-is and a null or empty value suppresses the
+        /// default welcome message. When the flag is not set, the runner shows its
+        /// built-in help text and this field is ignored.
+        /// </summary>
+        [DataMember(EmitDefaultValue = false)]
+        public string DebuggerWelcomeMessage
+        {
+            get;
+            set;
+        }
+
         /// <summary>
         /// Gets the workflow-level action dependencies (lockfile entries)
         /// </summary>

src/Sdk/DTPipelines/workflow-v1.0.json

@@ -186,7 +186,16 @@
         "vars",
         "needs",
         "strategy",
-        "matrix"
+        "matrix",
+        "steps",
+        "job",
+        "runner",
+        "env",
+        "always(0,0)",
+        "failure(0,0)",
+        "cancelled(0,0)",
+        "success(0,0)",
+        "hashFiles(1,255)"
       ],
       "string": {}
     },

src/Sdk/WorkflowParser/Conversion/WorkflowTemplateConverter.cs

@@ -2291,6 +2291,10 @@ namespace GitHub.Actions.WorkflowParser.Conversion
             new NamedValueInfo<NoOperationNamedValue>(WorkflowTemplateConstants.Needs),
             new NamedValueInfo<NoOperationNamedValue>(WorkflowTemplateConstants.Strategy),
             new NamedValueInfo<NoOperationNamedValue>(WorkflowTemplateConstants.Matrix),
+            new NamedValueInfo<NoOperationNamedValue>(WorkflowTemplateConstants.Steps),
+            new NamedValueInfo<NoOperationNamedValue>(WorkflowTemplateConstants.Job),
+            new NamedValueInfo<NoOperationNamedValue>(WorkflowTemplateConstants.Runner),
+            new NamedValueInfo<NoOperationNamedValue>(WorkflowTemplateConstants.Env),
         };
         private static readonly IFunctionInfo[] s_jobConditionFunctions = new IFunctionInfo[]
         {
@@ -2307,6 +2311,13 @@ namespace GitHub.Actions.WorkflowParser.Conversion
             new FunctionInfo<NoOperation>(WorkflowTemplateConstants.Success, 0, 0),
             new FunctionInfo<NoOperation>(WorkflowTemplateConstants.HashFiles, 1, Byte.MaxValue),
         };
-        private static readonly IFunctionInfo[] s_snapshotConditionFunctions = null;
+        private static readonly IFunctionInfo[] s_snapshotConditionFunctions = new IFunctionInfo[]
+        {
+            new FunctionInfo<NoOperation>(WorkflowTemplateConstants.Always, 0, 0),
+            new FunctionInfo<NoOperation>(WorkflowTemplateConstants.Cancelled, 0, 0),
+            new FunctionInfo<NoOperation>(WorkflowTemplateConstants.Failure, 0, 0),
+            new FunctionInfo<NoOperation>(WorkflowTemplateConstants.Success, 0, 0),
+            new FunctionInfo<NoOperation>(WorkflowTemplateConstants.HashFiles, 1, Byte.MaxValue),
+        };
     }
 }

src/Sdk/WorkflowParser/workflow-v1.0.json

@@ -2196,7 +2196,16 @@
         "vars",
         "needs",
         "strategy",
-        "matrix"
+        "matrix",
+        "steps",
+        "job",
+        "runner",
+        "env",
+        "always(0,0)",
+        "failure(0,0)",
+        "cancelled(0,0)",
+        "success(0,0)",
+        "hashFiles(1,255)"
       ],
       "description": "Use the if conditional to prevent a snapshot from being taken unless a condition is met. Any supported context and expression can be used to create a conditional. Expressions in an `if` conditional do not require the bracketed expression syntax. When you use expressions in an `if` conditional, you may omit the expression syntax because GitHub automatically evaluates the `if` conditional as an expression.",
       "string": {

src/Test/L0/Sdk/RSWebApi/AgentJobRequestMessageL0.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using System.Runtime.Serialization.Json;
 using System.Text;
@@ -17,13 +17,13 @@ public sealed class AgentJobRequestMessageL0
         // Arrange
         var serializer = new DataContractJsonSerializer(typeof(AgentJobRequestMessage));
         string jsonWithEnabledDebugger = DoubleQuotify("{'EnableDebugger': true}");
-        
+
         // Act
         using var stream = new MemoryStream();
         stream.Write(Encoding.UTF8.GetBytes(jsonWithEnabledDebugger));
         stream.Position = 0;
         var recoveredMessage = serializer.ReadObject(stream) as AgentJobRequestMessage;
-        
+
         // Assert
         Assert.NotNull(recoveredMessage);
         Assert.True(recoveredMessage.EnableDebugger, "EnableDebugger should be true when JSON contains 'EnableDebugger': true");
@@ -37,13 +37,13 @@ public sealed class AgentJobRequestMessageL0
         // Arrange
         var serializer = new DataContractJsonSerializer(typeof(AgentJobRequestMessage));
         string jsonWithoutDebugger = DoubleQuotify("{'messageType': 'PipelineAgentJobRequest'}");
-        
+
         // Act
         using var stream = new MemoryStream();
         stream.Write(Encoding.UTF8.GetBytes(jsonWithoutDebugger));
         stream.Position = 0;
         var recoveredMessage = serializer.ReadObject(stream) as AgentJobRequestMessage;
-        
+
         // Assert
         Assert.NotNull(recoveredMessage);
         Assert.False(recoveredMessage.EnableDebugger, "EnableDebugger should default to false when JSON field is absent");
@@ -57,13 +57,13 @@ public sealed class AgentJobRequestMessageL0
         // Arrange
         var serializer = new DataContractJsonSerializer(typeof(AgentJobRequestMessage));
         string jsonWithDisabledDebugger = DoubleQuotify("{'EnableDebugger': false}");
-        
+
         // Act
         using var stream = new MemoryStream();
         stream.Write(Encoding.UTF8.GetBytes(jsonWithDisabledDebugger));
         stream.Position = 0;
         var recoveredMessage = serializer.ReadObject(stream) as AgentJobRequestMessage;
-        
+
         // Assert
         Assert.NotNull(recoveredMessage);
         Assert.False(recoveredMessage.EnableDebugger, "EnableDebugger should be false when JSON contains 'EnableDebugger': false");
@@ -161,6 +161,26 @@ public sealed class AgentJobRequestMessageL0
         Assert.Empty(recoveredMessage.ActionsDependencies);
     }
 
+    [Fact]
+    [Trait("Level", "L0")]
+    [Trait("Category", "Common")]
+    public void VerifyDebuggerWelcomeMessageRoundTrips()
+    {
+        // Arrange
+        var serializer = new DataContractJsonSerializer(typeof(AgentJobRequestMessage));
+        string json = DoubleQuotify("{'DebuggerWelcomeMessage': 'Welcome to debugging!'}");
+
+        // Act
+        using var stream = new MemoryStream();
+        stream.Write(Encoding.UTF8.GetBytes(json));
+        stream.Position = 0;
+        var recoveredMessage = serializer.ReadObject(stream) as AgentJobRequestMessage;
+
+        // Assert
+        Assert.NotNull(recoveredMessage);
+        Assert.Equal("Welcome to debugging!", recoveredMessage.DebuggerWelcomeMessage);
+    }
+
     private static string DoubleQuotify(string text)
     {
         return text.Replace('\'', '"');

src/Test/L0/Worker/DapDebuggerL0.cs

@@ -236,7 +236,7 @@ namespace GitHub.Runner.Common.Tests.Worker
             }
         }
 
-        private static Mock<IExecutionContext> CreateJobContextWithTunnel(CancellationToken cancellationToken, ushort port, string jobName = null)
+        private static Mock<IExecutionContext> CreateJobContextWithTunnel(CancellationToken cancellationToken, ushort port, string jobName = null, bool overrideWelcomeMessage = false, string welcomeMessage = null)
         {
             var tunnel = new GitHub.DistributedTask.Pipelines.DebuggerTunnelInfo
             {
@@ -245,7 +245,7 @@ namespace GitHub.Runner.Common.Tests.Worker
                 HostToken = "test-token",
                 Port = port
             };
-            var debuggerConfig = new DebuggerConfig(true, tunnel);
+            var debuggerConfig = new DebuggerConfig(true, tunnel, overrideWelcomeMessage, welcomeMessage);
             var jobContext = new Mock<IExecutionContext>();
             jobContext.Setup(x => x.CancellationToken).Returns(cancellationToken);
             jobContext.Setup(x => x.Global).Returns(new GlobalContext { Debugger = debuggerConfig });
@@ -742,6 +742,8 @@ namespace GitHub.Runner.Common.Tests.Worker
 
                 // Read the configurationDone response
                 await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                // Read the welcome message output event
+                await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
                 await waitTask;
 
                 // Complete the job — OnJobCompletedAsync pauses when stepping,
@@ -849,6 +851,8 @@ namespace GitHub.Runner.Common.Tests.Worker
                     Command = "configurationDone"
                 });
 
+                await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                // Read the welcome message output event
                 await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
                 await waitTask;
 
@@ -868,6 +872,225 @@ namespace GitHub.Runner.Common.Tests.Worker
             }
         }
 
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public async Task WelcomeMessageSendsDefaultHelpWhenOverrideDisabled()
+        {
+            using (CreateTestContext())
+            {
+                var port = GetFreePort();
+                using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+                var jobContext = CreateJobContextWithTunnel(cts.Token, port);
+                await _debugger.StartAsync(jobContext.Object);
+
+                using var client = await ConnectClientAsync(port);
+                var stream = client.GetStream();
+
+                await SendRequestAsync(stream, new Request
+                {
+                    Seq = 1,
+                    Type = "request",
+                    Command = "configurationDone"
+                });
+
+                // First message: configurationDone response
+                var configDoneResponse = await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                Assert.Contains("\"command\":\"configurationDone\"", configDoneResponse);
+
+                // Second message: welcome output event with default help text
+                var welcomeMsg = await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                Assert.Contains("\"event\":\"output\"", welcomeMsg);
+                Assert.Contains("\"category\":\"console\"", welcomeMsg);
+                Assert.Contains("Actions Debug Console", welcomeMsg);
+                Assert.Contains("help", welcomeMsg);
+
+                await _debugger.StopAsync();
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public async Task WelcomeMessageShowsCustomMessageWhenOverrideEnabled()
+        {
+            using (CreateTestContext())
+            {
+                var port = GetFreePort();
+                using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+                var jobContext = CreateJobContextWithTunnel(cts.Token, port,
+                    overrideWelcomeMessage: true,
+                    welcomeMessage: "Welcome to debugging!");
+                await _debugger.StartAsync(jobContext.Object);
+
+                using var client = await ConnectClientAsync(port);
+                var stream = client.GetStream();
+
+                await SendRequestAsync(stream, new Request
+                {
+                    Seq = 1,
+                    Type = "request",
+                    Command = "configurationDone"
+                });
+
+                // First: configurationDone response
+                var configDoneResponse = await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                Assert.Contains("\"command\":\"configurationDone\"", configDoneResponse);
+
+                // Second: custom welcome message
+                var welcomeMsg = await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                Assert.Contains("\"event\":\"output\"", welcomeMsg);
+                Assert.Contains("Welcome to debugging!", welcomeMsg);
+
+                await _debugger.StopAsync();
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public async Task WelcomeMessageSuppressedWhenOverrideEnabledWithEmptyMessage()
+        {
+            using (CreateTestContext())
+            {
+                var port = GetFreePort();
+                using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+                var jobContext = CreateJobContextWithTunnel(cts.Token, port,
+                    overrideWelcomeMessage: true,
+                    welcomeMessage: "");
+                await _debugger.StartAsync(jobContext.Object);
+
+                using var client = await ConnectClientAsync(port);
+                var stream = client.GetStream();
+
+                await SendRequestAsync(stream, new Request
+                {
+                    Seq = 1,
+                    Type = "request",
+                    Command = "configurationDone"
+                });
+
+                // Read configurationDone response
+                var configDoneResponse = await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                Assert.Contains("\"command\":\"configurationDone\"", configDoneResponse);
+
+                // Send threads request — if welcome message was suppressed, this
+                // should be the next response (no output event in between)
+                await SendRequestAsync(stream, new Request
+                {
+                    Seq = 2,
+                    Type = "request",
+                    Command = "threads"
+                });
+
+                var threadsResponse = await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                Assert.Contains("\"command\":\"threads\"", threadsResponse);
+
+                await _debugger.StopAsync();
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public async Task WelcomeMessageSuppressedWhenOverrideEnabledWithNullMessage()
+        {
+            using (CreateTestContext())
+            {
+                var port = GetFreePort();
+                using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+                var jobContext = CreateJobContextWithTunnel(cts.Token, port,
+                    overrideWelcomeMessage: true,
+                    welcomeMessage: null);
+                await _debugger.StartAsync(jobContext.Object);
+
+                using var client = await ConnectClientAsync(port);
+                var stream = client.GetStream();
+
+                await SendRequestAsync(stream, new Request
+                {
+                    Seq = 1,
+                    Type = "request",
+                    Command = "configurationDone"
+                });
+
+                // Read configurationDone response
+                var configDoneResponse = await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                Assert.Contains("\"command\":\"configurationDone\"", configDoneResponse);
+
+                // Send threads request — if welcome message was suppressed, this
+                // should be the next response (no output event in between)
+                await SendRequestAsync(stream, new Request
+                {
+                    Seq = 2,
+                    Type = "request",
+                    Command = "threads"
+                });
+
+                var threadsResponse = await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                Assert.Contains("\"command\":\"threads\"", threadsResponse);
+
+                await _debugger.StopAsync();
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public async Task WelcomeMessageSentOnlyOnce()
+        {
+            using (CreateTestContext())
+            {
+                var port = GetFreePort();
+                using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+                var jobContext = CreateJobContextWithTunnel(cts.Token, port);
+                await _debugger.StartAsync(jobContext.Object);
+
+                using var client = await ConnectClientAsync(port);
+                var stream = client.GetStream();
+
+                // First configurationDone
+                await SendRequestAsync(stream, new Request
+                {
+                    Seq = 1,
+                    Type = "request",
+                    Command = "configurationDone"
+                });
+
+                var configDoneResponse = await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                Assert.Contains("\"command\":\"configurationDone\"", configDoneResponse);
+
+                // Welcome message should appear
+                var welcomeMsg = await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                Assert.Contains("\"event\":\"output\"", welcomeMsg);
+                Assert.Contains("Actions Debug Console", welcomeMsg);
+
+                // Second configurationDone — should NOT produce another welcome message
+                await SendRequestAsync(stream, new Request
+                {
+                    Seq = 2,
+                    Type = "request",
+                    Command = "configurationDone"
+                });
+
+                var secondResponse = await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                Assert.Contains("\"command\":\"configurationDone\"", secondResponse);
+
+                // Next message should be threads response, not another welcome output
+                await SendRequestAsync(stream, new Request
+                {
+                    Seq = 3,
+                    Type = "request",
+                    Command = "threads"
+                });
+
+                var threadsResponse = await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                Assert.Contains("\"command\":\"threads\"", threadsResponse);
+
+                await _debugger.StopAsync();
+            }
+        }
+
         // ---------------------------------------------------------------------
         // Phase 2c: synthesized execution view as DAP source.
         // ---------------------------------------------------------------------
@@ -1339,6 +1562,7 @@ namespace GitHub.Runner.Common.Tests.Worker
                     var stream = client.GetStream();
                     await SendRequestAsync(stream, new Request { Seq = 1, Type = "request", Command = "configurationDone" });
                     await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5)); // configurationDone response
+                    await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5)); // welcome output event
                     await _debugger.WaitUntilReadyAsync();
 
                     var step = NewActionRunner(GitHub.Runner.Worker.ActionRunStage.Main, "Run").Object;
@@ -1372,7 +1596,8 @@ namespace GitHub.Runner.Common.Tests.Worker
                 {
                     var stream = client.GetStream();
                     await SendRequestAsync(stream, new Request { Seq = 1, Type = "request", Command = "configurationDone" });
-                    await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
+                    await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5)); // configurationDone response
+                    await ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5)); // welcome output event
                     await _debugger.WaitUntilReadyAsync();
 
                     var main = NewActionRunner(GitHub.Runner.Worker.ActionRunStage.Main, "Run").Object;

src/Test/L0/Worker/DapReplExecutorL0.cs

@@ -5,9 +5,12 @@ using System.Threading;
 using System.Threading.Tasks;
 using GitHub.DistributedTask.Expressions2;
 using GitHub.DistributedTask.Pipelines.ContextData;
+using GitHub.DistributedTask.WebApi;
 using GitHub.Runner.Common.Tests;
 using GitHub.Runner.Worker;
+using GitHub.Runner.Worker.Container;
 using GitHub.Runner.Worker.Dap;
+using GitHub.Runner.Worker.Handlers;
 using Moq;
 using Xunit;
 
@@ -40,7 +43,8 @@ namespace GitHub.Runner.Common.Tests.Worker
 
         private Mock<IExecutionContext> CreateMockContext(
             DictionaryContextData exprValues = null,
-            IDictionary<string, IDictionary<string, string>> jobDefaults = null)
+            IDictionary<string, IDictionary<string, string>> jobDefaults = null,
+            ContainerInfo container = null)
         {
             var mock = new Mock<IExecutionContext>();
             mock.Setup(x => x.ExpressionValues).Returns(exprValues ?? new DictionaryContextData());
@@ -51,6 +55,7 @@ namespace GitHub.Runner.Common.Tests.Worker
                 PrependPath = new List<string>(),
                 JobDefaults = jobDefaults
                     ?? new Dictionary<string, IDictionary<string, string>>(StringComparer.OrdinalIgnoreCase),
+                Container = container,
             };
             mock.Setup(x => x.Global).Returns(global);
 
@@ -65,7 +70,7 @@ namespace GitHub.Runner.Common.Tests.Worker
             using (CreateTestContext())
             {
                 var command = new RunCommand { Script = "echo hello" };
-                var result = await _executor.ExecuteRunCommandAsync(command, null, CancellationToken.None);
+                var result = await _executor.ExecuteRunCommandAsync(command, null, false, CancellationToken.None);
 
                 Assert.Equal("error", result.Type);
                 Assert.Contains("No execution context available", result.Result);
@@ -233,5 +238,101 @@ namespace GitHub.Runner.Common.Tests.Worker
                 Assert.False(result.ContainsKey("BAZ"));
             }
         }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void CreateStepHost_NoContainer_ReturnsDefaultStepHost()
+        {
+            using (var hc = CreateTestContext())
+            {
+                hc.EnqueueInstance<IDefaultStepHost>(new DefaultStepHost());
+                var context = CreateMockContext();
+                var result = _executor.CreateStepHost(context.Object, isActionStep: true);
+
+                Assert.IsType<DefaultStepHost>(result);
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void CreateStepHost_WithContainer_ActionStep_ReturnsContainerStepHost()
+        {
+            using (var hc = CreateTestContext())
+            {
+                hc.EnqueueInstance<IContainerStepHost>(new ContainerStepHost());
+                var container = new ContainerInfo { ContainerId = "abc123" };
+                var context = CreateMockContext(container: container);
+                var result = _executor.CreateStepHost(context.Object, isActionStep: true);
+
+                Assert.IsType<ContainerStepHost>(result);
+                var containerHost = (ContainerStepHost)result;
+                Assert.Same(container, containerHost.Container);
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void CreateStepHost_WithContainer_InfrastructureStep_ReturnsDefaultStepHost()
+        {
+            using (var hc = CreateTestContext())
+            {
+                hc.EnqueueInstance<IDefaultStepHost>(new DefaultStepHost());
+                var container = new ContainerInfo { ContainerId = "abc123" };
+                var context = CreateMockContext(container: container);
+                var result = _executor.CreateStepHost(context.Object, isActionStep: false);
+
+                Assert.IsType<DefaultStepHost>(result);
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void CreateStepHost_ContainerWithoutId_NoHooks_ReturnsDefaultStepHost()
+        {
+            using (var hc = CreateTestContext())
+            {
+                hc.EnqueueInstance<IDefaultStepHost>(new DefaultStepHost());
+                // Container exists but hasn't been started yet (no ContainerId)
+                var container = new ContainerInfo();
+                var context = CreateMockContext(container: container);
+                var result = _executor.CreateStepHost(context.Object, isActionStep: true);
+
+                Assert.IsType<DefaultStepHost>(result);
+            }
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void CreateStepHost_ContainerWithoutId_HooksEnabled_ReturnsContainerStepHost()
+        {
+            using (var hc = CreateTestContext())
+            {
+                hc.EnqueueInstance<IContainerStepHost>(new ContainerStepHost());
+                // Container hooks need both the feature flag and the env var
+                Environment.SetEnvironmentVariable("ACTIONS_RUNNER_CONTAINER_HOOKS", "/some/hook/path");
+                try
+                {
+                    var container = new ContainerInfo();
+                    var context = CreateMockContext(container: container);
+                    context.Object.Global.Variables = new Variables(
+                        hc,
+                        new Dictionary<string, VariableValue>
+                        {
+                            { Constants.Runner.Features.AllowRunnerContainerHooks, new VariableValue("true") }
+                        });
+                    var result = _executor.CreateStepHost(context.Object, isActionStep: true);
+                    Assert.IsAssignableFrom<IContainerStepHost>(result);
+                }
+                finally
+                {
+                    Environment.SetEnvironmentVariable("ACTIONS_RUNNER_CONTAINER_HOOKS", null);
+                }
+            }
+        }
     }
 }

src/Test/L0/Worker/JobExecutionViewL0.cs

@@ -426,42 +426,17 @@ namespace GitHub.Runner.Common.Tests.Worker
         [Fact]
         [Trait("Level", "L0")]
         [Trait("Category", "Worker")]
-        public void TryMarkSkipped_MarksUnclaimedPlaceholder()
+        public void Append_RejectsBothStepIdentityAndMatchKey()
         {
+            // Allowing both would orphan the IStep→line mapping the moment
+            // TryClaim overwrites _stepIdentities[index] for a different
+            // step, so the API rejects the combination at append time.
             var view = new JobExecutionView("j");
-            var postEntry = new JobExecutionViewEntry(JobExecutionPhase.Post, "Post X", uses: "actions/x@v1");
-            view.Append(postEntry, stepIdentity: null, matchKey: "k1");
-
-            Assert.True(view.TryMarkSkipped("k1"));
-            Assert.True(postEntry.IsSkipped);
-            Assert.Contains("(skipped — main step did not execute)", view.Yaml);
-        }
-
-        [Fact]
-        [Trait("Level", "L0")]
-        [Trait("Category", "Worker")]
-        public void TryMarkSkipped_ReturnsFalseForUnknownKey()
-        {
-            var view = new JobExecutionView("j");
-            Assert.False(view.TryMarkSkipped("nope"));
-            Assert.DoesNotContain("(skipped", view.Yaml);
-        }
-
-        [Fact]
-        [Trait("Level", "L0")]
-        [Trait("Category", "Worker")]
-        public void TryMarkSkipped_ReturnsFalseForClaimedPlaceholder()
-        {
-            var view = new JobExecutionView("j");
-            var postEntry = new JobExecutionViewEntry(JobExecutionPhase.Post, "Post X", uses: "actions/x@v1");
-            view.Append(postEntry, stepIdentity: null, matchKey: "k1");
-
-            var step = NewStep("real-post");
-            Assert.NotNull(view.TryClaim("k1", step));
-
-            // Already claimed — must not mark as skipped.
-            Assert.False(view.TryMarkSkipped("k1"));
-            Assert.False(postEntry.IsSkipped);
+            var entry = new JobExecutionViewEntry(JobExecutionPhase.Post, "Post X", uses: "actions/x@v1");
+            Assert.Throws<ArgumentException>(() =>
+                view.Append(entry, stepIdentity: NewStep("real"), matchKey: "k1"));
+            // State unchanged.
+            Assert.Equal(0, view.EntryCount);
         }
     }
 }

src/Test/L0/Worker/JobExecutionViewLifecycleL0.cs

@@ -656,48 +656,5 @@ namespace GitHub.Runner.Common.Tests.Worker
                 }
             }
         }
-
-        [Fact]
-        [Trait("Level", "L0")]
-        [Trait("Category", "Worker")]
-        public async Task OnStepCompleted_SkippedMainStep_MarksPostPlaceholder()
-        {
-            using (var hc = CreateTestContext())
-            {
-                hc.SetSingleton<IActionManager>(NewActionManagerWithPost("actions/has-post").Object);
-
-                var port = GetFreePort();
-                using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
-                var jobContext = CreateJobContextWithTunnel(cts.Token, port);
-                await _debugger.StartAsync(jobContext.Object);
-                try
-                {
-                    await DriveToReadyAsync(_debugger, port);
-
-                    var actionId = Guid.NewGuid();
-                    var mainMock = NewActionRunner(ActionRunStage.Main, "Run actions/has-post@v1", "actions/has-post", "v1", actionId: actionId);
-                    var execCtx = new Mock<IExecutionContext>();
-                    execCtx.SetupGet(x => x.Result).Returns(TaskResult.Skipped);
-                    mainMock.SetupGet(x => x.ExecutionContext).Returns(execCtx.Object);
-
-                    await _debugger.OnJobStepsInitializedAsync(new[] { mainMock.Object }, Array.Empty<IStep>());
-
-                    var view = _debugger.ExecutionView;
-                    Assert.Equal(2, view.EntryCount); // main + predicted post placeholder
-                    Assert.DoesNotContain("(skipped", view.Yaml);
-
-                    _debugger.OnStepCompleted(mainMock.Object);
-
-                    Assert.Equal(2, _debugger.ExecutionView.EntryCount);
-                    Assert.Contains("(skipped — main step did not execute)", _debugger.ExecutionView.Yaml);
-                    // Inline annotation must not have introduced a new line.
-                    Assert.Equal(view.Yaml.Split('\n').Length, _debugger.ExecutionView.Yaml.Split('\n').Length);
-                }
-                finally
-                {
-                    await _debugger.StopAsync();
-                }
-            }
-        }
     }
 }

src/Test/L0/Worker/JobExecutionViewRendererL0.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using GitHub.Runner.Worker.Dap;
 using Xunit;
 
@@ -518,6 +517,36 @@ namespace GitHub.Runner.Common.Tests.Worker
             Assert.Contains("  - step: Complete job\n", result.Yaml);
         }
 
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void Render_ReportsCompleteJobLineMatchingYaml()
+        {
+            // Empty entries — Cleanup still emitted.
+            var emptyResult = JobExecutionViewRenderer.Render("j", new List<JobExecutionViewEntry>());
+            AssertCompleteJobLineMatchesYaml(emptyResult);
+
+            // Non-empty entries across phases.
+            var populatedResult = JobExecutionViewRenderer.Render("build", WorkedExampleEntries());
+            AssertCompleteJobLineMatchesYaml(populatedResult);
+        }
+
+        private static void AssertCompleteJobLineMatchesYaml(RenderResult result)
+        {
+            var lines = result.Yaml.Split('\n');
+            int? actual = null;
+            for (int i = 0; i < lines.Length; i++)
+            {
+                if (lines[i] == "  - step: Complete job")
+                {
+                    actual = i + 1;
+                    break;
+                }
+            }
+            Assert.NotNull(actual);
+            Assert.Equal(actual.Value, result.CompleteJobLine);
+        }
+
         [Fact]
         [Trait("Level", "L0")]
         [Trait("Category", "Worker")]
@@ -585,33 +614,15 @@ namespace GitHub.Runner.Common.Tests.Worker
         [Fact]
         [Trait("Level", "L0")]
         [Trait("Category", "Worker")]
-        public void Render_EmitsSkippedAnnotationForMarkedEntry()
+        public void Render_AlwaysUsesLfLineBreaks()
         {
-            var entry = new JobExecutionViewEntry(JobExecutionPhase.Post, "Post X", uses: "actions/x@v1");
-            entry.IsSkipped = true;
-
-            var result = JobExecutionViewRenderer.Render("j", new[] { entry });
-
-            // Annotation is inline on the `- step:` line so subsequent
-            // entry line numbers stay stable.
-            Assert.Contains("- step: Post X  # (skipped — main step did not execute)\n", result.Yaml);
-        }
-
-        [Fact]
-        [Trait("Level", "L0")]
-        [Trait("Category", "Worker")]
-        public void Render_SkippedAnnotation_DoesNotShiftSubsequentLines()
-        {
-            var skipped = new JobExecutionViewEntry(JobExecutionPhase.Post, "Post A", uses: "actions/a@v1");
-            var following = new JobExecutionViewEntry(JobExecutionPhase.Post, "Post B", uses: "actions/b@v1");
-
-            var unmarked = JobExecutionViewRenderer.Render("j", new[] { skipped, following });
-            skipped.IsSkipped = true;
-            var marked = JobExecutionViewRenderer.Render("j", new[] { skipped, following });
-
-            // Following entry's start line must not move when the prior
-            // entry gets an inline skipped annotation.
-            Assert.Equal(unmarked.EntryStartLines[1], marked.EntryStartLines[1]);
+            // Regression: YamlDotNet's Emitter calls WriteLine, which on
+            // Windows produces CRLF (the host's Environment.NewLine).
+            // The renderer's hand-emitted skeleton always uses '\n'; this
+            // test asserts the scalar formatter doesn't sneak CRLF in.
+            var entry = new JobExecutionViewEntry(JobExecutionPhase.Main, "with: colon", id: "step-1", uses: "actions/checkout@v4");
+            var result = JobExecutionViewRenderer.Render("job-1", new[] { entry });
+            Assert.DoesNotContain("\r", result.Yaml);
         }
     }
 }

src/Test/L0/Worker/StepEntryTranslatorL0.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using GitHub.DistributedTask.ObjectTemplating.Tokens;
 using GitHub.DistributedTask.Pipelines;
 using GitHub.Runner.Worker;
@@ -244,13 +243,17 @@ namespace GitHub.Runner.Common.Tests.Worker
         [Trait("Category", "Worker")]
         public void Translate_RunStep_ExtractsShellAndWorkingDirectory()
         {
+            // The runner stores run-step inputs under the keys defined in
+            // PipelineConstants.ScriptStepInputs (camelCase), NOT their
+            // kebab-case workflow-YAML spellings — see
+            // ActionManifestManagerWrapper:244.
             var action = new ActionStep
             {
                 Reference = new ScriptReference(),
                 Inputs = Map(
-                    ("script", Str("npm test")),
-                    ("shell", Str("bash")),
-                    ("working-directory", Str("./api"))),
+                    (PipelineConstants.ScriptStepInputs.Script, Str("npm test")),
+                    (PipelineConstants.ScriptStepInputs.Shell, Str("bash")),
+                    (PipelineConstants.ScriptStepInputs.WorkingDirectory, Str("./api"))),
             };
             var mock = NewActionRunnerMock(ActionRunStage.Main, "Run", new ScriptReference(), action);
 
@@ -276,9 +279,9 @@ namespace GitHub.Runner.Common.Tests.Worker
                 Reference = reference,
                 Inputs = Map(
                     ("mode", Str("ci")),
-                    ("script", Str("leak")),
-                    ("shell", Str("leak")),
-                    ("working-directory", Str("leak"))),
+                    (PipelineConstants.ScriptStepInputs.Script, Str("leak")),
+                    (PipelineConstants.ScriptStepInputs.Shell, Str("leak")),
+                    (PipelineConstants.ScriptStepInputs.WorkingDirectory, Str("leak"))),
             };
             var mock = NewActionRunnerMock(ActionRunStage.Main, "Run", reference, action);
 
@@ -288,9 +291,9 @@ namespace GitHub.Runner.Common.Tests.Worker
             Assert.NotNull(entry.WithYaml);
             Assert.Contains("mode: ci", entry.WithYaml);
             Assert.DoesNotContain("leak", entry.WithYaml);
-            Assert.DoesNotContain("script", entry.WithYaml);
-            Assert.DoesNotContain("shell", entry.WithYaml);
-            Assert.DoesNotContain("working-directory", entry.WithYaml);
+            Assert.DoesNotContain(PipelineConstants.ScriptStepInputs.Script, entry.WithYaml);
+            Assert.DoesNotContain(PipelineConstants.ScriptStepInputs.Shell, entry.WithYaml);
+            Assert.DoesNotContain(PipelineConstants.ScriptStepInputs.WorkingDirectory, entry.WithYaml);
         }
 
         [Fact]

src/Test/L0/Worker/TemplateTokenYamlAdapterL0.cs

@@ -60,14 +60,33 @@ namespace GitHub.Runner.Common.Tests.Worker
         [Trait("Category", "Worker")]
         public void Serialize_PreservesCompositeExpressionInStringToken()
         {
-            // Composite strings like `${{ runner.os }}-primes` are parsed
-            // as a StringToken whose value is exactly that literal. The
-            // adapter must round-trip the literal unchanged.
+            // A StringToken constructed directly with the literal text
+            // round-trips unchanged. (The workflow parser does NOT produce
+            // a StringToken for this input — see
+            // Serialize_ReversesFormatRewriteForCompositeExpression — but
+            // direct StringToken construction must still preserve the
+            // literal verbatim.)
             var token = Str("${{ runner.os }}-primes");
             string yaml = TemplateTokenYamlAdapter.Serialize(token, 0);
             Assert.Contains("${{ runner.os }}-primes", yaml);
         }
 
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void Serialize_ReversesFormatRewriteForCompositeExpression()
+        {
+            // The workflow parser tokenizes a mixed scalar like
+            // `${{ runner.os }}-primes` as a single BasicExpressionToken
+            // whose internal expression is `format('{0}-primes', runner.os)`.
+            // The adapter must surface the author-facing form, not the
+            // parser's normalized rewrite.
+            var token = Expr("format('{0}-primes', runner.os)");
+            string yaml = TemplateTokenYamlAdapter.Serialize(token, 0);
+            Assert.Contains("${{ runner.os }}-primes", yaml);
+            Assert.DoesNotContain("format(", yaml);
+        }
+
         [Fact]
         [Trait("Level", "L0")]
         [Trait("Category", "Worker")]
@@ -151,5 +170,22 @@ namespace GitHub.Runner.Common.Tests.Worker
             string yaml = TemplateTokenYamlAdapter.Serialize(token, 0);
             Assert.False(yaml.EndsWith("\n"));
         }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void Serialize_AlwaysUsesLfLineBreaks()
+        {
+            // Regression: YamlDotNet's Emitter calls WriteLine, which on
+            // Windows produces CRLF (the host's Environment.NewLine).
+            // Serialize must force LF so the rendered view round-trips
+            // regardless of platform.
+            var map = new MappingToken(null, null, null);
+            map.Add(Str("k1"), Str("v1"));
+            map.Add(Str("k2"), Num(2));
+            map.Add(Str("k3"), Bool(true));
+            string yaml = TemplateTokenYamlAdapter.Serialize(map, indentSpaces: 2);
+            Assert.DoesNotContain("\r", yaml);
+        }
     }
 }

src/Test/L0/Worker/YamlScalarFormatterL0.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Collections.Generic;
+using GitHub.Runner.Worker.Dap;
+using Xunit;
+using YamlDotNet.Serialization;
+
+namespace GitHub.Runner.Common.Tests.Worker
+{
+    public sealed class YamlScalarFormatterL0
+    {
+        private static readonly IDeserializer Deserializer = new DeserializerBuilder().Build();
+
+        // Embed the formatter output inside a minimal YAML mapping and
+        // round-trip through YamlDotNet, asserting the parsed value equals
+        // the original input. Decouples assertions from the emitter's
+        // quoting choices (plain vs single- vs double-quoted).
+        private static void AssertRoundTrips(string value)
+        {
+            string scalar = YamlScalarFormatter.Format(value);
+            string yaml = $"k: {scalar}\n";
+
+            Dictionary<string, object> doc;
+            try
+            {
+                doc = Deserializer.Deserialize<Dictionary<string, object>>(yaml);
+            }
+            catch (Exception ex)
+            {
+                throw new Xunit.Sdk.XunitException(
+                    $"Formatted scalar did not round-trip as valid YAML.\nInput: '{value}'\nFormatted: '{scalar}'\nFull YAML:\n{yaml}\nError: {ex}");
+            }
+            Assert.NotNull(doc);
+            Assert.True(doc.ContainsKey("k"), $"missing key in parsed doc. Formatted: '{scalar}'");
+            Assert.Equal(value, doc["k"] as string);
+        }
+
+        [Theory]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        [InlineData("hello")]
+        [InlineData("with: colon")]
+        [InlineData("with#hash")]
+        [InlineData(" leading")]
+        [InlineData("trailing ")]
+        [InlineData("a\"b")]
+        [InlineData("a\\b")]
+        [InlineData("@at")]
+        [InlineData("*star")]
+        [InlineData("&amp")]
+        [InlineData("?question")]
+        [InlineData("!exclaim")]
+        [InlineData("- dash")]
+        [InlineData("{brace}")]
+        [InlineData("[bracket]")]
+        public void Format_RoundTripsThroughYamlDeserializer(string value)
+        {
+            // The formatter must produce output that, embedded under a key,
+            // parses back to exactly the input. The emitter is free to
+            // pick plain, single-quoted, or double-quoted style.
+            AssertRoundTrips(value);
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void Format_PlainAscii_NoQuotingNeeded()
+        {
+            // Sanity check that the simple case stays plain.
+            Assert.Equal("hello", YamlScalarFormatter.Format("hello"));
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void Format_NoTrailingNewline()
+        {
+            Assert.False(YamlScalarFormatter.Format("hello").EndsWith("\n"));
+            Assert.False(YamlScalarFormatter.Format("with: colon").EndsWith("\n"));
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void Format_NoDocumentMarkers()
+        {
+            // The emitter wraps the scalar in a document; the formatter
+            // must strip both `--- ` (with space) and `---\n` (on its
+            // own line) prefixes plus the `\n...` suffix.
+            Assert.DoesNotContain("---", YamlScalarFormatter.Format("hello"));
+            Assert.DoesNotContain("...", YamlScalarFormatter.Format("hello"));
+            // Empty string is one of the cases where the emitter does
+            // produce a document marker by default.
+            Assert.DoesNotContain("---", YamlScalarFormatter.Format(""));
+            Assert.DoesNotContain("...", YamlScalarFormatter.Format(""));
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void Format_AlwaysUsesLfLineBreaks()
+        {
+            // Regression: YamlDotNet's Emitter calls WriteLine, which on
+            // Windows produces CRLF (the host's Environment.NewLine).
+            // Format must force LF so the output round-trips regardless
+            // of platform.
+            Assert.DoesNotContain('\r', YamlScalarFormatter.Format("hello"));
+            Assert.DoesNotContain('\r', YamlScalarFormatter.Format("with: colon"));
+            Assert.DoesNotContain('\r', YamlScalarFormatter.Format(""));
+        }
+
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public void Format_NullValue_Throws()
+        {
+            Assert.Throws<ArgumentNullException>(() => YamlScalarFormatter.Format(null));
+        }
+    }
+}

src/dev.sh

@@ -17,7 +17,7 @@ LAYOUT_DIR="$SCRIPT_DIR/../_layout"
 DOWNLOAD_DIR="$SCRIPT_DIR/../_downloads/netcore2x"
 PACKAGE_DIR="$SCRIPT_DIR/../_package"
 DOTNETSDK_ROOT="$SCRIPT_DIR/../_dotnetsdk"
-DOTNETSDK_VERSION="8.0.420"
+DOTNETSDK_VERSION="8.0.421"
 DOTNETSDK_INSTALLDIR="$DOTNETSDK_ROOT/$DOTNETSDK_VERSION"
 RUNNER_VERSION=$(cat runnerversion)
 

src/global.json

@@ -1,5 +1,5 @@
 {
   "sdk": {
-    "version": "8.0.420"
+    "version": "8.0.421"
   }
 }