Hook job lifecycle into DAP debugger behind containment gate

Wires three runner-internal call sites into the DAP debugger:
  - JobRunner: notifies the debugger once Pre/Main/Post step lists
    are populated, so it can seed the execution view and predict
    Post placeholders.
  - ExecutionContext.RegisterPostJobStep: notifies the debugger when
    a post step is registered, so it can claim the predicted
    placeholder or append a new entry.
  - StepsRunner: notifies the debugger when a Main step is skipped
    by its if: condition, so predicted Post placeholders for that
    step can be marked as skipped.

Each call site gates on jobContext.Global.Debugger?.Enabled == true
before calling HostContext.GetService<IDapDebugger>(). Without the
gate, GetService<T>() auto-instantiates the default singleton for
every non-debug job, breaking the 'no debugger, no risk' containment
property.

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.421"
+      "version": "8.0.420"
     },
     "ghcr.io/devcontainers/features/node:1": {
       "version": "20"

.gitignore

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

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-ust1t64, liblttng-ust1 or liblttng-ust0
+- liblttng-ust1 or liblttng-ust0
 - libkrb5-3
 - zlib1g
 - libssl3t64, libssl3, libssl1.1, libssl1.0.2 or libssl1.0.0
-- libicu80, libicu79, ..., libicu66, libicu65, libicu63, libicu60, libicu57, libicu55, or libicu52
+- libicu76, libicu75, ..., 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.5.0
-ARG BUILDX_VERSION=0.34.0
+ARG DOCKER_VERSION=29.4.0
+ARG BUILDX_VERSION=0.33.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.16.0"
+NODE24_VERSION="24.15.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-ust1t64 liblttng-ust1 liblttng-ust0
+        apt_get_with_fallbacks 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 libicu80 libicu79 libicu78 libicu77 libicu76 libicu75 libicu74 libicu73 libicu72 libicu71 libicu70 libicu69 libicu68 libicu67 libicu66 libicu65 libicu63 libicu60 libicu57 libicu55 libicu52
+        apt_get_with_fallbacks 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,7 +179,6 @@ 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,7 +58,6 @@ 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;
@@ -89,11 +88,6 @@ 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;
 
@@ -249,10 +243,6 @@ 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.");
 
@@ -405,6 +395,7 @@ namespace GitHub.Runner.Worker.Dap
             try
             {
                 Trace.Info("Step completed");
+                JobExecutionView view;
                 lock (_stateLock)
                 {
                     if (_state != DapSessionState.Ready &&
@@ -420,6 +411,23 @@ 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)
@@ -810,11 +818,6 @@ namespace GitHub.Runner.Worker.Dap
                     });
                     Trace.Info("Sent initialized event");
                 }
-
-                if (request.Command == "configurationDone")
-                {
-                    SendWelcomeMessage();
-                }
             }
             catch (Exception ex)
             {
@@ -833,7 +836,6 @@ 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
@@ -1144,34 +1146,6 @@ 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;
@@ -1210,9 +1184,6 @@ 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);
         }
@@ -1389,12 +1360,10 @@ namespace GitHub.Runner.Worker.Dap
         {
             IStep currentStep;
             JobExecutionView view;
-            bool jobCompleted;
             lock (_stateLock)
             {
                 currentStep = _currentStep;
                 view = _executionView;
-                jobCompleted = _jobCompleted;
             }
 
             var frames = new List<StackFrame>();
@@ -1403,23 +1372,9 @@ namespace GitHub.Runner.Worker.Dap
             {
                 var source = BuildExecutionViewSource(view.JobId);
 
-                if (jobCompleted)
+                // Frame 0: the currently-executing step (only when one is set).
+                if (currentStep != null)
                 {
-                    // 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
                     {
@@ -1670,12 +1625,7 @@ namespace GitHub.Runner.Worker.Dap
 
                 case RunCommand run:
                     var context = GetExecutionContextForFrame(frameId);
-                    bool isActionStep;
-                    lock (_stateLock)
-                    {
-                        isActionStep = _currentStep is IActionRunner;
-                    }
-                    return await _replExecutor.ExecuteRunCommandAsync(run, context, isActionStep, cancellationToken);
+                    return await _replExecutor.ExecuteRunCommandAsync(run, context, cancellationToken);
 
                 default:
                     return new EvaluateResponseBody
@@ -1915,40 +1865,6 @@ 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,7 +9,6 @@ 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
@@ -44,7 +43,6 @@ namespace GitHub.Runner.Worker.Dap
         public async Task<EvaluateResponseBody> ExecuteRunCommandAsync(
             RunCommand command,
             IExecutionContext context,
-            bool isActionStep,
             CancellationToken cancellationToken)
         {
             if (context == null)
@@ -54,7 +52,7 @@ namespace GitHub.Runner.Worker.Dap
 
             try
             {
-                return await ExecuteScriptAsync(command, context, isActionStep, cancellationToken);
+                return await ExecuteScriptAsync(command, context, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -67,17 +65,9 @@ namespace GitHub.Runner.Worker.Dap
         private async Task<EvaluateResponseBody> ExecuteScriptAsync(
             RunCommand command,
             IExecutionContext context,
-            bool isActionStep,
             CancellationToken cancellationToken)
         {
-            // 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
+            // 1. Resolve shell — same logic as ScriptHandler
             string shellCommand;
             string argFormat;
 
@@ -97,9 +87,9 @@ namespace GitHub.Runner.Worker.Dap
                 argFormat = ScriptHandlerHelpers.GetScriptArgumentsFormat(shellCommand);
             }
 
-            _trace.Info($"Resolved REPL shell (container={isContainerStepHost})");
+            _trace.Info("Resolved REPL shell");
 
-            // 3. Expand ${{ }} expressions in the script body, just like
+            // 2. 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);
@@ -121,47 +111,25 @@ namespace GitHub.Runner.Worker.Dap
 
             try
             {
-                // 4. Resolve script path — translate for container if needed
-                var resolvedPath = stepHost.ResolvePathForStepHost(context, scriptFilePath).Replace("\"", "\\\"");
+                // 3. Format arguments with script path
+                var resolvedPath = 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);
 
-                // 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.
+                // 4. Resolve shell command path
                 string prependPath = string.Join(
                     Path.PathSeparator.ToString(),
                     Enumerable.Reverse(context.Global.PrependPath));
-                var fileName = isContainerStepHost
-                    ? shellCommand
-                    : WhichUtil.Which(shellCommand, false, _trace, prependPath) ?? shellCommand;
+                var commandPath = WhichUtil.Which(shellCommand, false, _trace, prependPath)
+                    ?? shellCommand;
 
-                // 6. Build environment — merge from execution context like a real step
+                // 5. Build environment — merge from execution context like a real step
                 var environment = BuildEnvironment(context, command.Env);
 
-                // 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
+                // 6. Resolve working directory
                 var workingDirectory = command.WorkingDirectory;
                 if (string.IsNullOrEmpty(workingDirectory))
                 {
@@ -173,60 +141,48 @@ 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");
 
-                // 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))
+                // 7. Execute via IProcessInvoker (same as DefaultStepHost)
+                int exitCode;
+                using (var processInvoker = _hostContext.CreateService<IProcessInvoker>())
                 {
-                    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");
+                    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);
                 }
 
-                // 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}");
 
-                // 10. Return only the exit code summary (output was already streamed)
+                // 8. 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}.",
@@ -242,43 +198,6 @@ 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,12 +8,10 @@ namespace GitHub.Runner.Worker.Dap
     /// </summary>
     public sealed class DebuggerConfig
     {
-        public DebuggerConfig(bool enabled, DebuggerTunnelInfo tunnel, bool overrideWelcomeMessage = false, string welcomeMessage = null)
+        public DebuggerConfig(bool enabled, DebuggerTunnelInfo tunnel)
         {
             Enabled = enabled;
             Tunnel = tunnel;
-            OverrideWelcomeMessage = overrideWelcomeMessage;
-            WelcomeMessage = welcomeMessage;
         }
 
         /// <summary>Whether the debugger is enabled for this job.</summary>
@@ -25,19 +23,6 @@ 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,21 +10,9 @@ 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.
     ///
-    /// 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.
+    /// 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.
     /// </summary>
     internal sealed class JobExecutionView
     {
@@ -40,7 +28,6 @@ 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)
         {
@@ -73,21 +60,6 @@ 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
         {
@@ -141,25 +113,20 @@ namespace GitHub.Runner.Worker.Dap
         }
 
         /// <summary>
-        /// 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.
+        /// 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.
         /// </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)
         {
-            ArgUtil.NotNull(entry, nameof(entry));
-            if (stepIdentity != null && matchKey != null)
+            if (entry == null)
             {
-                throw new ArgumentException(
-                    "Append cannot register both a step identity and a placeholder match key on the same entry; pass at most one.");
+                throw new ArgumentNullException(nameof(entry));
             }
 
             lock (_lock)
@@ -226,6 +193,46 @@ 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.
@@ -277,7 +284,6 @@ 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,8 +1,11 @@
 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
 {
@@ -85,6 +88,15 @@ 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>
@@ -95,21 +107,14 @@ namespace GitHub.Runner.Worker.Dap
     /// </summary>
     internal readonly struct RenderResult
     {
-        public RenderResult(string yaml, IReadOnlyList<int> entryStartLines, int completeJobLine)
+        public RenderResult(string yaml, IReadOnlyList<int> entryStartLines)
         {
             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>
@@ -148,7 +153,7 @@ namespace GitHub.Runner.Worker.Dap
             int newlinesEmitted = 0;
 
             // Header (3 lines).
-            sb.Append("# Job: ").Append(YamlScalarFormatter.Format(jobId)).Append('\n');
+            sb.Append("# Job: ").Append(FormatScalar(jobId)).Append('\n');
             sb.Append("# Runner execution plan — read-only.\n");
             sb.Append('\n');
             newlinesEmitted += 3;
@@ -167,11 +172,9 @@ 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), completeJobLine);
+            return new RenderResult(sb.ToString(), Array.AsReadOnly(startLines));
         }
 
         private static void EmitPhaseSection(
@@ -209,7 +212,12 @@ namespace GitHub.Runner.Worker.Dap
                 // 1-based line of the `- step:` key for this entry.
                 startLines[i] = newlinesEmitted + 1;
 
-                sb.Append("  - step: ").Append(YamlScalarFormatter.Format(entry.DisplayName));
+                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('\n');
                 newlinesEmitted++;
 
@@ -219,7 +227,7 @@ namespace GitHub.Runner.Worker.Dap
                     case JobExecutionPhase.Post:
                         if (!string.IsNullOrEmpty(entry.Uses))
                         {
-                            sb.Append("    action: ").Append(YamlScalarFormatter.Format(entry.Uses)).Append('\n');
+                            sb.Append("    action: ").Append(FormatScalar(entry.Uses)).Append('\n');
                             newlinesEmitted++;
                         }
                         // No source: annotation for pre/post.
@@ -228,19 +236,19 @@ namespace GitHub.Runner.Worker.Dap
                     case JobExecutionPhase.Main:
                         if (!string.IsNullOrEmpty(entry.Id))
                         {
-                            sb.Append("    id: ").Append(YamlScalarFormatter.Format(entry.Id)).Append('\n');
+                            sb.Append("    id: ").Append(FormatScalar(entry.Id)).Append('\n');
                             newlinesEmitted++;
                         }
                         if (!string.IsNullOrEmpty(entry.Uses))
                         {
-                            sb.Append("    uses: ").Append(YamlScalarFormatter.Format(entry.Uses)).Append('\n');
+                            sb.Append("    uses: ").Append(FormatScalar(entry.Uses)).Append('\n');
                             newlinesEmitted++;
                         }
                         if (!string.IsNullOrEmpty(entry.Run))
                         {
                             if (entry.Run.IndexOf('\n') < 0)
                             {
-                                sb.Append("    run: ").Append(YamlScalarFormatter.Format(entry.Run)).Append('\n');
+                                sb.Append("    run: ").Append(FormatScalar(entry.Run)).Append('\n');
                                 newlinesEmitted++;
                             }
                             else
@@ -252,7 +260,7 @@ namespace GitHub.Runner.Worker.Dap
                         }
                         if (!string.IsNullOrEmpty(entry.If))
                         {
-                            sb.Append("    if: ").Append(YamlScalarFormatter.Format(entry.If)).Append('\n');
+                            sb.Append("    if: ").Append(FormatScalar(entry.If)).Append('\n');
                             newlinesEmitted++;
                         }
                         if (!string.IsNullOrEmpty(entry.ContinueOnError))
@@ -281,12 +289,12 @@ namespace GitHub.Runner.Worker.Dap
                         }
                         if (!string.IsNullOrEmpty(entry.Shell))
                         {
-                            sb.Append("    shell: ").Append(YamlScalarFormatter.Format(entry.Shell)).Append('\n');
+                            sb.Append("    shell: ").Append(FormatScalar(entry.Shell)).Append('\n');
                             newlinesEmitted++;
                         }
                         if (!string.IsNullOrEmpty(entry.WorkingDirectory))
                         {
-                            sb.Append("    working-directory: ").Append(YamlScalarFormatter.Format(entry.WorkingDirectory)).Append('\n');
+                            sb.Append("    working-directory: ").Append(FormatScalar(entry.WorkingDirectory)).Append('\n');
                             newlinesEmitted++;
                         }
                         if (entry.SourcePath != null)
@@ -341,5 +349,43 @@ 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,14 +16,12 @@ namespace GitHub.Runner.Worker.Dap
     internal static class StepEntryTranslator
     {
         // Run-step internals carried on ActionStep.Inputs that are NOT
-        // user-authored `with:` entries. The runner stores these under
-        // the keys defined in PipelineConstants.ScriptStepInputs, NOT
-        // their kebab-case workflow-YAML spellings.
+        // user-authored `with:` entries.
         private static readonly HashSet<string> RunStepInternalKeys = new(StringComparer.Ordinal)
         {
-            PipelineConstants.ScriptStepInputs.Script,
-            PipelineConstants.ScriptStepInputs.Shell,
-            PipelineConstants.ScriptStepInputs.WorkingDirectory,
+            "script",
+            "shell",
+            "working-directory",
         };
 
         /// <summary>
@@ -118,11 +116,11 @@ namespace GitHub.Runner.Worker.Dap
                     var inputs = action.Inputs as MappingToken;
                     if (inputs != null)
                     {
-                        if (TryGetMapValue(inputs, PipelineConstants.ScriptStepInputs.Script, out var scriptTok) && scriptTok != null)
+                        if (TryGetMapValue(inputs, "script", out var scriptTok) && scriptTok != null)
                         {
                             run = scriptTok.ToString();
                         }
-                        if (TryGetMapValue(inputs, PipelineConstants.ScriptStepInputs.Shell, out var shellTok) && shellTok != null)
+                        if (TryGetMapValue(inputs, "shell", out var shellTok) && shellTok != null)
                         {
                             string shellText = shellTok.ToString();
                             if (!string.IsNullOrEmpty(shellText))
@@ -130,7 +128,7 @@ namespace GitHub.Runner.Worker.Dap
                                 shell = shellText;
                             }
                         }
-                        if (TryGetMapValue(inputs, PipelineConstants.ScriptStepInputs.WorkingDirectory, out var wdTok) && wdTok != null)
+                        if (TryGetMapValue(inputs, "working-directory", out var wdTok) && wdTok != null)
                         {
                             string wdText = wdTok.ToString();
                             if (!string.IsNullOrEmpty(wdText))

src/Runner.Worker/Dap/TemplateTokenYamlAdapter.cs

@@ -95,32 +95,16 @@ 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);
-            adapter.WriteStart();
-            WriteToken(adapter, token);
-            adapter.WriteEnd();
+            TemplateWriter.Write(adapter, token);
 
             string raw = sw.ToString();
-            // 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.
+            // Strip YAML document markers ("--- " prefix and "\n..." suffix).
             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))
             {
@@ -160,64 +144,5 @@ 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

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

src/Runner.Worker/Handlers/NodeScriptActionHandler.cs

@@ -12,7 +12,6 @@ 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
 {
@@ -129,15 +128,6 @@ 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,12 +219,18 @@ 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,21 +267,6 @@ 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,16 +186,7 @@
         "vars",
         "needs",
         "strategy",
-        "matrix",
-        "steps",
-        "job",
-        "runner",
-        "env",
-        "always(0,0)",
-        "failure(0,0)",
-        "cancelled(0,0)",
-        "success(0,0)",
-        "hashFiles(1,255)"
+        "matrix"
       ],
       "string": {}
     },

src/Sdk/WorkflowParser/Conversion/WorkflowTemplateConverter.cs

@@ -2291,10 +2291,6 @@ 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[]
         {
@@ -2311,13 +2307,6 @@ 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 = 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),
-        };
+        private static readonly IFunctionInfo[] s_snapshotConditionFunctions = null;
     }
 }

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

@@ -2196,16 +2196,7 @@
         "vars",
         "needs",
         "strategy",
-        "matrix",
-        "steps",
-        "job",
-        "runner",
-        "env",
-        "always(0,0)",
-        "failure(0,0)",
-        "cancelled(0,0)",
-        "success(0,0)",
-        "hashFiles(1,255)"
+        "matrix"
       ],
       "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,26 +161,6 @@ 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, bool overrideWelcomeMessage = false, string welcomeMessage = null)
+        private static Mock<IExecutionContext> CreateJobContextWithTunnel(CancellationToken cancellationToken, ushort port, string jobName = 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, overrideWelcomeMessage, welcomeMessage);
+            var debuggerConfig = new DebuggerConfig(true, tunnel);
             var jobContext = new Mock<IExecutionContext>();
             jobContext.Setup(x => x.CancellationToken).Returns(cancellationToken);
             jobContext.Setup(x => x.Global).Returns(new GlobalContext { Debugger = debuggerConfig });
@@ -742,8 +742,6 @@ 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,
@@ -851,8 +849,6 @@ 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;
 
@@ -872,225 +868,6 @@ 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.
         // ---------------------------------------------------------------------
@@ -1562,7 +1339,6 @@ 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;
@@ -1596,8 +1372,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 ReadDapMessageAsync(stream, TimeSpan.FromSeconds(5));
                     await _debugger.WaitUntilReadyAsync();
 
                     var main = NewActionRunner(GitHub.Runner.Worker.ActionRunStage.Main, "Run").Object;

src/Test/L0/Worker/DapReplExecutorL0.cs

@@ -5,12 +5,9 @@ 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;
 
@@ -43,8 +40,7 @@ namespace GitHub.Runner.Common.Tests.Worker
 
         private Mock<IExecutionContext> CreateMockContext(
             DictionaryContextData exprValues = null,
-            IDictionary<string, IDictionary<string, string>> jobDefaults = null,
-            ContainerInfo container = null)
+            IDictionary<string, IDictionary<string, string>> jobDefaults = null)
         {
             var mock = new Mock<IExecutionContext>();
             mock.Setup(x => x.ExpressionValues).Returns(exprValues ?? new DictionaryContextData());
@@ -55,7 +51,6 @@ 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);
 
@@ -70,7 +65,7 @@ namespace GitHub.Runner.Common.Tests.Worker
             using (CreateTestContext())
             {
                 var command = new RunCommand { Script = "echo hello" };
-                var result = await _executor.ExecuteRunCommandAsync(command, null, false, CancellationToken.None);
+                var result = await _executor.ExecuteRunCommandAsync(command, null, CancellationToken.None);
 
                 Assert.Equal("error", result.Type);
                 Assert.Contains("No execution context available", result.Result);
@@ -238,101 +233,5 @@ 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,17 +426,42 @@ namespace GitHub.Runner.Common.Tests.Worker
         [Fact]
         [Trait("Level", "L0")]
         [Trait("Category", "Worker")]
-        public void Append_RejectsBothStepIdentityAndMatchKey()
+        public void TryMarkSkipped_MarksUnclaimedPlaceholder()
         {
-            // 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 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);
+            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);
         }
     }
 }

src/Test/L0/Worker/JobExecutionViewLifecycleL0.cs

@@ -656,5 +656,48 @@ 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,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using GitHub.Runner.Worker.Dap;
 using Xunit;
 
@@ -517,36 +518,6 @@ 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")]
@@ -614,15 +585,33 @@ namespace GitHub.Runner.Common.Tests.Worker
         [Fact]
         [Trait("Level", "L0")]
         [Trait("Category", "Worker")]
-        public void Render_AlwaysUsesLfLineBreaks()
+        public void Render_EmitsSkippedAnnotationForMarkedEntry()
         {
-            // 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);
+            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]);
         }
     }
 }

src/Test/L0/Worker/StepEntryTranslatorL0.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using GitHub.DistributedTask.ObjectTemplating.Tokens;
 using GitHub.DistributedTask.Pipelines;
 using GitHub.Runner.Worker;
@@ -243,17 +244,13 @@ 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(
-                    (PipelineConstants.ScriptStepInputs.Script, Str("npm test")),
-                    (PipelineConstants.ScriptStepInputs.Shell, Str("bash")),
-                    (PipelineConstants.ScriptStepInputs.WorkingDirectory, Str("./api"))),
+                    ("script", Str("npm test")),
+                    ("shell", Str("bash")),
+                    ("working-directory", Str("./api"))),
             };
             var mock = NewActionRunnerMock(ActionRunStage.Main, "Run", new ScriptReference(), action);
 
@@ -279,9 +276,9 @@ namespace GitHub.Runner.Common.Tests.Worker
                 Reference = reference,
                 Inputs = Map(
                     ("mode", Str("ci")),
-                    (PipelineConstants.ScriptStepInputs.Script, Str("leak")),
-                    (PipelineConstants.ScriptStepInputs.Shell, Str("leak")),
-                    (PipelineConstants.ScriptStepInputs.WorkingDirectory, Str("leak"))),
+                    ("script", Str("leak")),
+                    ("shell", Str("leak")),
+                    ("working-directory", Str("leak"))),
             };
             var mock = NewActionRunnerMock(ActionRunStage.Main, "Run", reference, action);
 
@@ -291,9 +288,9 @@ namespace GitHub.Runner.Common.Tests.Worker
             Assert.NotNull(entry.WithYaml);
             Assert.Contains("mode: ci", entry.WithYaml);
             Assert.DoesNotContain("leak", entry.WithYaml);
-            Assert.DoesNotContain(PipelineConstants.ScriptStepInputs.Script, entry.WithYaml);
-            Assert.DoesNotContain(PipelineConstants.ScriptStepInputs.Shell, entry.WithYaml);
-            Assert.DoesNotContain(PipelineConstants.ScriptStepInputs.WorkingDirectory, entry.WithYaml);
+            Assert.DoesNotContain("script", entry.WithYaml);
+            Assert.DoesNotContain("shell", entry.WithYaml);
+            Assert.DoesNotContain("working-directory", entry.WithYaml);
         }
 
         [Fact]

src/Test/L0/Worker/TemplateTokenYamlAdapterL0.cs

@@ -60,33 +60,14 @@ namespace GitHub.Runner.Common.Tests.Worker
         [Trait("Category", "Worker")]
         public void Serialize_PreservesCompositeExpressionInStringToken()
         {
-            // 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.)
+            // 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.
             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")]
@@ -170,22 +151,5 @@ 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

@@ -1,119 +0,0 @@
-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.421"
+DOTNETSDK_VERSION="8.0.420"
 DOTNETSDK_INSTALLDIR="$DOTNETSDK_ROOT/$DOTNETSDK_VERSION"
 RUNNER_VERSION=$(cat runnerversion)
 

src/global.json

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