From 1b268b6952fa370aba2cf91bb8f8d5697f845472 Mon Sep 17 00:00:00 2001
From: Karol Zadora-Przylecki <karolz@microsoft.com>
Date: Tue, 4 Aug 2026 10:52:57 -0700
Subject: [PATCH 01/13] Separate regular arguments from launch tool
 ("entrypoint") arguments

Fixes https://github.com/microsoft/aspire/issues/18929
---
 .../DotnetProjectHostingExtensions.cs         |   4 +-
 src/Aspire.Hosting.Go/GoHostingExtensions.cs  | 138 ++++++-------
 .../PythonAppResourceBuilderExtensions.cs     |  44 +---
 ...ArgumentsExecutionConfigurationGatherer.cs |  46 +++++
 .../DebugSupportExtensions.cs                 |  16 ++
 .../EntrypointArgsCallbackAnnotation.cs       |  98 +++++++++
 src/Aspire.Hosting/Dcp/DcpExecutor.cs         |   8 +
 src/Aspire.Hosting/Dcp/ExecutableCreator.cs   | 194 +++++++++++++-----
 .../ResourceBuilderExtensions.cs              |  86 +++++---
 .../SupportsDebuggingAnnotation.cs            |  31 +--
 .../DotnetProjectResourceTests.cs             |  17 +-
 .../Aspire.Hosting.Go.Tests/AddGoAppTests.cs  |  39 +++-
 .../AddPythonAppTests.cs                      |  30 ++-
 .../Dcp/DcpExecutorTests.cs                   | 128 ++++++++----
 ...ExecutableResourceBuilderExtensionTests.cs | 156 +++++++++++---
 15 files changed, 720 insertions(+), 315 deletions(-)
 create mode 100644 src/Aspire.Hosting/ApplicationModel/EntrypointArgsCallbackAnnotation.cs

diff --git a/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs b/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
index 412281a10bd..9db14a3de43 100644
--- a/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
+++ b/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
@@ -134,10 +134,10 @@ public static IResourceBuilder<DotnetProjectResource> AddDotnetProject(this IDis
         {
             // Mirrors the fallback rule in Dcp/ExecutableCreator: 
             // a Process fallback is offered for the plain executable UNLESS 
-            // the launch configuration is "project", OR the configuration rewrites the arguments for debugging. 
+            // the launch configuration is "project", OR the launch configuration owns the entrypoint arguments. 
             // For any other active annotation a fallback IS offered and we need to construct the args here.
             if (ctx.Resource.SupportsDebugging(builder.Configuration, out var debugAnnotation)
-                && (debugAnnotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project || debugAnnotation.RewritesArgumentsForDebugging))
+                && (debugAnnotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project || ctx.Resource.OwnsEntrypointArguments(debugAnnotation)))
             {
                 return;
             }
diff --git a/src/Aspire.Hosting.Go/GoHostingExtensions.cs b/src/Aspire.Hosting.Go/GoHostingExtensions.cs
index e1d298d7f1e..1429c85112d 100644
--- a/src/Aspire.Hosting.Go/GoHostingExtensions.cs
+++ b/src/Aspire.Hosting.Go/GoHostingExtensions.cs
@@ -95,60 +95,36 @@ public static IResourceBuilder<GoAppResource> AddGoApp(
                     ? argsAnnotation.Args
                     : [];
 
-                var hasDelve = ctx.Resource.TryGetLastAnnotation<GoDelveServerAnnotation>(out var delveAnnotation);
-                var pkg = ctx.Resource.TryGetLastAnnotation<GoPackagePathAnnotation>(out var pkgAnnotation)
-                    ? pkgAnnotation.PackagePath
-                    : ".";
-
-                if (hasDelve)
+                if (!ctx.Resource.TryGetLastAnnotation<GoDelveServerAnnotation>(out var delveAnnotation))
                 {
-                    // Delve debug mode — global flags MUST precede the subcommand per the Delve CLI:
-                    //   dlv --headless=true --listen=127.0.0.1:PORT --api-version=2 debug [--continue] [--build-flags=...] <pkg> [-- args]
-                    // See: https://www.jetbrains.com/help/go/attach-to-running-go-processes-with-debugger.html
-                    ctx.Args.Add("--headless=true");
-                    ctx.Args.Add($"--listen=127.0.0.1:{delveAnnotation!.Port}");
-                    ctx.Args.Add("--api-version=2");
-                    if (delveAnnotation.AcceptMultiClient)
-                    {
-                        ctx.Args.Add("--accept-multiclient");
-                    }
-                    if (delveAnnotation.OnlySameUser.HasValue)
-                    {
-                        ctx.Args.Add($"--only-same-user={delveAnnotation.OnlySameUser.Value.ToString().ToLowerInvariant()}");
-                    }
-                    if (delveAnnotation.Log)
-                    {
-                        ctx.Args.Add("--log");
-                        if (!string.IsNullOrEmpty(delveAnnotation.LogOutput))
-                        {
-                            ctx.Args.Add($"--log-output={delveAnnotation.LogOutput}");
-                        }
-                    }
-
-                    ctx.Args.Add("debug");
-                    if (delveAnnotation.ContinueOnStart)
+                    // Normal run mode. The `go run [build flags] <pkg>` prefix is contributed as entrypoint
+                    // arguments by WithVSCodeDebugging(), so only the program's own arguments belong here.
+                    foreach (var arg in programArgs)
                     {
-                        ctx.Args.Add("--continue");
+                        ctx.Args.Add(arg);
                     }
 
-                    var buildFlags = BuildFlagsString(ctx.Resource);
-                    if (buildFlags.Length > 0)
-                    {
-                        ctx.Args.Add($"--build-flags={buildFlags}");
-                    }
+                    return;
+                }
 
-                    ctx.Args.Add(pkg);
+                // Delve debug mode — global flags MUST precede the subcommand per the Delve CLI:
+                //   dlv --headless=true --listen=127.0.0.1:PORT --api-version=2 debug [--continue] [--build-flags=...] <pkg> [-- args]
+                // See: https://www.jetbrains.com/help/go/attach-to-running-go-processes-with-debugger.html
+                // WithDelveServer removes the debug launch annotation, so this whole command line is a plain
+                // process invocation and stays in the regular argument callback.
+                var pkg = ctx.Resource.TryGetLastAnnotation<GoPackagePathAnnotation>(out var pkgAnnotation)
+                    ? pkgAnnotation.PackagePath
+                    : ".";
 
-                    if (programArgs.Length > 0)
-                    {
-                        ctx.Args.Add("--");
-                        foreach (var arg in programArgs)
-                        {
-                            ctx.Args.Add(arg);
-                        }
-                    }
+                ctx.Args.Add("--headless=true");
+                ctx.Args.Add($"--listen=127.0.0.1:{delveAnnotation.Port}");
+                ctx.Args.Add("--api-version=2");
+                if (delveAnnotation.AcceptMultiClient)
+                {
+                    ctx.Args.Add("--accept-multiclient");
                 }
                 else
+                if (delveAnnotation.OnlySameUser.HasValue)
                 {
                     // Normal run mode: go run [-race] [-tags=...] [-ldflags=...] [-gcflags=...] <pkg> [args]
                     ctx.Args.Add("run");
@@ -159,22 +135,34 @@ public static IResourceBuilder<GoAppResource> AddGoApp(
                     }
 
                     if (ctx.Resource.TryGetLastAnnotation<GoBuildTagsAnnotation>(out var tagsAnnotation))
+                    ctx.Args.Add($"--only-same-user={delveAnnotation.OnlySameUser.Value.ToString().ToLowerInvariant()}");
+                }
+                if (delveAnnotation.Log)
+                {
+                    ctx.Args.Add("--log");
+                    if (!string.IsNullOrEmpty(delveAnnotation.LogOutput))
                     {
-                        ctx.Args.Add($"-tags={string.Join(",", tagsAnnotation.Tags)}");
+                        ctx.Args.Add($"--log-output={delveAnnotation.LogOutput}");
                     }
+                }
 
-                    if (ctx.Resource.TryGetLastAnnotation<GoLdFlagsAnnotation>(out var ldFlagsAnnotation))
-                    {
-                        ctx.Args.Add($"-ldflags={ldFlagsAnnotation.Flags}");
-                    }
+                ctx.Args.Add("debug");
+                if (delveAnnotation.ContinueOnStart)
+                {
+                    ctx.Args.Add("--continue");
+                }
 
-                    if (ctx.Resource.TryGetLastAnnotation<GoGcFlagsAnnotation>(out var gcFlagsAnnotation))
-                    {
-                        ctx.Args.Add($"-gcflags={gcFlagsAnnotation.Flags}");
-                    }
+                var delveBuildFlags = BuildFlagsString(ctx.Resource);
+                if (delveBuildFlags.Length > 0)
+                {
+                    ctx.Args.Add($"--build-flags={delveBuildFlags}");
+                }
 
-                    ctx.Args.Add(pkg);
+                ctx.Args.Add(pkg);
 
+                if (programArgs.Length > 0)
+                {
+                    ctx.Args.Add("--");
                     foreach (var arg in programArgs)
                     {
                         ctx.Args.Add(arg);
@@ -780,33 +768,43 @@ internal static IResourceBuilder<T> WithVSCodeDebugging<T>(this IResourceBuilder
             {
                 // The executable resource normally starts as:
                 //   go run [-race] [-tags=...] [-ldflags=...] [-gcflags=...] <pkg> [app args]
-                // In IDE mode VS Code's Go debugger owns the tool/build/package portion via
-                // program/buildFlags, so only the user program arguments should remain.
-                if (ctx.Args is not [string runCommand, ..] || runCommand != "run")
+                // Everything up to and including <pkg> is the entrypoint: in IDE mode VS Code's Go debugger owns it
+                // via program/buildFlags, so it is not passed to the launched program.
+                if (ctx.Resource.HasAnnotationOfType<GoDelveServerAnnotation>())
                 {
+                    // WithDelveServer replaces the whole command line with a headless `dlv debug ...` invocation and
+                    // removes the debug launch annotation, so there is no `go run` prefix to contribute.
                     return;
                 }
 
-                ctx.Args.RemoveAt(0);
+                ctx.Args.Add("run");
+
+                if (ctx.Resource.TryGetLastAnnotation<GoRaceDetectorAnnotation>(out _))
+                {
+                    ctx.Args.Add("-race");
+                }
+
+                if (ctx.Resource.TryGetLastAnnotation<GoBuildTagsAnnotation>(out var tagsAnnotation))
+                {
+                    ctx.Args.Add($"-tags={string.Join(",", tagsAnnotation.Tags)}");
+                }
 
-                while (ctx.Args is [string arg, ..] && IsGoRunBuildFlag(arg))
+                if (ctx.Resource.TryGetLastAnnotation<GoLdFlagsAnnotation>(out var ldFlagsAnnotation))
                 {
-                    ctx.Args.RemoveAt(0);
+                    ctx.Args.Add($"-ldflags={ldFlagsAnnotation.Flags}");
                 }
 
-                if (ctx.Args.Count > 0)
+                if (ctx.Resource.TryGetLastAnnotation<GoGcFlagsAnnotation>(out var gcFlagsAnnotation))
                 {
-                    ctx.Args.RemoveAt(0);
+                    ctx.Args.Add($"-gcflags={gcFlagsAnnotation.Flags}");
                 }
+
+                ctx.Args.Add(ctx.Resource.TryGetLastAnnotation<GoPackagePathAnnotation>(out var pkgAnnotation)
+                    ? pkgAnnotation.PackagePath
+                    : ".");
             });
     }
 
-    private static bool IsGoRunBuildFlag(string arg) =>
-        arg == "-race" ||
-        arg.StartsWith("-tags=", StringComparison.Ordinal) ||
-        arg.StartsWith("-ldflags=", StringComparison.Ordinal) ||
-        arg.StartsWith("-gcflags=", StringComparison.Ordinal);
-
     /// <summary>
     /// Builds the <c>go build</c> command for the generated Dockerfile, propagating any
     /// build-time flags that were set on the resource via <see cref="AddGoApp"/>.
diff --git a/src/Aspire.Hosting.Python/PythonAppResourceBuilderExtensions.cs b/src/Aspire.Hosting.Python/PythonAppResourceBuilderExtensions.cs
index 949ea8b8e0e..7fe70758328 100644
--- a/src/Aspire.Hosting.Python/PythonAppResourceBuilderExtensions.cs
+++ b/src/Aspire.Hosting.Python/PythonAppResourceBuilderExtensions.cs
@@ -993,37 +993,10 @@ public static IResourceBuilder<T> WithDebugging<T>(
                     WorkingDirectory = workingDirectory
                 };
             },
-            "python",
-            static ctx =>
-            {
-                // Remove entrypoint-specific arguments that VS Code will handle.
-                // We need to verify the annotation to ensure we remove the correct args.
-                if (!ctx.Resource.TryGetLastAnnotation<PythonEntrypointAnnotation>(out var annotation))
-                {
-                    return;
-                }
-
-                // For Module type: remove "-m" and module name (2 args)
-                if (annotation.Type == EntrypointType.Module)
-                {
-                    if (ctx.Args is [string arg0, string arg1, ..] &&
-                        arg0 == "-m" &&
-                        arg1 == annotation.Entrypoint)
-                    {
-                        ctx.Args.RemoveAt(0); // Remove "-m"
-                        ctx.Args.RemoveAt(0); // Remove module name
-                    }
-                }
-                // For Script type: remove script path (1 arg)
-                else if (annotation.Type == EntrypointType.Script)
-                {
-                    if (ctx.Args is [string arg0, ..] &&
-                        arg0 == annotation.Entrypoint)
-                    {
-                        ctx.Args.RemoveAt(0); // Remove script path
-                    }
-                }
-            });
+            // The entrypoint arguments (`-m <module>` / `<script>`) are declared by WithEntrypoint, which is also
+            // reachable on Python resources that never opt into debugging. They carry the same "python" launch
+            // configuration type, so they are automatically withheld when VS Code launches the interpreter itself.
+            "python");
 
         return builder;
     }
@@ -1047,8 +1020,8 @@ public static IResourceBuilder<T> WithDebugging<T>(
     /// <item><description><b>Executable</b>: Runs the executable directly from the virtual environment</description></item>
     /// </list>
     /// <para>
-    /// <b>Important:</b> This method resets all command-line arguments. If you need to add arguments after changing
-    /// the entrypoint, call <c>WithArgs</c> after this method.
+    /// <b>Note:</b> The entrypoint arguments always lead the resource's command line, so arguments added with
+    /// <c>WithArgs</c> before or after this call are preserved and stay after the entrypoint.
     /// </para>
     /// </remarks>
     /// <example>
@@ -1092,16 +1065,13 @@ public static IResourceBuilder<T> WithEntrypoint<T>(
         },
         ResourceAnnotationMutationBehavior.Replace);
 
-        builder.WithArgs(static context =>
+        builder.WithEntrypointArgs("python", static context =>
         {
             if (!context.Resource.TryGetLastAnnotation<PythonEntrypointAnnotation>(out var existingAnnotation))
             {
                 return;
             }
 
-            // Clear existing args since we're replacing the entrypoint
-            context.Args.Clear();
-
             var entrypointType = existingAnnotation.Type;
             var entrypoint = existingAnnotation.Entrypoint;
 
diff --git a/src/Aspire.Hosting/ApplicationModel/ArgumentsExecutionConfigurationGatherer.cs b/src/Aspire.Hosting/ApplicationModel/ArgumentsExecutionConfigurationGatherer.cs
index 16c901712c3..a3724b1c937 100644
--- a/src/Aspire.Hosting/ApplicationModel/ArgumentsExecutionConfigurationGatherer.cs
+++ b/src/Aspire.Hosting/ApplicationModel/ArgumentsExecutionConfigurationGatherer.cs
@@ -32,5 +32,51 @@ public async ValueTask GatherAsync(IExecutionConfigurationGathererContext contex
             context.Arguments.Clear();
             context.Arguments.AddRange(args);
         }
+
+        await GatherEntrypointArgumentsAsync(context, resource, resourceLogger, executionContext, cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Evaluates the resource's entrypoint arguments (the tool-invocation prefix, e.g. <c>run ./cmd/api</c>) and
+    /// inserts them ahead of every other argument.
+    /// </summary>
+    /// <remarks>
+    /// The callback is deliberately evaluated <em>after</em> the ordinary argument callbacks but its result is
+    /// inserted <em>before</em> them. That is what makes the prefix order-independent: no <c>WithArgs</c> callback
+    /// can observe it, mutate it, or clear it, so it does not matter whether the entrypoint was declared before or
+    /// after the calls that add the program's own arguments.
+    /// </remarks>
+    private static async ValueTask GatherEntrypointArgumentsAsync(IExecutionConfigurationGathererContext context, IResource resource, ILogger resourceLogger, DistributedApplicationExecutionContext executionContext, CancellationToken cancellationToken)
+    {
+        // Entrypoint arguments describe how a local tool (the resource's executable command) invokes the program.
+        // A container invokes the program through the image's ENTRYPOINT instead, so the prefix must not be repeated
+        // in its arguments. This matters for executables published as a Dockerfile (Go, Python, JavaScript), where
+        // PublishAsDockerFile() reuses the executable's annotations for the generated container resource.
+        if (resource is ContainerResource)
+        {
+            return;
+        }
+
+        // Only the last annotation applies, mirroring how the active SupportsDebuggingAnnotation is resolved:
+        // a resource can be handed entrypoint arguments more than once and the most recent declaration wins.
+        if (!resource.TryGetLastAnnotation<EntrypointArgsCallbackAnnotation>(out var entrypointAnnotation))
+        {
+            return;
+        }
+
+        var entrypointContext = new CommandLineArgsCallbackContext([], resource, cancellationToken)
+        {
+            Logger = resourceLogger,
+            ExecutionContext = executionContext
+        };
+
+        var entrypointArgs = await entrypointAnnotation.AsCallbackAnnotation().EvaluateOnceAsync(entrypointContext).ConfigureAwait(false);
+        if (entrypointArgs.Count == 0)
+        {
+            return;
+        }
+
+        context.Arguments.InsertRange(0, entrypointArgs);
+        context.AddAdditionalData(new EntrypointArgumentsData(entrypointArgs.Count));
     }
 }
\ No newline at end of file
diff --git a/src/Aspire.Hosting/ApplicationModel/DebugSupportExtensions.cs b/src/Aspire.Hosting/ApplicationModel/DebugSupportExtensions.cs
index 99d9d924973..44a2f51b009 100644
--- a/src/Aspire.Hosting/ApplicationModel/DebugSupportExtensions.cs
+++ b/src/Aspire.Hosting/ApplicationModel/DebugSupportExtensions.cs
@@ -73,6 +73,22 @@ public static bool SupportsDebugging(this IResource resource, IConfiguration con
         return supportedLaunchConfigurations.Contains(supportsDebuggingAnnotation.LaunchConfigurationType);
     }
 
+    /// <summary>
+    /// Determines whether the launch configuration owns the resource's entrypoint arguments.
+    /// </summary>
+    /// <param name="resource">The resource to inspect.</param>
+    /// <param name="supportsDebuggingAnnotation">The launch configuration annotation to compare.</param>
+    /// <returns><see langword="true"/> when the launch configuration supplies the entrypoint; otherwise, <see langword="false"/>.</returns>
+    [AspireExportIgnore(Reason = "Debug support inspection is a local .NET helper and is not part of the ATS surface.")]
+    public static bool OwnsEntrypointArguments(this IResource resource, SupportsDebuggingAnnotation supportsDebuggingAnnotation)
+    {
+        ArgumentNullException.ThrowIfNull(resource);
+        ArgumentNullException.ThrowIfNull(supportsDebuggingAnnotation);
+
+        return resource.TryGetLastAnnotation<EntrypointArgsCallbackAnnotation>(out var entrypointAnnotation)
+            && string.Equals(entrypointAnnotation.LaunchConfigurationType, supportsDebuggingAnnotation.LaunchConfigurationType, StringComparison.Ordinal);
+    }
+
     /// <summary>
     /// Creates the launch configuration that this resource sends to the IDE for the given launch mode.
     /// </summary>
diff --git a/src/Aspire.Hosting/ApplicationModel/EntrypointArgsCallbackAnnotation.cs b/src/Aspire.Hosting/ApplicationModel/EntrypointArgsCallbackAnnotation.cs
new file mode 100644
index 00000000000..445253f47d5
--- /dev/null
+++ b/src/Aspire.Hosting/ApplicationModel/EntrypointArgsCallbackAnnotation.cs
@@ -0,0 +1,98 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Immutable;
+
+namespace Aspire.Hosting.ApplicationModel;
+
+using IArgCallbackAnnotation = ICallbackResourceAnnotation<CommandLineArgsCallbackContext, IList<object>>;
+
+/// <summary>
+/// Carries the <em>entrypoint arguments</em> of a resource: the tool-invocation prefix that hosts the
+/// program, such as <c>run -tags=netgo ./cmd/api</c> for <c>go</c> or <c>-m flask</c> for <c>python</c>.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Entrypoint arguments are modelled separately from ordinary <see cref="CommandLineArgsCallbackAnnotation"/>
+/// arguments for two reasons:
+/// </para>
+/// <list type="number">
+/// <item><description>
+/// They are always placed <em>first</em>, no matter when the annotation was added. The callback is evaluated
+/// against its own empty argument list and the result is inserted ahead of every other argument, so no
+/// <c>WithArgs</c> callback can observe it, mutate it, or clear it, and no registration order is implied.
+/// </description></item>
+/// <item><description>
+/// When an IDE debug launch configuration owns the entrypoint (the debugger launches the built binary or the
+/// interpreter itself), the prefix must not be passed to the program. Because it is a separate, structurally
+/// leading list, it can simply be withheld instead of being textually subtracted from the final command line.
+/// </description></item>
+/// </list>
+/// </remarks>
+internal sealed class EntrypointArgsCallbackAnnotation : IResourceAnnotation, IArgCallbackAnnotation
+{
+    private Task<IList<object>>? _callbackTask;
+    private readonly object _lock = new();
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="EntrypointArgsCallbackAnnotation"/> class.
+    /// </summary>
+    /// <param name="launchConfigurationType">
+    /// The debug launch configuration type that owns this entrypoint, for example "go" or "python".
+    /// </param>
+    /// <param name="callback">
+    /// Callback that produces the entrypoint arguments. It is invoked with an empty
+    /// <see cref="CommandLineArgsCallbackContext.Args"/> list; everything it adds becomes the leading arguments.
+    /// </param>
+    public EntrypointArgsCallbackAnnotation(string launchConfigurationType, Func<CommandLineArgsCallbackContext, Task> callback)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(launchConfigurationType);
+        ArgumentNullException.ThrowIfNull(callback);
+
+        LaunchConfigurationType = launchConfigurationType;
+        Callback = callback;
+    }
+
+    /// <summary>
+    /// Gets the debug launch configuration type that owns this entrypoint.
+    /// </summary>
+    public string LaunchConfigurationType { get; }
+
+    /// <summary>
+    /// Gets the callback that produces the entrypoint arguments.
+    /// </summary>
+    public Func<CommandLineArgsCallbackContext, Task> Callback { get; }
+
+    internal IArgCallbackAnnotation AsCallbackAnnotation() => this;
+
+    Task<IList<object>> IArgCallbackAnnotation.EvaluateOnceAsync(CommandLineArgsCallbackContext context)
+    {
+        lock (_lock)
+        {
+            _callbackTask ??= ExecuteCallbackAsync(context);
+            return _callbackTask;
+        }
+    }
+
+    void IArgCallbackAnnotation.ForgetCachedResult()
+    {
+        lock (_lock)
+        {
+            _callbackTask = null;
+        }
+    }
+
+    private async Task<IList<object>> ExecuteCallbackAsync(CommandLineArgsCallbackContext context)
+    {
+        await Callback(context).ConfigureAwait(false);
+        return context.Args.ToImmutableList();
+    }
+}
+
+/// <summary>
+/// Reports how many of the leading arguments in an execution configuration were produced by an
+/// <see cref="EntrypointArgsCallbackAnnotation"/>, so that consumers that compose the actual command line
+/// (such as the DCP executable creator) can tell the tool-invocation prefix apart from the program arguments.
+/// </summary>
+/// <param name="Count">The number of leading arguments that form the entrypoint prefix.</param>
+internal sealed record EntrypointArgumentsData(int Count) : IExecutionConfigurationData;
diff --git a/src/Aspire.Hosting/Dcp/DcpExecutor.cs b/src/Aspire.Hosting/Dcp/DcpExecutor.cs
index a5f48970a99..3e297026163 100644
--- a/src/Aspire.Hosting/Dcp/DcpExecutor.cs
+++ b/src/Aspire.Hosting/Dcp/DcpExecutor.cs
@@ -1352,6 +1352,14 @@ private static void ForgetCachedCallbackResults(IResource resource)
                 ((ICallbackResourceAnnotation<CommandLineArgsCallbackContext, IList<object>>)callback).ForgetCachedResult();
             }
         }
+
+        if (resource.TryGetAnnotationsOfType<EntrypointArgsCallbackAnnotation>(out var entrypointArgsCallbacks))
+        {
+            foreach (var callback in entrypointArgsCallbacks)
+            {
+                ((ICallbackResourceAnnotation<CommandLineArgsCallbackContext, IList<object>>)callback).ForgetCachedResult();
+            }
+        }
     }
 
     private void ForgetConnectionStringAvailableEvent(IResource resource)
diff --git a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
index 42b5f123920..97e0edf1258 100644
--- a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
+++ b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
@@ -94,8 +94,22 @@ public async Task CreateObjectAsync(RenderedModelResource<Executable> er, EmptyC
 
         spec.PemCertificates = pemCertificates;
 
+        if (configuration.Exception is not null)
+        {
+            throw new FailedToApplyEnvironmentException($"Failed to apply configuration to executable {er.ModelResource.Name}", configuration.Exception);
+        }
+
+        // The launch configuration is applied before the command line is composed because applying it can switch the
+        // execution type to Process, and the composition depends on the final execution type: an IDE-launched
+        // resource does not receive its entrypoint arguments, a process-launched one does.
+        await ApplyLaunchConfigurationAsync(er, exe, cancellationToken).ConfigureAwait(false);
+
+        var omittedEntrypointArgumentCount = OmitEntrypointArguments(er, spec)
+            ? configuration.AdditionalConfigurationData.OfType<EntrypointArgumentsData>().FirstOrDefault()?.Count ?? 0
+            : 0;
+
         var executableArgumentStartIndex = spec.Args?.Count ?? 0;
-        var launchArgs = BuildLaunchArgs(er, spec, configuration.Arguments, executableArgumentStartIndex);
+        var launchArgs = BuildLaunchArgs(er, spec, configuration.Arguments, executableArgumentStartIndex, omittedEntrypointArgumentCount);
         if (!HasProjectLaunchArgsOverride(er.ModelResource))
         {
             AddDotnetRunArgsForExecutableAnnotatedProject(er, launchArgs, executableArgumentStartIndex);
@@ -110,6 +124,19 @@ public async Task CreateObjectAsync(RenderedModelResource<Executable> er, EmptyC
         // Arg annotations are what is displayed in the dashboard.
         er.DcpResource.SetAnnotationAsObjectList(CustomResource.ResourceAppArgsAnnotation, displayArgs.Select(a => new AppLaunchArgumentAnnotation(a.Value, isSensitive: a.IsSensitive, effectiveArgumentIndex: a.EffectiveArgumentIndex)));
 
+        // PrepareObjects() had to decide on the DCP-level Process fallback before any argument callback had run,
+        // so it conservatively withheld the fallback from every resource that declares entrypoint arguments.
+        // Now that the arguments are known, restore it when nothing was actually withheld from Spec.Args
+        // (for example a Python "Executable" entrypoint contributes no prefix at all).
+        if (spec.ExecutionType == ExecutionType.IDE
+            && er.ModelResource.SupportsDebugging(_configuration, out var debuggingAnnotation)
+            && er.ModelResource.OwnsEntrypointArguments(debuggingAnnotation))
+        {
+            spec.FallbackExecutionTypes = ShouldOfferProcessFallback(er.ModelResource, debuggingAnnotation, entrypointArgumentsOmitted: omittedEntrypointArgumentCount > 0)
+                ? [ExecutionType.Process]
+                : null;
+        }
+
         spec.Env = configuration.EnvironmentVariables.Select(kvp => new EnvVar { Name = kvp.Key, Value = kvp.Value }).ToList();
 
         // Configure the per-replica terminal spec if the resource has a TerminalAnnotation.
@@ -153,62 +180,104 @@ public async Task CreateObjectAsync(RenderedModelResource<Executable> er, EmptyC
             }
         }
 
-        if (configuration.Exception is not null)
+        await factory.CreateDcpObjectsAsync([exe], cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Applies the resource's debug launch configuration, now that endpoints are allocated and the launch
+    /// configuration can reference endpoint URLs that were not available during <see cref="PrepareObjectsAsync"/>.
+    /// </summary>
+    /// <remarks>
+    /// "project" launch types on <see cref="ProjectResource"/> configure their launch configurations in
+    /// <c>PrepareProjectExecutables()</c> directly. Plain executables that carry <see cref="IProjectMetadata"/> and a
+    /// "project" <see cref="SupportsDebuggingAnnotation"/> (e.g. <c>DotnetProjectResource</c>) are prepared as plain
+    /// executables, so their "project" launch configuration is applied here for IDE/F5 parity with <c>AddProject</c>.
+    /// All other types (plain executables and project subtypes like azure-functions) are also handled here.
+    /// </remarks>
+    private async Task ApplyLaunchConfigurationAsync(RenderedModelResource<Executable> er, Executable exe, CancellationToken cancellationToken)
+    {
+        if (er.ModelResource.HasAnnotationOfType<ForceProcessExecutionAnnotation>()
+            || !er.ModelResource.SupportsDebugging(_configuration, out var supportsDebuggingAnnotation))
         {
-            throw new FailedToApplyEnvironmentException($"Failed to apply configuration to executable {er.ModelResource.Name}", configuration.Exception);
+            return;
         }
 
-        // Invoke the debug configuration callback now that endpoints are allocated.
-        // This allows launch configurations to access endpoint URLs that were not
-        // available during PrepareExecutables().
-        // "project" launch types on ProjectResources configure their launch configs in
-        // PrepareProjectExecutables() directly. Plain executables that carry IProjectMetadata and a
-        // "project" SupportsDebuggingAnnotation (e.g. DotnetProjectResource) are prepared as plain executables, 
-        // so their "project" launch configuration is applied here for IDE/F5 parity with AddProject. 
-        // All other types (plain executables and project subtypes like azure-functions) are also handled here.
-        if (!er.ModelResource.HasAnnotationOfType<ForceProcessExecutionAnnotation>()
-            && er.ModelResource.SupportsDebugging(_configuration, out var supportsDebuggingAnnotation))
+        if (supportsDebuggingAnnotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project)
         {
-            if (supportsDebuggingAnnotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project)
-            {
-                // ProjectResources already applied the "project" launch config in PrepareProjectExecutables().
-                // Only plain executables carrying project metadata need it applied here.
-                if (er.ModelResource is not ProjectResource)
-                {
-                    if (er.ModelResource.TryGetProjectMetadata(out var plainProjectMetadata))
-                    {
-                        // Clear and re-apply the launch configuration to ensure proper restart behavior.
-                        await ApplyProjectLaunchConfigurationAsync(exe, er.ModelResource, plainProjectMetadata, supportsDebuggingAnnotation, cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        throw new FailedToApplyEnvironmentException(
-                            $"Resource '{er.ModelResource.Name}' declares \"project\" debug launch support (WithDebugSupport) but has no project metadata. " +
-                            $"The \"project\" launch configuration type is reserved for .NET project resources; use a resource that carries {nameof(IProjectMetadata)} or a different launch configuration type.");
-                    }
-                }
-            }
-            else
+            // ProjectResources already applied the "project" launch config in PrepareProjectExecutables().
+            // Only plain executables carrying project metadata need it applied here.
+            if (er.ModelResource is not ProjectResource)
             {
-                // We have non-project Executable that supports debugging; need to annotate it properly.
-
-                var mode = _configuration[KnownConfigNames.DebugSessionRunMode] ?? ExecutableLaunchMode.NoDebug;
-                try
+                if (er.ModelResource.TryGetProjectMetadata(out var plainProjectMetadata))
                 {
-                    // Clear any existing launch configurations (needed for restart scenarios).
-                    exe.Annotate(Executable.LaunchConfigurationsAnnotation, string.Empty);
-                    await supportsDebuggingAnnotation.LaunchConfigurationAnnotator(exe, mode, cancellationToken).ConfigureAwait(false);
+                    // Clear and re-apply the launch configuration to ensure proper restart behavior.
+                    await ApplyProjectLaunchConfigurationAsync(exe, er.ModelResource, plainProjectMetadata, supportsDebuggingAnnotation, cancellationToken).ConfigureAwait(false);
                 }
-                // Only fall back to Process when Spec.Args still forms a runnable command.
-                catch (Exception ex) when (!supportsDebuggingAnnotation.RewritesArgumentsForDebugging)
+                else
                 {
-                    _logger.LogWarning(ex, "Failed to apply launch configuration for resource '{ResourceName}'. Falling back to process execution.", er.ModelResource.Name);
-                    exe.Spec.ExecutionType = ExecutionType.Process;
+                    throw new FailedToApplyEnvironmentException(
+                        $"Resource '{er.ModelResource.Name}' declares \"project\" debug launch support (WithDebugSupport) but has no project metadata. " +
+                        $"The \"project\" launch configuration type is reserved for .NET project resources; use a resource that carries {nameof(IProjectMetadata)} or a different launch configuration type.");
                 }
             }
+
+            return;
         }
 
-        await factory.CreateDcpObjectsAsync([exe], cancellationToken).ConfigureAwait(false);
+        // We have non-project Executable that supports debugging; need to annotate it properly.
+        var mode = _configuration[KnownConfigNames.DebugSessionRunMode] ?? ExecutableLaunchMode.NoDebug;
+        try
+        {
+            // Clear any existing launch configurations (needed for restart scenarios).
+            exe.Annotate(Executable.LaunchConfigurationsAnnotation, string.Empty);
+            await supportsDebuggingAnnotation.LaunchConfigurationAnnotator(exe, mode, cancellationToken).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            // Falling back here is safe even for resources with entrypoint arguments: the command line is composed
+            // after this point, so switching to Process execution now means the full command line is emitted.
+            _logger.LogWarning(ex, "Failed to apply launch configuration for resource '{ResourceName}'. Falling back to process execution.", er.ModelResource.Name);
+            exe.Spec.ExecutionType = ExecutionType.Process;
+        }
+    }
+
+    /// <summary>
+    /// Determines whether the resource's entrypoint arguments must be omitted from the DCP executable spec because
+    /// it will be handled by IDE launch configuration.
+    /// </summary>
+    private bool OmitEntrypointArguments(RenderedModelResource<Executable> er, ExecutableSpec spec)
+    {
+        if (spec.ExecutionType != ExecutionType.IDE)
+        {
+            return false;
+        }
+
+        // Only withhold when the launch configuration that declared the entrypoint is the one actually in use.
+        // A launch configuration of a different type knows nothing about this entrypoint, so in that case the
+        // resource keeps its full command line.
+        return er.ModelResource.SupportsDebugging(_configuration, out var activeAnnotation)
+            && er.ModelResource.OwnsEntrypointArguments(activeAnnotation);
+    }
+
+    /// <summary>
+    /// Determines whether DCP may fall back to Process execution when the IDE cannot launch the resource.
+    /// </summary>
+    /// <remarks>
+    /// A Process fallback runs the DCP Executable spec's command and args "as is", so it is only meaningful when
+    /// those args form a runnable command. A DCP Executable spec has a single <c>args</c> field, so it cannot carry
+    /// both the IDE form and the process form of the command line: when the entrypoint prefix is omitted for the
+    /// IDE, no fallback can be offered.
+    /// </remarks>
+    private static bool ShouldOfferProcessFallback(IResource modelResource, SupportsDebuggingAnnotation annotation, bool entrypointArgumentsOmitted)
+    {
+        if (entrypointArgumentsOmitted)
+        {
+            return false;
+        }
+
+        // A ProjectResource always carries a runnable `dotnet run ...` command in its project args. A plain
+        // executable with a "project" launch configuration does not — those args come from the IDE.
+        return modelResource is ProjectResource || annotation.LaunchConfigurationType is not "project";
     }
 
     private async Task PrepareProjectExecutablesAsync(CancellationToken cancellationToken)
@@ -282,11 +351,12 @@ private async Task PrepareProjectExecutablesAsync(CancellationToken cancellation
                 {
                     exe.Spec.ExecutionType = ExecutionType.IDE;
 
-                    // A Process fallback runs the DCP Executable Spec's command and args "as is". When the debug
-                    // support rewrites the resource's arguments for debugging (an argsCallback on an
-                    // IResourceWithArgs, supplied via the generic WithDebugSupport), those args are valid only for
-                    // IDE launch, so a Process fallback would run a broken command. Skip the fallback in that case.
-                    if (!supportsDebuggingAnnotation.RewritesArgumentsForDebugging)
+                    // A Process fallback runs the DCP Executable Spec's command and args "as is". A resource that
+                    // declares entrypoint arguments may have them withheld from Spec.Args for the IDE, which would
+                    // leave a Process fallback running a broken command. The arguments are not evaluated yet here,
+                    // so omit the fallback conservatively; CreateObjectAsync() will add it if the entrypoint arguments
+                    // are not used.
+                    if (ShouldOfferProcessFallback(project, supportsDebuggingAnnotation, entrypointArgumentsOmitted: project.OwnsEntrypointArguments(supportsDebuggingAnnotation)))
                     {
                         exe.Spec.FallbackExecutionTypes = [ExecutionType.Process];
                     }
@@ -449,11 +519,11 @@ private void PreparePlainExecutables()
                 // will be invoked in CreateExecutableAsync after endpoints are allocated.
                 exe.Spec.ExecutionType = ExecutionType.IDE;
 
-                // A Process fallback is only meaningful when the fallback can actually launch the resource.
-                // This means the DCP Executable Spec has "real" command and args that can be executed "as is".
-                // In case of "project" launch configuration type, or when RewritesArgumentsForDebugging is true, 
-                // that is not the case, so we do not add the fallback. 
-                if (supportsDebuggingAnnotation.LaunchConfigurationType is not KnownLaunchConfigurationTypes.Project && !supportsDebuggingAnnotation.RewritesArgumentsForDebugging)
+                // A Process fallback is only meaningful when the fallback can actually launch the resource, i.e. when
+                // the DCP Executable Spec has "real" command and args that can be executed "as is". The arguments are
+                // not evaluated yet here, so a resource that declares entrypoint arguments conservatively forgoes the
+                // fallback; CreateObjectAsync() will add it when it determines that entrypoint arguments are not used.
+                if (ShouldOfferProcessFallback(executable, supportsDebuggingAnnotation, entrypointArgumentsOmitted: executable.OwnsEntrypointArguments(supportsDebuggingAnnotation)))
                 {
                     exe.Spec.FallbackExecutionTypes = [ExecutionType.Process];
                 }
@@ -619,7 +689,13 @@ private string GetCertificatesRootDirectory(RenderedModelResource<Executable> er
         return Path.Join(_locations.DcpSessionDir, exe.Metadata.Name);
     }
 
-    private static List<LaunchArgument> BuildLaunchArgs(RenderedModelResource<Executable> er, ExecutableSpec spec, IEnumerable<(string Value, bool IsSensitive)> appHostArgs, int executableArgumentStartIndex)
+    private static List<LaunchArgument> BuildLaunchArgs(
+        RenderedModelResource<Executable> er,
+        ExecutableSpec spec,
+        IEnumerable<(string Value, bool IsSensitive)> appHostArgs,
+        int executableArgumentStartIndex,
+        int omittedEntrypointArgumentCount
+    )
     {
         // Launch args is the final list of args that are displayed in the UI and possibly added to the executable spec.
         // They're built from app host resource model args and any args in the effective launch profile.
@@ -680,7 +756,11 @@ LaunchArgument CreateLaunchArgument(string value, bool isSensitive, bool executa
         }
 
         // In the situation where args are combined (process execution) the app host args are added after the launch profile args.
-        launchArgs.AddRange(appHostArgList.Select(a => CreateLaunchArgument(a.Value, a.IsSensitive, executable: true, display: true)));
+        // Entrypoint arguments (the tool-invocation prefix such as `run ./cmd/api`) are always the leading app host
+        // args. When the IDE launch configuration owns them they must not be passed to the launched program, but they
+        // are still shown in the dashboard so the resource's real command line stays visible — the same treatment
+        // project launch-profile args get above.
+        launchArgs.AddRange(appHostArgList.Select((a, i) => CreateLaunchArgument(a.Value, a.IsSensitive, executable: i >= omittedEntrypointArgumentCount, display: true)));
 
         return launchArgs;
     }
diff --git a/src/Aspire.Hosting/ResourceBuilderExtensions.cs b/src/Aspire.Hosting/ResourceBuilderExtensions.cs
index c15be44ba95..a4074137eb3 100644
--- a/src/Aspire.Hosting/ResourceBuilderExtensions.cs
+++ b/src/Aspire.Hosting/ResourceBuilderExtensions.cs
@@ -4760,6 +4760,53 @@ public static IResourceBuilder<T> WithComputeEnvironment<T>(this IResourceBuilde
         return builder;
     }
 
+    /// <summary>
+    /// Declares the resource's <em>entrypoint arguments</em>: the tool-invocation prefix that hosts the program,
+    /// for example <c>run ./cmd/api</c> for <c>go</c> or <c>-m flask</c> for <c>python</c>.
+    /// </summary>
+    /// <param name="builder">The resource builder.</param>
+    /// <param name="launchConfigurationType">
+    /// The debug launch configuration type that owns this entrypoint, for example "go" or "python". This is the same
+    /// value passed to <c>WithDebugSupport</c>.
+    /// </param>
+    /// <param name="callback">
+    /// Callback that produces the entrypoint arguments. It is invoked with an <em>empty</em>
+    /// <see cref="CommandLineArgsCallbackContext.Args"/> list; everything it adds becomes the leading arguments.
+    /// </param>
+    /// <returns>A reference to the <see cref="IResourceBuilder{T}"/>.</returns>
+    /// <remarks>
+    /// <para>
+    /// Entrypoint arguments are always placed ahead of every argument contributed by <c>WithArgs</c>, no matter when
+    /// this method is called, and no <c>WithArgs</c> callback can observe or modify them. Declaring the tool
+    /// invocation this way therefore avoids any dependency on the order in which resource builder methods are called.
+    /// </para>
+    /// <para>
+    /// When the resource is launched by an IDE using a launch configuration of
+    /// <paramref name="launchConfigurationType"/> (see <c>WithDebugSupport</c>), the launch configuration
+    /// already carries the tool invocation, so these arguments are not passed to the launched program. In every other
+    /// case — process execution, publish, or when a launch configuration of a different type is active — they are
+    /// part of the resource's command line.
+    /// </para>
+    /// <para>
+    /// Calling this method more than once is allowed; the most recent declaration wins.
+    /// </para>
+    /// </remarks>
+    [Experimental("ASPIREEXTENSION001", UrlFormat = "https://aka.ms/aspire/diagnostics/{0}")]
+    [AspireExportIgnore(Reason = "Generic debug launch configuration support is not part of the ATS surface.")]
+    public static IResourceBuilder<T> WithEntrypointArgs<T>(this IResourceBuilder<T> builder, string launchConfigurationType, Action<CommandLineArgsCallbackContext> callback)
+        where T : IResourceWithArgs
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentException.ThrowIfNullOrEmpty(launchConfigurationType);
+        ArgumentNullException.ThrowIfNull(callback);
+
+        return builder.WithAnnotation(new EntrypointArgsCallbackAnnotation(launchConfigurationType, ctx =>
+        {
+            callback(ctx);
+            return Task.CompletedTask;
+        }));
+    }
+
     /// <summary>
     /// Adds support for debugging the resource in VS Code when running in an extension host.
     /// </summary>
@@ -4768,7 +4815,7 @@ public static IResourceBuilder<T> WithComputeEnvironment<T>(this IResourceBuilde
     /// <param name="builder">The resource builder.</param>
     /// <param name="launchConfigurationProducer">Launch configuration producer for the resource. It is passed the launch mode (one of the values on <see cref="ExecutableLaunchMode"/>) and produces the configuration that is handed to the IDE.</param>
     /// <param name="launchConfigurationType">The type tag of the launch configuration (as sent to the IDE).</param>
-    /// <param name="argsCallback">Optional callback to add or modify command line arguments when running in an extension host. Useful if the entrypoint is usually provided as an argument to the resource executable.</param>
+    /// <param name="entrypointArgsCallback">Optional callback that produces the resource's entrypoint arguments.</param>
     /// <returns>The <see cref="IResourceBuilder{T}"/>.</returns>
     /// <exception cref="ArgumentException">
     /// <typeparamref name="TLaunchConfiguration"/> is a <see cref="Task"/> or <see cref="ValueTask"/>, which means an
@@ -4784,7 +4831,7 @@ public static IResourceBuilder<T> WithComputeEnvironment<T>(this IResourceBuilde
     /// </remarks>
     [Experimental("ASPIREEXTENSION001", UrlFormat = "https://aka.ms/aspire/diagnostics/{0}")]
     [AspireExportIgnore(Reason = "Generic debug launch configuration support is not part of the ATS surface.")]
-    public static IResourceBuilder<T> WithDebugSupport<T, TLaunchConfiguration>(this IResourceBuilder<T> builder, Func<string, TLaunchConfiguration> launchConfigurationProducer, string launchConfigurationType, Action<CommandLineArgsCallbackContext>? argsCallback = null)
+    public static IResourceBuilder<T> WithDebugSupport<T, TLaunchConfiguration>(this IResourceBuilder<T> builder, Func<string, TLaunchConfiguration> launchConfigurationProducer, string launchConfigurationType, Action<CommandLineArgsCallbackContext>? entrypointArgsCallback = null)
         where T : IResource
     {
         ArgumentNullException.ThrowIfNull(builder);
@@ -4798,7 +4845,7 @@ public static IResourceBuilder<T> WithDebugSupport<T, TLaunchConfiguration>(this
                 nameof(launchConfigurationProducer));
         }
 
-        return builder.WithDebugSupport((mode, _) => Task.FromResult(launchConfigurationProducer(mode)), launchConfigurationType, argsCallback);
+        return builder.WithDebugSupport((mode, _) => Task.FromResult(launchConfigurationProducer(mode)), launchConfigurationType, entrypointArgsCallback);
 
         static bool IsValueTask(Type type)
             => type == typeof(ValueTask) || (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ValueTask<>));
@@ -4813,7 +4860,7 @@ static bool IsValueTask(Type type)
     /// <param name="builder">The resource builder.</param>
     /// <param name="launchConfigurationProducer">Launch configuration producer for the resource. It is passed the launch mode (one of the values on <see cref="ExecutableLaunchMode"/>) and produces the configuration that is handed to the IDE.</param>
     /// <param name="launchConfigurationType">The type of the resource.</param>
-    /// <param name="argsCallback">Optional callback to add or modify command line arguments when running in an extension host. Useful if the entrypoint is usually provided as an argument to the resource executable.</param>
+    /// <param name="entrypointArgsCallback">Optional callback that produces the resource's entrypoint arguments.</param>
     /// <returns>The <see cref="IResourceBuilder{T}"/>.</returns>
     /// <remarks>
     /// Use this overload when the launch configuration has to be resolved from work that is itself asynchronous, for
@@ -4825,39 +4872,28 @@ static bool IsValueTask(Type type)
     /// </remarks>
     [Experimental("ASPIREEXTENSION001", UrlFormat = "https://aka.ms/aspire/diagnostics/{0}")]
     [AspireExportIgnore(Reason = "Generic debug launch configuration support is not part of the ATS surface.")]
-    public static IResourceBuilder<T> WithDebugSupport<T, TLaunchConfiguration>(this IResourceBuilder<T> builder, Func<string, CancellationToken, Task<TLaunchConfiguration>> launchConfigurationProducer, string launchConfigurationType, Action<CommandLineArgsCallbackContext>? argsCallback = null)
+    public static IResourceBuilder<T> WithDebugSupport<T, TLaunchConfiguration>(this IResourceBuilder<T> builder, Func<string, CancellationToken, Task<TLaunchConfiguration>> launchConfigurationProducer, string launchConfigurationType, Action<CommandLineArgsCallbackContext>? entrypointArgsCallback = null)
         where T : IResource
     {
         ArgumentNullException.ThrowIfNull(builder);
         ArgumentNullException.ThrowIfNull(launchConfigurationProducer);
 
+        // Entrypoint arguments describe how the resource is invoked in general, so unlike debug support itself they
+        // are registered in publish mode too, where they end up in the manifest and in generated container images.
+        if (entrypointArgsCallback is not null && builder is IResourceBuilder<IResourceWithArgs> resourceWithArgs)
+        {
+            resourceWithArgs.WithEntrypointArgs(launchConfigurationType, entrypointArgsCallback);
+        }
+
         if (!builder.ApplicationBuilder.ExecutionContext.IsRunMode)
         {
             return builder;
         }
 
-        var supportsDebuggingAnnotation = SupportsDebuggingAnnotation.Create(
+        return builder.WithAnnotation(SupportsDebuggingAnnotation.Create(
             builder.Resource.Name,
             launchConfigurationType,
-            launchConfigurationProducer,
-            rewritesArgumentsForDebugging: argsCallback is not null && builder is IResourceBuilder<IResourceWithArgs>
-        );
-
-        if (argsCallback is not null && builder is IResourceBuilder<IResourceWithArgs> resourceWithArgs)
-        {
-            resourceWithArgs.WithArgs(ctx =>
-            {
-                // Make sure that we do not call the callback if we aren't the active (last) SupportsDebuggingAnnotation, 
-                // because the callback may be specific to the launch configuration type.
-                if (resourceWithArgs.Resource.SupportsDebugging(builder.ApplicationBuilder.Configuration, out var activeAnnotation)
-                    && ReferenceEquals(activeAnnotation, supportsDebuggingAnnotation))
-                {
-                    argsCallback(ctx);
-                }
-            });
-        }
-
-        return builder.WithAnnotation(supportsDebuggingAnnotation);
+            launchConfigurationProducer));
     }
 
     /// <summary>
diff --git a/src/Aspire.Hosting/SupportsDebuggingAnnotation.cs b/src/Aspire.Hosting/SupportsDebuggingAnnotation.cs
index 3bb4d4cc8a1..b6bde7d597a 100644
--- a/src/Aspire.Hosting/SupportsDebuggingAnnotation.cs
+++ b/src/Aspire.Hosting/SupportsDebuggingAnnotation.cs
@@ -26,13 +26,11 @@ public sealed class SupportsDebuggingAnnotation : IResourceAnnotation
     private SupportsDebuggingAnnotation(
         string launchConfigurationType,
         Func<Executable, string, CancellationToken, Task> launchConfigurationAnnotator,
-        Func<string, CancellationToken, Task<object>> launchConfigurationProducer,
-        bool rewritesArgumentsForDebugging)
+        Func<string, CancellationToken, Task<object>> launchConfigurationProducer)
     {
         LaunchConfigurationType = launchConfigurationType;
         LaunchConfigurationAnnotator = launchConfigurationAnnotator;
         LaunchConfigurationProducer = launchConfigurationProducer;
-        RewritesArgumentsForDebugging = rewritesArgumentsForDebugging;
     }
 
     /// <summary>
@@ -58,29 +56,7 @@ private SupportsDebuggingAnnotation(
     // the supported way to reach it.
     internal Func<string, CancellationToken, Task<object>> LaunchConfigurationProducer { get; }
 
-    /// <summary>
-    /// Indicates that the debug support rewrites the resource's command-line arguments while a debug
-    /// session is active (via the <c>argsCallback</c> passed to <c>WithDebugSupport</c>).
-    /// </summary>
-    /// <remarks>
-    /// Integrations such as Go and Python strip the process entrypoint tokens 
-    /// (e.g. <c>go run &lt;pkg&gt;</c>, <c>python -m &lt;mod&gt;</c>)
-    /// so the IDE debugger can own them, which leaves the executable's <c>Spec.Args</c> valid 
-    /// only for IDE execution. When this is <see langword="true"/>, a Process fallback 
-    /// (either the DCP-level <c>FallbackExecutionTypes</c> or the in-process fallback when the launch configuration fails) 
-    /// would attempt to run <c>ExecutablePath + Args</c> with the entrypoint stripped — a broken command — 
-    /// so a process fallback must NOT be offered.
-    /// <para>
-    /// This is set based purely on the presence of an <c>argsCallback</c> in <c>WithDebugSupport</c>,
-    /// not on whether that callback actually rewrites anything for a given resource configuration. This is a
-    /// deliberate, conservative rule: a resource that supplies an args callback forgoes the process fallback
-    /// even when the callback happens to be a no-op (e.g. a Python "Executable" entrypoint), keeping the rule
-    /// simple and predictable.
-    /// </para>
-    /// </remarks>
-    public bool RewritesArgumentsForDebugging { get; }
-
-    internal static SupportsDebuggingAnnotation Create<T>(string resourceName, string launchConfigurationType, Func<string, CancellationToken, Task<T>> launchProfileProducer, bool rewritesArgumentsForDebugging = false)
+    internal static SupportsDebuggingAnnotation Create<T>(string resourceName, string launchConfigurationType, Func<string, CancellationToken, Task<T>> launchProfileProducer)
     {
         // The annotator stays generic over T so the DCP annotation is serialized against the concrete
         // launch configuration type rather than a boxed object, which would change the emitted JSON.
@@ -89,8 +65,7 @@ internal static SupportsDebuggingAnnotation Create<T>(string resourceName, strin
             async (exe, mode, ct) => exe.AnnotateAsObjectList(Executable.LaunchConfigurationsAnnotation, await ProduceAsync(mode, ct).ConfigureAwait(false)),
             // The suppression is safe because ProduceAsync throws rather than returning null; the
             // compiler cannot see that because T is unconstrained and so may be a nullable type.
-            async (mode, ct) => (await ProduceAsync(mode, ct).ConfigureAwait(false))!,
-            rewritesArgumentsForDebugging);
+            async (mode, ct) => (await ProduceAsync(mode, ct).ConfigureAwait(false))!);
 
         async Task<T> ProduceAsync(string mode, CancellationToken cancellationToken)
         {
diff --git a/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs b/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
index ad6ff85961c..2bbb1c911e5 100644
--- a/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
+++ b/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
@@ -338,12 +338,11 @@ public async Task AddDotnetProject_InDebugSession_KeepsDotnetRunArgs_WhenActiveC
     }
 
     [Fact]
-    public async Task AddDotnetProject_InDebugSession_OmitsDotnetRunScaffolding_WhenActiveCustomDebugSupportRewritesArgs()
+    public async Task AddDotnetProject_InDebugSession_OmitsDotnetRunScaffolding_WhenActiveCustomDebugSupportOwnsEntrypointArgs()
     {
-        // A stacked custom WithDebugSupport with an argsCallback rewrites the arguments for debugging
-        // (RewritesArgumentsForDebugging == true), so no Process fallback is offered and that callback owns
-        // Spec.Args. The `dotnet run …` scaffolding must be omitted; re-emitting it would pollute the args
-        // the custom callback rewrites.
+        // A stacked custom WithDebugSupport that declares entrypoint arguments owns the tool invocation, so no
+        // Process fallback is offered and Spec.Args is composed from that entrypoint plus the program arguments.
+        // The `dotnet run …` scaffolding must be omitted; re-emitting it would duplicate the tool invocation.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
         builder.Configuration["DEBUG_SESSION_PORT"] = "5678";
@@ -356,16 +355,16 @@ public async Task AddDotnetProject_InDebugSession_OmitsDotnetRunScaffolding_When
         var projectPath = Path.Combine(builder.AppHostDirectory, "MyService", "MyService.csproj");
         var app = builder.AddDotnetProject("svc", projectPath, o => o.ExcludeLaunchProfile = true)
                          .WithArgs("--config", "prod.yaml")
-                         .WithDebugSupport(_ => new ExecutableLaunchConfiguration("custom"), "custom", ctx => ctx.Args.Add("rewritten-arg"));
+                         .WithDebugSupport(_ => new ExecutableLaunchConfiguration("custom"), "custom", ctx => ctx.Args.Add("entrypoint-arg"));
 
         using var application = builder.Build();
         var args = await ArgumentEvaluator.GetArgumentListAsync(app.Resource, application.Services);
 
-        // Only the user args plus the custom callback's rewrite remain; no `dotnet run …` scaffolding.
+        // Only the custom entrypoint plus the user args remain; no `dotnet run …` scaffolding.
         Assert.Collection(args,
+            arg => Assert.Equal("entrypoint-arg", arg),
             arg => Assert.Equal("--config", arg),
-            arg => Assert.Equal("prod.yaml", arg),
-            arg => Assert.Equal("rewritten-arg", arg));
+            arg => Assert.Equal("prod.yaml", arg));
     }
 
     [Theory]
diff --git a/tests/Aspire.Hosting.Go.Tests/AddGoAppTests.cs b/tests/Aspire.Hosting.Go.Tests/AddGoAppTests.cs
index 258bfa64e04..670e366d671 100644
--- a/tests/Aspire.Hosting.Go.Tests/AddGoAppTests.cs
+++ b/tests/Aspire.Hosting.Go.Tests/AddGoAppTests.cs
@@ -538,8 +538,11 @@ public async Task WithVSCodeDebugging_OmitsBuildFlagsWhenNoneConfigured()
     }
 
     [Fact]
-    public async Task WithVSCodeDebugging_RemovesGoToolArguments()
+    public async Task WithVSCodeDebugging_KeepsGoToolArgumentsInTheAppModel()
     {
+        // The `go run [build flags] <pkg>` prefix is declared as entrypoint arguments, so it stays part of the
+        // resource's command line even during a debug session. Withholding it from the launched program is a
+        // DCP-level concern (see DcpExecutorTests), which keeps the app model and the dashboard accurate.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         var sourceDir = workspace.CreateDirectory("source");
@@ -566,8 +569,42 @@ public async Task WithVSCodeDebugging_RemovesGoToolArguments()
         var commandArguments = await ArgumentEvaluator.GetArgumentListAsync(app.Resource, application.Services);
 
         Assert.Collection(commandArguments,
+            arg => Assert.Equal("run", arg),
+            arg => Assert.Equal("-race", arg),
+            arg => Assert.Equal("-tags=integration", arg),
+            arg => Assert.Equal("-ldflags=-X main.version=1.0.0", arg),
+            arg => Assert.Equal("-gcflags=all=-N -l", arg),
+            arg => Assert.Equal("./cmd/server", arg),
             arg => Assert.Equal("--config", arg),
             arg => Assert.Equal("prod.yaml", arg));
+
+        // The "go" launch configuration owns that prefix, which is what makes DCP withhold it from the debugger.
+        var debugAnnotation = app.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().Last();
+        Assert.True(app.Resource.OwnsEntrypointArguments(debugAnnotation));
+    }
+
+    [Fact]
+    public async Task WithVSCodeDebugging_GoToolArgumentsLeadTheCommandLineRegardlessOfCallOrder()
+    {
+        // Regression coverage for https://github.com/microsoft/aspire/issues/18929: the tool prefix used to be
+        // removed by an ordinary WithArgs callback, which silently no-opped when it ran before the callback that
+        // added the prefix. Arguments added by the user must always land after the prefix, whenever they are added.
+        using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var sourceDir = workspace.CreateDirectory("source");
+
+        var app = builder.AddGoApp("api", sourceDir.FullName, packagePath: "./cmd/server")
+            .WithArgs("--login", "user");
+
+        var application = builder.Build();
+
+        var commandArguments = await ArgumentEvaluator.GetArgumentListAsync(app.Resource, application.Services);
+
+        Assert.Collection(commandArguments,
+            arg => Assert.Equal("run", arg),
+            arg => Assert.Equal("./cmd/server", arg),
+            arg => Assert.Equal("--login", arg),
+            arg => Assert.Equal("user", arg));
     }
 
     [Fact]
diff --git a/tests/Aspire.Hosting.Python.Tests/AddPythonAppTests.cs b/tests/Aspire.Hosting.Python.Tests/AddPythonAppTests.cs
index 8d37bc4875f..0c3cec1aca8 100644
--- a/tests/Aspire.Hosting.Python.Tests/AddPythonAppTests.cs
+++ b/tests/Aspire.Hosting.Python.Tests/AddPythonAppTests.cs
@@ -1165,14 +1165,11 @@ public async Task WithEntrypoint_ChangesEntrypointTypeAndValue()
         Assert.Equal(EntrypointType.Module, entrypointAnnotation.Type);
         Assert.Equal("uvicorn", entrypointAnnotation.Entrypoint);
 
-        // Verify arguments
+        // Verify arguments. The entrypoint occupies its own leading slot, so switching it replaces only the
+        // entrypoint and leaves arguments added before the switch in place.
         var commandArguments = await ArgumentEvaluator.GetArgumentListAsync(resource, TestServiceProvider.Instance);
 
-        Assert.Equal(4, commandArguments.Count);
-        Assert.Equal("-m", commandArguments[0]);
-        Assert.Equal("uvicorn", commandArguments[1]);
-        Assert.Equal("main:app", commandArguments[2]);
-        Assert.Equal("--reload", commandArguments[3]);
+        Assert.Equal(["-m", "uvicorn", "arg1", "arg2", "main:app", "--reload"], commandArguments);
     }
 
     [Fact]
@@ -1383,7 +1380,7 @@ await Verify(scriptDockerfileContent)
     }
 
     [Fact]
-    public async Task WithDebugSupport_RemovesScriptArgumentForScriptEntrypoint()
+    public async Task WithDebugSupport_KeepsScriptArgumentInTheAppModelForScriptEntrypoint()
     {
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
         using var workspace = TemporaryWorkspace.Create(outputHelper);
@@ -1415,10 +1412,16 @@ public async Task WithDebugSupport_RemovesScriptArgumentForScriptEntrypoint()
         // Use ArgumentEvaluator to get the resolved argument list (after callbacks are applied)
         var commandArguments = await ArgumentEvaluator.GetArgumentListAsync(resource, app.Services);
 
-        // Verify the script path was removed but other args remain
+        // The entrypoint stays in the app model even during a debug session; withholding it from the launched
+        // program is handled when the DCP executable is created (see DcpExecutorTests).
         Assert.Collection(commandArguments,
+            arg => Assert.Equal("main.py", arg),
             arg => Assert.Equal("arg1", arg),
             arg => Assert.Equal("arg2", arg));
+
+        // The "python" launch configuration owns the entrypoint, which is what makes DCP withhold it.
+        var debugAnnotation = resource.Annotations.OfType<SupportsDebuggingAnnotation>().Last();
+        Assert.True(resource.OwnsEntrypointArguments(debugAnnotation));
     }
 
     [Fact]
@@ -1461,7 +1464,7 @@ public async Task WithDebugSupport_DoesntRemoveScriptArgumentForScriptEntrypoint
     }
 
     [Fact]
-    public async Task WithDebugSupport_RemovesModuleArgumentsForModuleEntrypoint()
+    public async Task WithDebugSupport_KeepsModuleArgumentsInTheAppModelForModuleEntrypoint()
     {
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
         using var workspace = TemporaryWorkspace.Create(outputHelper);
@@ -1493,9 +1496,16 @@ public async Task WithDebugSupport_RemovesModuleArgumentsForModuleEntrypoint()
         // Use ArgumentEvaluator to get the resolved argument list (after callbacks are applied)
         var commandArguments = await ArgumentEvaluator.GetArgumentListAsync(resource, app.Services);
 
-        // Verify "-m" and module name were removed but other args remain
+        // The entrypoint stays in the app model even during a debug session; withholding it from the launched
+        // program is handled when the DCP executable is created (see DcpExecutorTests).
         Assert.Collection(commandArguments,
+            arg => Assert.Equal("-m", arg),
+            arg => Assert.Equal("flask", arg),
             arg => Assert.Equal("run", arg));
+
+        // The "python" launch configuration owns the entrypoint, which is what makes DCP withhold it.
+        var debugAnnotation = resource.Annotations.OfType<SupportsDebuggingAnnotation>().Last();
+        Assert.True(resource.OwnsEntrypointArguments(debugAnnotation));
     }
 
     [Fact]
diff --git a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
index 16607f9434f..5d3b1af2347 100644
--- a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
+++ b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
@@ -3672,16 +3672,16 @@ public async Task PersistentPlainExecutable_ExtensionMode_RunsInProcess()
     }
 
     [Fact]
-    public async Task ProjectResource_WithArgumentRewritingDebugSupport_DoesNotOfferProcessFallback_InDebugSession()
+    public async Task ProjectResource_WithEntrypointArgumentsDebugSupport_DoesNotOfferProcessFallback_InDebugSession()
     {
-        // A ProjectResource can, via the generic WithDebugSupport(argsCallback: ...), rewrite its arguments
-        // for debugging (ProjectResource implements IResourceWithArgs). Those args are valid only for IDE
-        // launch, so DCP must NOT advertise a Process fallback that would later run a broken command. This
+        // A ProjectResource can, via the generic WithDebugSupport(entrypointArgsCallback: ...), declare a tool
+        // invocation prefix (ProjectResource implements IResourceWithArgs). That prefix is withheld from Spec.Args
+        // for the IDE, so DCP must NOT advertise a Process fallback that would later run a broken command. This
         // mirrors the guard already applied to plain executables in PreparePlainExecutables.
         var builder = DistributedApplication.CreateBuilder();
         var projectBuilder = builder.AddProject<TestProject>("proj", launchProfileName: null);
 
-        // Replace the default "project" debug support with a custom launch type that also rewrites arguments.
+        // Replace the default "project" debug support with a custom launch type that also owns entrypoint arguments.
         var defaultAnnotation = projectBuilder.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().FirstOrDefault();
         if (defaultAnnotation is not null)
         {
@@ -3691,7 +3691,7 @@ public async Task ProjectResource_WithArgumentRewritingDebugSupport_DoesNotOffer
         projectBuilder.WithDebugSupport(
             mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
             "test",
-            argsCallback: _ => { /* rewrites arguments for debugging */ });
+            entrypointArgsCallback: ctx => ctx.Args.Add("run"));
 
         using var app = builder.Build();
         var model = app.Services.GetRequiredService<DistributedApplicationModel>();
@@ -3715,11 +3715,11 @@ public async Task ProjectResource_WithArgumentRewritingDebugSupport_DoesNotOffer
     }
 
     [Fact]
-    public async Task ProjectResource_WithoutArgumentRewriting_OffersProcessFallback_InDebugSession()
+    public async Task ProjectResource_WithoutEntrypointArguments_OffersProcessFallback_InDebugSession()
     {
-        // The common case: a default AddProject ("project" launch type, no argument rewriting) keeps the
+        // The common case: a default AddProject ("project" launch type, no entrypoint arguments) keeps the
         // Process fallback so an IDE launch rejection can still start the project. Guards against the
-        // RewritesArgumentsForDebugging guard accidentally dropping the fallback for ordinary projects.
+        // entrypoint-argument guard accidentally dropping the fallback for ordinary projects.
         var builder = DistributedApplication.CreateBuilder();
         builder.AddProject<Projects.ServiceA>("proj", launchProfileName: null);
 
@@ -4442,12 +4442,11 @@ public async Task Project_WithTerminal_RunsAsProcess_InDebugSessionWhenDebugSupp
             AssemblyName = typeof(DistributedApplicationTests).Assembly.FullName
         });
 
-        var debugArgsCallbackInvoked = false;
         var resource = builder.AddProject<Projects.ServiceA>("ServiceA").WithTerminal();
         resource.WithDebugSupport(
             mode => new ProjectLaunchConfiguration { ProjectPath = "/test/path", Mode = mode },
             "project",
-            argsCallback: _ => debugArgsCallbackInvoked = true);
+            entrypointArgsCallback: ctx => ctx.Args.Add("entrypoint-arg"));
 
         // Simulate a debug session whose capability list advertises "project" support.
         var configDict = new Dictionary<string, string?>
@@ -4472,7 +4471,9 @@ public async Task Project_WithTerminal_RunsAsProcess_InDebugSessionWhenDebugSupp
 
         var exe = GetCreatedExecutableForResource(kubernetesService, "ServiceA");
         Assert.Equal(ExecutionType.Process, exe.Spec.ExecutionType);
-        Assert.False(debugArgsCallbackInvoked);
+        // Process execution keeps the full command line, so the entrypoint prefix is passed through.
+        Assert.NotNull(exe.Spec.Args);
+        Assert.Contains("entrypoint-arg", exe.Spec.Args);
         Assert.NotNull(exe.Spec.Terminal);
     }
 
@@ -5898,28 +5899,21 @@ static Task<ProjectLaunchConfiguration> CreateProjectLaunchConfiguration(string
     }
 
     [Fact]
-    public async Task PlainExecutable_ExtensionMode_ArgsRewritingDebugSupport_OmitsProcessFallback()
+    public async Task PlainExecutable_ExtensionMode_EntrypointArgsDebugSupport_WithholdsPrefixAndOmitsProcessFallback()
     {
-        // A non-"project" debuggable executable whose WithDebugSupport supplies an argsCallback (e.g. Go/Python,
-        // which strip the process entrypoint so the IDE debugger owns it) is left with Spec.Args holding only the
-        // application arguments. A Process fallback would then run `ExecutablePath <app-args>` — the wrong command —
-        // so no Process fallback must be advertised for it.
+        // A non-"project" debuggable executable that declares entrypoint arguments (e.g. Go/Python, where the IDE
+        // debugger owns the `go run <pkg>` / `python -m <mod>` tool invocation) must not pass the prefix to the
+        // launched program. Because the DCP Executable spec has a single args field, the resulting Spec.Args cannot
+        // also serve a Process fallback, so no fallback is advertised even though the launch type is not "project".
         var builder = DistributedApplication.CreateBuilder();
 
         var debuggableExecutable = new TestExecutableResource("test-working-directory");
         builder.AddResource(debuggableExecutable)
-            .WithArgs("run", "app-arg")
+            .WithArgs("app-arg")
             .WithDebugSupport(
                 mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
                 "test",
-                argsCallback: static ctx =>
-                {
-                    // Mimic Go/Python stripping the process entrypoint token, leaving only the application args.
-                    if (ctx.Args.Count > 0)
-                    {
-                        ctx.Args.RemoveAt(0);
-                    }
-                });
+                entrypointArgsCallback: static ctx => ctx.Args.Add("run"));
 
         var configDict = new Dictionary<string, string?>
         {
@@ -5939,33 +5933,78 @@ public async Task PlainExecutable_ExtensionMode_ArgsRewritingDebugSupport_OmitsP
 
         var exe = GetCreatedExecutableForResource(kubernetesService, "TestExecutable");
         Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
-        // Because the debug support registered an argsCallback (RewritesArgumentsForDebugging), Spec.Args can be
-        // rewritten to an IDE-only shape, so no Process fallback is advertised even though the launch type is not
-        // "project".
+        Assert.Equal(["app-arg"], exe.Spec.Args);
         Assert.Null(exe.Spec.FallbackExecutionTypes);
+
+        // The dashboard still shows the resource's real command line, prefix included. The prefix has no effective
+        // argument index because it is not passed to the launched program.
+        Assert.True(exe.TryGetAnnotationAsObjectList<AppLaunchArgumentAnnotation>(CustomResource.ResourceAppArgsAnnotation, out var displayArgs));
+        Assert.Collection(displayArgs,
+            arg =>
+            {
+                Assert.Equal("run", arg.Argument);
+                Assert.Null(arg.EffectiveArgumentIndex);
+            },
+            arg =>
+            {
+                Assert.Equal("app-arg", arg.Argument);
+                Assert.Equal(0, arg.EffectiveArgumentIndex);
+            });
+    }
+
+    [Fact]
+    public async Task PlainExecutable_ExtensionMode_EmptyEntrypointArgs_OffersProcessFallback()
+    {
+        // Declaring entrypoint arguments does not always produce a prefix — a Python "Executable" entrypoint
+        // contributes nothing, for example. Nothing is withheld from Spec.Args in that case, so the Process
+        // fallback remains usable and must be advertised.
+        var builder = DistributedApplication.CreateBuilder();
+
+        var debuggableExecutable = new TestExecutableResource("test-working-directory");
+        builder.AddResource(debuggableExecutable)
+            .WithArgs("app-arg")
+            .WithDebugSupport(
+                mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
+                "test",
+                entrypointArgsCallback: static _ => { });
+
+        var configDict = new Dictionary<string, string?>
+        {
+            [DcpExecutor.DebugSessionPortVar] = "12345",
+            [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["test"] }),
+            [KnownConfigNames.ExtensionEndpoint] = "http://localhost:1234",
+            [KnownConfigNames.DebugSessionRunMode] = "Debug"
+        };
+        var configuration = new ConfigurationBuilder().AddInMemoryCollection(configDict).Build();
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService, configuration: configuration);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetesService, "TestExecutable");
+        Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
+        Assert.Equal(["app-arg"], exe.Spec.Args);
+        Assert.NotNull(exe.Spec.FallbackExecutionTypes);
+        Assert.Equal(ExecutionType.Process, Assert.Single(exe.Spec.FallbackExecutionTypes));
     }
 
     [Fact]
-    public async Task PlainExecutable_ExtensionMode_ArgsRewritingDebugSupport_LaunchConfigFailure_FailsWithoutProcessFallback()
+    public async Task PlainExecutable_ExtensionMode_EntrypointArgsDebugSupport_LaunchConfigFailure_FallsBackWithFullCommandLine()
     {
-        // When the launch configuration producer throws for an args-rewriting debug resource, Spec.Args has already
-        // had its entrypoint stripped for the IDE, so a Process fallback would launch a broken command. The failure
-        // must propagate (the resource fails to start) instead of silently falling back to Process execution.
+        // When the launch configuration producer throws, the resource switches to Process execution before its
+        // command line is composed, so the entrypoint prefix is emitted and the fallback runs the real command.
         var builder = DistributedApplication.CreateBuilder();
 
         var resource = new TestExecutableResource("test-working-directory");
         builder.AddResource(resource)
-            .WithArgs("run", "app-arg")
+            .WithArgs("app-arg")
             .WithDebugSupport(
                 ThrowingLaunchConfiguration,
                 "test",
-                argsCallback: static ctx =>
-                {
-                    if (ctx.Args.Count > 0)
-                    {
-                        ctx.Args.RemoveAt(0);
-                    }
-                });
+                entrypointArgsCallback: static ctx => ctx.Args.Add("run"));
 
         var configDict = new Dictionary<string, string?>
         {
@@ -5990,8 +6029,11 @@ public async Task PlainExecutable_ExtensionMode_ArgsRewritingDebugSupport_Launch
 
         await appExecutor.RunApplicationAsync();
 
-        Assert.Empty(kubernetesService.CreatedResources.OfType<Executable>());
-        Assert.Same(resource, Assert.Single(failedResources));
+        Assert.Empty(failedResources);
+
+        var exe = GetCreatedExecutableForResource(kubernetesService, "TestExecutable");
+        Assert.Equal(ExecutionType.Process, exe.Spec.ExecutionType);
+        Assert.Equal(["run", "app-arg"], exe.Spec.Args);
 
         static Task<ExecutableLaunchConfiguration> ThrowingLaunchConfiguration(string mode, CancellationToken cancellationToken)
         {
diff --git a/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs b/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs
index 602c75bfb42..7c2f8413b57 100644
--- a/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs
+++ b/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs
@@ -165,11 +165,32 @@ public void WithDebugSupportRejectsAValueTaskReturningSynchronousProducer()
     }
 
     [Fact]
-    public async Task WithDebugSupportArgsCallbackRunsWhenItsAnnotationIsActive()
+    public async Task WithDebugSupportEntrypointArgsLeadTheCommandLine()
     {
-        // A single WithDebugSupport call whose annotation is active (last) must run its
-        // argument-rewriting callback. This verifies the normal single-integration path
-        // independently of the multiple-annotation behavior below.
+        // The entrypoint arguments are the tool-invocation prefix, so they always come first and the program's own
+        // arguments follow, regardless of the launch configuration in effect.
+        using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
+
+        var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
+            .WithArgs("base-arg")
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("entrypoint-arg"));
+
+        var args = await ArgumentEvaluator.GetArgumentListAsync(executable.Resource);
+
+        Assert.Collection(args,
+            arg => Assert.Equal("entrypoint-arg", arg),
+            arg => Assert.Equal("base-arg", arg));
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task WithDebugSupportEntrypointArgsAreOrderIndependent(bool debugSupportFirst)
+    {
+        // Regression coverage for https://github.com/microsoft/aspire/issues/18929: the entrypoint arguments used to
+        // be applied by an ordinary WithArgs callback that *removed* the prefix, which only worked when
+        // WithDebugSupport happened to be called after the callback that added it. Declaring the prefix instead of
+        // subtracting it must produce the same command line either way.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
         builder.Configuration["DEBUG_SESSION_PORT"] = "5678";
@@ -179,78 +200,107 @@ public async Task WithDebugSupportArgsCallbackRunsWhenItsAnnotationIsActive()
             SupportedLaunchConfigurations = ["go"]
         });
 
+        var executable = builder.AddExecutable("myexe", "command", "workingdirectory");
+
+        if (debugSupportFirst)
+        {
+            executable
+                .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("run"))
+                .WithArgs("base-arg");
+        }
+        else
+        {
+            executable
+                .WithArgs("base-arg")
+                .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("run"));
+        }
+
+        var args = await ArgumentEvaluator.GetArgumentListAsync(executable.Resource);
+
+        Assert.Collection(args,
+            arg => Assert.Equal("run", arg),
+            arg => Assert.Equal("base-arg", arg));
+    }
+
+    [Fact]
+    public async Task WithDebugSupportEntrypointArgsSurviveAnArgsCallbackThatClearsTheList()
+    {
+        // No WithArgs callback can observe or clear the entrypoint prefix: it is evaluated separately and inserted
+        // ahead of the arguments those callbacks produce.
+        using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
+
         var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
-            .WithArgs("base-arg")
-            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("rewritten-arg"));
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("entrypoint-arg"))
+            .WithArgs("discarded")
+            .WithArgs(ctx =>
+            {
+                ctx.Args.Clear();
+                ctx.Args.Add("only-arg");
+            });
 
         var args = await ArgumentEvaluator.GetArgumentListAsync(executable.Resource);
 
         Assert.Collection(args,
-            arg => Assert.Equal("base-arg", arg),
-            arg => Assert.Equal("rewritten-arg", arg));
+            arg => Assert.Equal("entrypoint-arg", arg),
+            arg => Assert.Equal("only-arg", arg));
     }
 
     [Fact]
-    public async Task WithDebugSupportArgsCallbackDoesNotRunWhenLaterDebugSupportSupersedesIt()
+    public async Task WithDebugSupportEntrypointArgsRemainInTheAppModelDuringADebugSession()
     {
-        // WithDebugSupport is append-only and SupportsDebugging() only consults the LAST
-        // SupportsDebuggingAnnotation. A resource can gain debug support from more than one caller: e.g. a
-        // Go/Python integration that rewrites the entrypoint args (rewritesArgumentsForDebugging: true),
-        // followed by a second WithDebugSupport that does not. Once the later annotation supersedes the
-        // first, the first call's arg-rewriting callback must NOT fire; otherwise it would strip/append
-        // args while the active annotation reports RewritesArgumentsForDebugging == false and
-        // ExecutableCreator would offer a Process fallback built from the mangled arguments.
+        // Withholding the prefix is a DCP-level concern. The application model must keep describing the real
+        // command line so the dashboard, the manifest and GetArgumentValuesAsync() consumers stay accurate.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
         builder.Configuration["DEBUG_SESSION_PORT"] = "5678";
         builder.Configuration["DEBUG_SESSION_INFO"] = JsonSerializer.Serialize(new RunSessionInfo
         {
             ProtocolsSupported = ["test"],
-            SupportedLaunchConfigurations = ["go", "project"]
+            SupportedLaunchConfigurations = ["go"]
         });
 
         var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
             .WithArgs("base-arg")
-            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("rewritten-arg"))
-            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("project"), "project");
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("run"));
 
         var args = await ArgumentEvaluator.GetArgumentListAsync(executable.Resource);
 
         Assert.Collection(args,
+            arg => Assert.Equal("run", arg),
             arg => Assert.Equal("base-arg", arg));
     }
 
     [Fact]
-    public void WithDebugSupportReportsRewritesArgumentsWhenResourceSupportsArgs()
+    public void WithDebugSupportRegistersEntrypointArgsForItsLaunchConfigurationType()
     {
-        // A resource that carries command-line arguments (IResourceWithArgs) actually gets the
-        // arg-rewriting callback attached, so the annotation must advertise that it rewrites args.
+        // The entrypoint is owned by the launch configuration type it was declared with, so a launch configuration
+        // of a different type does not claim it.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
         var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
-            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("rewritten-arg"));
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("run"))
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("project"), "project");
 
-        var annotation = executable.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().Single();
-        Assert.True(annotation.RewritesArgumentsForDebugging);
+        var annotations = executable.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().ToList();
+        Assert.Collection(annotations,
+            annotation => Assert.True(executable.Resource.OwnsEntrypointArguments(annotation)),
+            annotation => Assert.False(executable.Resource.OwnsEntrypointArguments(annotation)));
     }
 
     [Fact]
-    public void WithDebugSupportDoesNotReportRewritesArgumentsWhenResourceHasNoArgs()
+    public void WithDebugSupportDoesNotRegisterEntrypointArgsWhenResourceHasNoArgs()
     {
-        // If a caller supplies an argsCallback for a resource that is not IResourceWithArgs, the callback
-        // is never registered and the arguments are left unchanged. The annotation must therefore report
-        // RewritesArgumentsForDebugging == false so ExecutableCreator still offers the Process fallbacks.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
         var resource = builder.AddResource(new DebuggableResourceWithoutArgs("noargs"))
-            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("rewritten-arg"));
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("run"));
 
         var annotation = resource.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().Single();
-        Assert.False(annotation.RewritesArgumentsForDebugging);
+        Assert.False(resource.Resource.OwnsEntrypointArguments(annotation));
     }
 
     [Fact]
-    public void WithDebugSupportDoesNotReportRewritesArgumentsWhenNoArgsCallbackProvided()
+    public void WithDebugSupportDoesNotRegisterEntrypointArgsWhenNoCallbackProvided()
     {
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
@@ -258,7 +308,47 @@ public void WithDebugSupportDoesNotReportRewritesArgumentsWhenNoArgsCallbackProv
             .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go");
 
         var annotation = executable.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().Single();
-        Assert.False(annotation.RewritesArgumentsForDebugging);
+        Assert.False(executable.Resource.OwnsEntrypointArguments(annotation));
+    }
+
+    [Fact]
+    public async Task WithDebugSupportRegistersEntrypointArgsInPublishMode()
+    {
+        // Debug support is run-mode only, but the entrypoint describes how the resource is invoked in general and
+        // must survive into the manifest and generated container images.
+        using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Publish);
+
+        var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
+            .WithArgs("base-arg")
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("run"));
+
+        Assert.Empty(executable.Resource.Annotations.OfType<SupportsDebuggingAnnotation>());
+
+        var args = await ArgumentEvaluator.GetArgumentListAsync(executable.Resource);
+
+        Assert.Collection(args,
+            arg => Assert.Equal("run", arg),
+            arg => Assert.Equal("base-arg", arg));
+    }
+
+    [Fact]
+    public async Task WithDebugSupportEntrypointArgsAreNotCarriedIntoAPublishedContainer()
+    {
+        // PublishAsDockerFile reuses the executable's annotations for the generated container resource, but a
+        // container invokes the program through the image's ENTRYPOINT, so repeating the tool prefix in the
+        // container's arguments would run the wrong command.
+        using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Publish);
+
+        builder.AddExecutable("myexe", "command", "workingdirectory")
+            .WithArgs("base-arg")
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("run"))
+            .PublishAsDockerFile();
+
+        var container = Assert.Single(builder.Resources.OfType<ContainerResource>());
+
+        var args = await ArgumentEvaluator.GetArgumentListAsync(container);
+
+        Assert.Empty(args);
     }
 
     private sealed class DebuggableResourceWithoutArgs(string name) : Resource(name);

From e7f5750c539465ac62a40979065b8c93664b9eb4 Mon Sep 17 00:00:00 2001
From: Karol Zadora-Przylecki <karolz@microsoft.com>
Date: Tue, 4 Aug 2026 13:26:07 -0700
Subject: [PATCH 02/13] Centralize executable process fallback selection

Derive DCP Process fallback availability once from the final execution type and resolved command line, including restart transitions and project-backed executable safeguards.

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

Copilot-Session: 8c5f7a97-cd57-4236-be32-a6e129b71f88
---
 .../DotnetProjectHostingExtensions.cs         |   7 +-
 src/Aspire.Hosting.Go/GoHostingExtensions.cs  |   4 +-
 .../DebugSupportExtensions.cs                 |   2 +-
 .../EntrypointArgsCallbackAnnotation.cs       |   5 +-
 .../ExecutableLaunchConfiguration.cs          |   4 +-
 .../ExecutionConfigurationGathererContext.cs  |  24 +-
 .../CompatibilitySuppressions.xml             |   7 +
 src/Aspire.Hosting/Dcp/ExecutableCreator.cs   |  91 +++---
 .../ResourceBuilderExtensions.cs              |  21 +-
 .../SupportsDebuggingAnnotation.cs            |   2 +-
 .../DotnetProjectResourceTests.cs             |  34 ++-
 .../Dcp/DcpExecutorTests.cs                   | 285 +++++++++++++++++-
 ...ExecutableResourceBuilderExtensionTests.cs |  61 ++--
 13 files changed, 425 insertions(+), 122 deletions(-)

diff --git a/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs b/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
index 9db14a3de43..a95d264199a 100644
--- a/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
+++ b/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
@@ -132,10 +132,9 @@ public static IResourceBuilder<DotnetProjectResource> AddDotnetProject(this IDis
         //   dotnet run --file <app.cs> --no-cache [--no-build] [--configuration <cfg>] --no-launch-profile
         resource.WithArgs(ctx =>
         {
-            // Mirrors the fallback rule in Dcp/ExecutableCreator: 
-            // a Process fallback is offered for the plain executable UNLESS 
-            // the launch configuration is "project", OR the launch configuration owns the entrypoint arguments. 
-            // For any other active annotation a fallback IS offered and we need to construct the args here.
+            // The active launch configuration supplies the project launch when it is "project" or owns a custom
+            // entrypoint. In those cases adding `dotnet run` would duplicate the tool invocation instead of
+            // contributing the process command.
             if (ctx.Resource.SupportsDebugging(builder.Configuration, out var debugAnnotation)
                 && (debugAnnotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project || ctx.Resource.OwnsEntrypointArguments(debugAnnotation)))
             {
diff --git a/src/Aspire.Hosting.Go/GoHostingExtensions.cs b/src/Aspire.Hosting.Go/GoHostingExtensions.cs
index 1429c85112d..fcd7f49268b 100644
--- a/src/Aspire.Hosting.Go/GoHostingExtensions.cs
+++ b/src/Aspire.Hosting.Go/GoHostingExtensions.cs
@@ -763,8 +763,8 @@ internal static IResourceBuilder<T> WithVSCodeDebugging<T>(this IResourceBuilder
                     BuildFlags = buildFlags.Length > 0 ? buildFlags : null
                 };
             },
-            "go",
-            static ctx =>
+            "go")
+            .WithEntrypointArgs("go", static ctx =>
             {
                 // The executable resource normally starts as:
                 //   go run [-race] [-tags=...] [-ldflags=...] [-gcflags=...] <pkg> [app args]
diff --git a/src/Aspire.Hosting/ApplicationModel/DebugSupportExtensions.cs b/src/Aspire.Hosting/ApplicationModel/DebugSupportExtensions.cs
index 44a2f51b009..a2fe01f618f 100644
--- a/src/Aspire.Hosting/ApplicationModel/DebugSupportExtensions.cs
+++ b/src/Aspire.Hosting/ApplicationModel/DebugSupportExtensions.cs
@@ -100,7 +100,7 @@ public static bool OwnsEntrypointArguments(this IResource resource, SupportsDebu
     /// <remarks>
     /// <para>
     /// Launch configuration is created by invoking the producer callback passed to
-    /// <see cref="ResourceBuilderExtensions.WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, TLaunchConfiguration}, string, Action{CommandLineArgsCallbackContext})"/>
+    /// <see cref="ResourceBuilderExtensions.WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, TLaunchConfiguration}, string)"/>
     /// (or its asynchronous overload),
     /// which owns the complete configuration; Aspire serializes the result as-is. 
     /// The configuration is produced fresh on each call; it is not a singleton.
diff --git a/src/Aspire.Hosting/ApplicationModel/EntrypointArgsCallbackAnnotation.cs b/src/Aspire.Hosting/ApplicationModel/EntrypointArgsCallbackAnnotation.cs
index 445253f47d5..a3311552837 100644
--- a/src/Aspire.Hosting/ApplicationModel/EntrypointArgsCallbackAnnotation.cs
+++ b/src/Aspire.Hosting/ApplicationModel/EntrypointArgsCallbackAnnotation.cs
@@ -94,5 +94,8 @@ private async Task<IList<object>> ExecuteCallbackAsync(CommandLineArgsCallbackCo
 /// <see cref="EntrypointArgsCallbackAnnotation"/>, so that consumers that compose the actual command line
 /// (such as the DCP executable creator) can tell the tool-invocation prefix apart from the program arguments.
 /// </summary>
-/// <param name="Count">The number of leading arguments that form the entrypoint prefix.</param>
+/// <param name="Count">
+/// The number of leading arguments that form the entrypoint prefix. This is normalized after value resolution to
+/// exclude arguments that resolve to <see langword="null"/>.
+/// </param>
 internal sealed record EntrypointArgumentsData(int Count) : IExecutionConfigurationData;
diff --git a/src/Aspire.Hosting/ApplicationModel/ExecutableLaunchConfiguration.cs b/src/Aspire.Hosting/ApplicationModel/ExecutableLaunchConfiguration.cs
index 21b0f95cd08..b1cec8dba26 100644
--- a/src/Aspire.Hosting/ApplicationModel/ExecutableLaunchConfiguration.cs
+++ b/src/Aspire.Hosting/ApplicationModel/ExecutableLaunchConfiguration.cs
@@ -60,7 +60,7 @@ public static class KnownLaunchConfigurationTypes
 /// </para>
 /// <para>
 /// Integrations create a derived type and supply it through
-/// <see cref="ResourceBuilderExtensions.WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, TLaunchConfiguration}, string, Action{CommandLineArgsCallbackContext})"/>
+/// <see cref="ResourceBuilderExtensions.WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, TLaunchConfiguration}, string)"/>
 /// or its asynchronous overload.
 /// </para>
 /// </remarks>
@@ -91,7 +91,7 @@ public class ExecutableLaunchConfiguration(string type)
     /// Defaults to <see cref="ExecutableLaunchMode.Debug"/> when a debugger is attached to the app host
     /// and <see cref="ExecutableLaunchMode.NoDebug"/> otherwise. The mode requested by the IDE for the
     /// current debug session is passed to the producer callback of
-    /// <see cref="ResourceBuilderExtensions.WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, TLaunchConfiguration}, string, Action{CommandLineArgsCallbackContext})"/>.
+    /// <see cref="ResourceBuilderExtensions.WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, TLaunchConfiguration}, string)"/>.
     /// </remarks>
     [JsonPropertyName("mode")]
     public string Mode { get; set; } = System.Diagnostics.Debugger.IsAttached ? ExecutableLaunchMode.Debug : ExecutableLaunchMode.NoDebug;
diff --git a/src/Aspire.Hosting/ApplicationModel/ExecutionConfigurationGathererContext.cs b/src/Aspire.Hosting/ApplicationModel/ExecutionConfigurationGathererContext.cs
index 22cc40f4363..2b2288bf5ba 100644
--- a/src/Aspire.Hosting/ApplicationModel/ExecutionConfigurationGathererContext.cs
+++ b/src/Aspire.Hosting/ApplicationModel/ExecutionConfigurationGathererContext.cs
@@ -44,15 +44,26 @@ internal async Task<IExecutionConfigurationResult> ResolveAsync(
         List<(object Unprocessed, string Value, bool IsSensitive)> resolvedArguments = new(Arguments.Count);
         Dictionary<string, (object Unprocessed, string Value)> resolvedEnvironmentVariables = new(EnvironmentVariables.Count);
         List<Exception> exceptions = new();
+        var entrypointArgumentsData = AdditionalConfigurationData.OfType<EntrypointArgumentsData>().FirstOrDefault();
+        var resolvedEntrypointArgumentCount = 0;
 
-        foreach (var argument in Arguments)
+        for (var argumentIndex = 0; argumentIndex < Arguments.Count; argumentIndex++)
         {
+            var argument = Arguments[argumentIndex];
+
             try
             {
                 var resolvedValue = await resource.ResolveValueAsync(executionContext, resourceLogger, argument, null, cancellationToken).ConfigureAwait(false);
                 if (resolvedValue?.Value != null)
                 {
                     resolvedArguments.Add((argument, resolvedValue.Value, resolvedValue.IsSensitive));
+                    if (entrypointArgumentsData is not null && argumentIndex < entrypointArgumentsData.Count)
+                    {
+                        // Resolution drops null values. Count only entrypoint values that survived so a missing prefix
+                        // value cannot make consumers treat the first ordinary argument as part of the prefix.
+                        resolvedEntrypointArgumentCount++;
+                    }
+
                     if (argument is IValueProvider or IManifestExpressionProvider)
                     {
                         references.Add(argument);
@@ -87,12 +98,21 @@ internal async Task<IExecutionConfigurationResult> ResolveAsync(
             }
         }
 
+        var resolvedAdditionalConfigurationData = AdditionalConfigurationData;
+        if (entrypointArgumentsData is not null && entrypointArgumentsData.Count != resolvedEntrypointArgumentCount)
+        {
+            resolvedAdditionalConfigurationData = AdditionalConfigurationData
+                .Where(data => data is not EntrypointArgumentsData)
+                .ToHashSet();
+            resolvedAdditionalConfigurationData.Add(new EntrypointArgumentsData(resolvedEntrypointArgumentCount));
+        }
+
         return new ExecutionConfigurationResult
         {
             References = references,
             ArgumentsWithUnprocessed = resolvedArguments,
             EnvironmentVariablesWithUnprocessed = resolvedEnvironmentVariables,
-            AdditionalConfigurationData = AdditionalConfigurationData,
+            AdditionalConfigurationData = resolvedAdditionalConfigurationData,
             Exception = exceptions.Count == 0 ? null : new AggregateException("One or more errors occurred while resolving resource configuration.", exceptions)
         };
     }
diff --git a/src/Aspire.Hosting/CompatibilitySuppressions.xml b/src/Aspire.Hosting/CompatibilitySuppressions.xml
index bd08efb4a92..a604bf888db 100644
--- a/src/Aspire.Hosting/CompatibilitySuppressions.xml
+++ b/src/Aspire.Hosting/CompatibilitySuppressions.xml
@@ -1,6 +1,13 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!-- https://learn.microsoft.com/dotnet/fundamentals/package-validation/diagnostic-ids -->
 <Suppressions xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+  <Suppression>
+    <DiagnosticId>CP0002</DiagnosticId>
+    <Target>M:Aspire.Hosting.ResourceBuilderExtensions.WithDebugSupport``2(Aspire.Hosting.ApplicationModel.IResourceBuilder{``0},System.Func{System.String,``1},System.String,System.Action{Aspire.Hosting.ApplicationModel.CommandLineArgsCallbackContext})</Target>
+    <Left>lib/net8.0/Aspire.Hosting.dll</Left>
+    <Right>lib/net8.0/Aspire.Hosting.dll</Right>
+    <IsBaselineSuppression>true</IsBaselineSuppression>
+  </Suppression>
   <Suppression>
     <DiagnosticId>CP0006</DiagnosticId>
     <Target>M:Aspire.Hosting.IInteractionService.PromptProgressAsync(System.String,System.String,Aspire.Hosting.ProgressInteractionOptions,System.Threading.CancellationToken)</Target>
diff --git a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
index 97e0edf1258..ebd84d9eba2 100644
--- a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
+++ b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
@@ -102,10 +102,11 @@ public async Task CreateObjectAsync(RenderedModelResource<Executable> er, EmptyC
         // The launch configuration is applied before the command line is composed because applying it can switch the
         // execution type to Process, and the composition depends on the final execution type: an IDE-launched
         // resource does not receive its entrypoint arguments, a process-launched one does.
-        await ApplyLaunchConfigurationAsync(er, exe, cancellationToken).ConfigureAwait(false);
+        var resolvedEntrypointArgumentCount = configuration.AdditionalConfigurationData.OfType<EntrypointArgumentsData>().FirstOrDefault()?.Count ?? 0;
+        await ApplyLaunchConfigurationAsync(er, exe, resolvedEntrypointArgumentCount, cancellationToken).ConfigureAwait(false);
 
         var omittedEntrypointArgumentCount = OmitEntrypointArguments(er, spec)
-            ? configuration.AdditionalConfigurationData.OfType<EntrypointArgumentsData>().FirstOrDefault()?.Count ?? 0
+            ? resolvedEntrypointArgumentCount
             : 0;
 
         var executableArgumentStartIndex = spec.Args?.Count ?? 0;
@@ -124,18 +125,11 @@ public async Task CreateObjectAsync(RenderedModelResource<Executable> er, EmptyC
         // Arg annotations are what is displayed in the dashboard.
         er.DcpResource.SetAnnotationAsObjectList(CustomResource.ResourceAppArgsAnnotation, displayArgs.Select(a => new AppLaunchArgumentAnnotation(a.Value, isSensitive: a.IsSensitive, effectiveArgumentIndex: a.EffectiveArgumentIndex)));
 
-        // PrepareObjects() had to decide on the DCP-level Process fallback before any argument callback had run,
-        // so it conservatively withheld the fallback from every resource that declares entrypoint arguments.
-        // Now that the arguments are known, restore it when nothing was actually withheld from Spec.Args
-        // (for example a Python "Executable" entrypoint contributes no prefix at all).
-        if (spec.ExecutionType == ExecutionType.IDE
-            && er.ModelResource.SupportsDebugging(_configuration, out var debuggingAnnotation)
-            && er.ModelResource.OwnsEntrypointArguments(debuggingAnnotation))
-        {
-            spec.FallbackExecutionTypes = ShouldOfferProcessFallback(er.ModelResource, debuggingAnnotation, entrypointArgumentsOmitted: omittedEntrypointArgumentCount > 0)
-                ? [ExecutionType.Process]
-                : null;
-        }
+        // Argument and launch-configuration callbacks can change on restart. Derive fallback availability from the
+        // final execution type and resolved command line every time instead of carrying a preparation-time guess.
+        spec.FallbackExecutionTypes = ShouldOfferProcessFallback(er.ModelResource, spec, omittedEntrypointArgumentCount)
+            ? [ExecutionType.Process]
+            : null;
 
         spec.Env = configuration.EnvironmentVariables.Select(kvp => new EnvVar { Name = kvp.Key, Value = kvp.Value }).ToList();
 
@@ -194,9 +188,10 @@ public async Task CreateObjectAsync(RenderedModelResource<Executable> er, EmptyC
     /// executables, so their "project" launch configuration is applied here for IDE/F5 parity with <c>AddProject</c>.
     /// All other types (plain executables and project subtypes like azure-functions) are also handled here.
     /// </remarks>
-    private async Task ApplyLaunchConfigurationAsync(RenderedModelResource<Executable> er, Executable exe, CancellationToken cancellationToken)
+    private async Task ApplyLaunchConfigurationAsync(RenderedModelResource<Executable> er, Executable exe, int resolvedEntrypointArgumentCount, CancellationToken cancellationToken)
     {
         if (er.ModelResource.HasAnnotationOfType<ForceProcessExecutionAnnotation>()
+            || HasProjectLaunchArgsOverride(er.ModelResource)
             || !er.ModelResource.SupportsDebugging(_configuration, out var supportsDebuggingAnnotation))
         {
             return;
@@ -225,6 +220,9 @@ private async Task ApplyLaunchConfigurationAsync(RenderedModelResource<Executabl
         }
 
         // We have non-project Executable that supports debugging; need to annotate it properly.
+        // A previous launch-configuration failure can leave the reusable spec in Process mode. Restore the prepared
+        // IDE mode before each attempt so a successful restart does not inherit that transient fallback.
+        exe.Spec.ExecutionType = ExecutionType.IDE;
         var mode = _configuration[KnownConfigNames.DebugSessionRunMode] ?? ExecutableLaunchMode.NoDebug;
         try
         {
@@ -234,8 +232,15 @@ private async Task ApplyLaunchConfigurationAsync(RenderedModelResource<Executabl
         }
         catch (Exception ex)
         {
-            // Falling back here is safe even for resources with entrypoint arguments: the command line is composed
-            // after this point, so switching to Process execution now means the full command line is emitted.
+            if (HasIncompleteProcessCommand(er.ModelResource, supportsDebuggingAnnotation, resolvedEntrypointArgumentCount))
+            {
+                // This project-backed executable suppressed its process scaffold because the custom launch
+                // configuration owns the entrypoint. With no resolved entrypoint to replace it, Process execution
+                // would run a bare tool command such as `dotnet <app-args>`.
+                throw;
+            }
+
+            // The command line is composed after this point, so Process execution receives the full entrypoint.
             _logger.LogWarning(ex, "Failed to apply launch configuration for resource '{ResourceName}'. Falling back to process execution.", er.ModelResource.Name);
             exe.Spec.ExecutionType = ExecutionType.Process;
         }
@@ -268,16 +273,36 @@ private bool OmitEntrypointArguments(RenderedModelResource<Executable> er, Execu
     /// both the IDE form and the process form of the command line: when the entrypoint prefix is omitted for the
     /// IDE, no fallback can be offered.
     /// </remarks>
-    private static bool ShouldOfferProcessFallback(IResource modelResource, SupportsDebuggingAnnotation annotation, bool entrypointArgumentsOmitted)
+    private bool ShouldOfferProcessFallback(IResource modelResource, ExecutableSpec spec, int omittedEntrypointArgumentCount)
     {
-        if (entrypointArgumentsOmitted)
+        if (spec.ExecutionType != ExecutionType.IDE || omittedEntrypointArgumentCount > 0)
         {
             return false;
         }
 
-        // A ProjectResource always carries a runnable `dotnet run ...` command in its project args. A plain
-        // executable with a "project" launch configuration does not — those args come from the IDE.
-        return modelResource is ProjectResource || annotation.LaunchConfigurationType is not "project";
+        if (modelResource is ProjectResource)
+        {
+            return true;
+        }
+
+        if (!modelResource.SupportsDebugging(_configuration, out var annotation)
+            || annotation.LaunchConfigurationType is "project")
+        {
+            return false;
+        }
+
+        // A project-backed plain executable suppresses its `dotnet run` process scaffold when the active launch
+        // configuration owns the entrypoint. Even when that entrypoint resolves empty, the remaining command line
+        // is IDE-only and cannot be reused as a Process fallback.
+        return !HasIncompleteProcessCommand(modelResource, annotation, omittedEntrypointArgumentCount);
+    }
+
+    private static bool HasIncompleteProcessCommand(IResource modelResource, SupportsDebuggingAnnotation annotation, int entrypointArgumentCount)
+    {
+        return entrypointArgumentCount == 0
+            && modelResource is not ProjectResource
+            && modelResource.HasAnnotationOfType<IProjectMetadata>()
+            && modelResource.OwnsEntrypointArguments(annotation);
     }
 
     private async Task PrepareProjectExecutablesAsync(CancellationToken cancellationToken)
@@ -351,16 +376,6 @@ private async Task PrepareProjectExecutablesAsync(CancellationToken cancellation
                 {
                     exe.Spec.ExecutionType = ExecutionType.IDE;
 
-                    // A Process fallback runs the DCP Executable Spec's command and args "as is". A resource that
-                    // declares entrypoint arguments may have them withheld from Spec.Args for the IDE, which would
-                    // leave a Process fallback running a broken command. The arguments are not evaluated yet here,
-                    // so omit the fallback conservatively; CreateObjectAsync() will add it if the entrypoint arguments
-                    // are not used.
-                    if (ShouldOfferProcessFallback(project, supportsDebuggingAnnotation, entrypointArgumentsOmitted: project.OwnsEntrypointArguments(supportsDebuggingAnnotation)))
-                    {
-                        exe.Spec.FallbackExecutionTypes = [ExecutionType.Process];
-                    }
-
                     if (supportsDebuggingAnnotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project)
                     {
                         // We want this annotation even if we are not using IDE execution; see ToSnapshot() for details.
@@ -405,7 +420,6 @@ private async Task PrepareProjectExecutablesAsync(CancellationToken cancellation
                     //    must preserve their process launch args unless an IDE explicitly advertises
                     //    support for their custom launch type.
                     exe.Spec.ExecutionType = ExecutionType.IDE;
-                    exe.Spec.FallbackExecutionTypes = [ExecutionType.Process];
 
                     await ApplyProjectLaunchConfigurationAsync(exe, project, projectMetadata, supportsDebuggingAnnotation: null, cancellationToken).ConfigureAwait(false);
                 }
@@ -513,20 +527,11 @@ private void PreparePlainExecutables()
 
             if (!persistent
                 && !executable.HasAnnotationOfType<ForceProcessExecutionAnnotation>()
-                && executable.SupportsDebugging(_configuration, out var supportsDebuggingAnnotation))
+                && executable.SupportsDebugging(_configuration, out _))
             {
                 // Just mark as IDE execution here - the actual launch configuration callback
                 // will be invoked in CreateExecutableAsync after endpoints are allocated.
                 exe.Spec.ExecutionType = ExecutionType.IDE;
-
-                // A Process fallback is only meaningful when the fallback can actually launch the resource, i.e. when
-                // the DCP Executable Spec has "real" command and args that can be executed "as is". The arguments are
-                // not evaluated yet here, so a resource that declares entrypoint arguments conservatively forgoes the
-                // fallback; CreateObjectAsync() will add it when it determines that entrypoint arguments are not used.
-                if (ShouldOfferProcessFallback(executable, supportsDebuggingAnnotation, entrypointArgumentsOmitted: executable.OwnsEntrypointArguments(supportsDebuggingAnnotation)))
-                {
-                    exe.Spec.FallbackExecutionTypes = [ExecutionType.Process];
-                }
             }
             else
             {
diff --git a/src/Aspire.Hosting/ResourceBuilderExtensions.cs b/src/Aspire.Hosting/ResourceBuilderExtensions.cs
index a4074137eb3..5eb37d9772a 100644
--- a/src/Aspire.Hosting/ResourceBuilderExtensions.cs
+++ b/src/Aspire.Hosting/ResourceBuilderExtensions.cs
@@ -4815,23 +4815,22 @@ public static IResourceBuilder<T> WithEntrypointArgs<T>(this IResourceBuilder<T>
     /// <param name="builder">The resource builder.</param>
     /// <param name="launchConfigurationProducer">Launch configuration producer for the resource. It is passed the launch mode (one of the values on <see cref="ExecutableLaunchMode"/>) and produces the configuration that is handed to the IDE.</param>
     /// <param name="launchConfigurationType">The type tag of the launch configuration (as sent to the IDE).</param>
-    /// <param name="entrypointArgsCallback">Optional callback that produces the resource's entrypoint arguments.</param>
     /// <returns>The <see cref="IResourceBuilder{T}"/>.</returns>
     /// <exception cref="ArgumentException">
     /// <typeparamref name="TLaunchConfiguration"/> is a <see cref="Task"/> or <see cref="ValueTask"/>, which means an
     /// asynchronous producer was written without the <see cref="CancellationToken"/> parameter and bound to this
-    /// overload. Use <see cref="WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, CancellationToken, Task{TLaunchConfiguration}}, string, Action{CommandLineArgsCallbackContext})"/> instead.
+    /// overload. Use <see cref="WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, CancellationToken, Task{TLaunchConfiguration}}, string)"/> instead.
     /// </exception>
     /// <remarks>
     /// Aspire invokes the launch configuration producer while preparing and creating the underlying orchestrator objects, and may invoke it
     /// several times for the same resource. Use
-    /// <see cref="WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, CancellationToken, Task{TLaunchConfiguration}}, string, Action{CommandLineArgsCallbackContext})"/>
+    /// <see cref="WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, CancellationToken, Task{TLaunchConfiguration}}, string)"/>
     /// when the configuration has to be resolved from work that is itself asynchronous, for example in the presence of 
     /// build-argument callbacks contributed by other annotations.
     /// </remarks>
     [Experimental("ASPIREEXTENSION001", UrlFormat = "https://aka.ms/aspire/diagnostics/{0}")]
     [AspireExportIgnore(Reason = "Generic debug launch configuration support is not part of the ATS surface.")]
-    public static IResourceBuilder<T> WithDebugSupport<T, TLaunchConfiguration>(this IResourceBuilder<T> builder, Func<string, TLaunchConfiguration> launchConfigurationProducer, string launchConfigurationType, Action<CommandLineArgsCallbackContext>? entrypointArgsCallback = null)
+    public static IResourceBuilder<T> WithDebugSupport<T, TLaunchConfiguration>(this IResourceBuilder<T> builder, Func<string, TLaunchConfiguration> launchConfigurationProducer, string launchConfigurationType)
         where T : IResource
     {
         ArgumentNullException.ThrowIfNull(builder);
@@ -4845,7 +4844,7 @@ public static IResourceBuilder<T> WithDebugSupport<T, TLaunchConfiguration>(this
                 nameof(launchConfigurationProducer));
         }
 
-        return builder.WithDebugSupport((mode, _) => Task.FromResult(launchConfigurationProducer(mode)), launchConfigurationType, entrypointArgsCallback);
+        return builder.WithDebugSupport((mode, _) => Task.FromResult(launchConfigurationProducer(mode)), launchConfigurationType);
 
         static bool IsValueTask(Type type)
             => type == typeof(ValueTask) || (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ValueTask<>));
@@ -4860,31 +4859,23 @@ static bool IsValueTask(Type type)
     /// <param name="builder">The resource builder.</param>
     /// <param name="launchConfigurationProducer">Launch configuration producer for the resource. It is passed the launch mode (one of the values on <see cref="ExecutableLaunchMode"/>) and produces the configuration that is handed to the IDE.</param>
     /// <param name="launchConfigurationType">The type of the resource.</param>
-    /// <param name="entrypointArgsCallback">Optional callback that produces the resource's entrypoint arguments.</param>
     /// <returns>The <see cref="IResourceBuilder{T}"/>.</returns>
     /// <remarks>
     /// Use this overload when the launch configuration has to be resolved from work that is itself asynchronous, for
     /// example in the presence of build-argument callbacks contributed by other annotations. Aspire invokes the producer while preparing
     /// and creating the underlying orchestrator objects, and may invoke it several times for the same resource. 
     /// A producer that computes everything synchronously should use
-    /// <see cref="WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, TLaunchConfiguration}, string, Action{CommandLineArgsCallbackContext})"/>
+    /// <see cref="WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, TLaunchConfiguration}, string)"/>
     /// instead.
     /// </remarks>
     [Experimental("ASPIREEXTENSION001", UrlFormat = "https://aka.ms/aspire/diagnostics/{0}")]
     [AspireExportIgnore(Reason = "Generic debug launch configuration support is not part of the ATS surface.")]
-    public static IResourceBuilder<T> WithDebugSupport<T, TLaunchConfiguration>(this IResourceBuilder<T> builder, Func<string, CancellationToken, Task<TLaunchConfiguration>> launchConfigurationProducer, string launchConfigurationType, Action<CommandLineArgsCallbackContext>? entrypointArgsCallback = null)
+    public static IResourceBuilder<T> WithDebugSupport<T, TLaunchConfiguration>(this IResourceBuilder<T> builder, Func<string, CancellationToken, Task<TLaunchConfiguration>> launchConfigurationProducer, string launchConfigurationType)
         where T : IResource
     {
         ArgumentNullException.ThrowIfNull(builder);
         ArgumentNullException.ThrowIfNull(launchConfigurationProducer);
 
-        // Entrypoint arguments describe how the resource is invoked in general, so unlike debug support itself they
-        // are registered in publish mode too, where they end up in the manifest and in generated container images.
-        if (entrypointArgsCallback is not null && builder is IResourceBuilder<IResourceWithArgs> resourceWithArgs)
-        {
-            resourceWithArgs.WithEntrypointArgs(launchConfigurationType, entrypointArgsCallback);
-        }
-
         if (!builder.ApplicationBuilder.ExecutionContext.IsRunMode)
         {
             return builder;
diff --git a/src/Aspire.Hosting/SupportsDebuggingAnnotation.cs b/src/Aspire.Hosting/SupportsDebuggingAnnotation.cs
index b6bde7d597a..0363b909898 100644
--- a/src/Aspire.Hosting/SupportsDebuggingAnnotation.cs
+++ b/src/Aspire.Hosting/SupportsDebuggingAnnotation.cs
@@ -12,7 +12,7 @@ namespace Aspire.Hosting.ApplicationModel;
 /// instead of being started as a plain process by Aspire.
 /// </summary>
 /// <remarks>
-/// Added by <see cref="ResourceBuilderExtensions.WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, TLaunchConfiguration}, string, Action{CommandLineArgsCallbackContext})"/>
+/// Added by <see cref="ResourceBuilderExtensions.WithDebugSupport{T, TLaunchConfiguration}(IResourceBuilder{T}, Func{string, TLaunchConfiguration}, string)"/>
 /// (or its asynchronous overload). The
 /// annotation is only honored while a debug session is active; use
 /// <see cref="DebugSupportExtensions.SupportsDebugging"/> to test for that, and
diff --git a/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs b/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
index 2bbb1c911e5..7ff67808987 100644
--- a/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
+++ b/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
@@ -340,7 +340,7 @@ public async Task AddDotnetProject_InDebugSession_KeepsDotnetRunArgs_WhenActiveC
     [Fact]
     public async Task AddDotnetProject_InDebugSession_OmitsDotnetRunScaffolding_WhenActiveCustomDebugSupportOwnsEntrypointArgs()
     {
-        // A stacked custom WithDebugSupport that declares entrypoint arguments owns the tool invocation, so no
+        // A stacked custom debug configuration with entrypoint arguments owns the tool invocation, so no
         // Process fallback is offered and Spec.Args is composed from that entrypoint plus the program arguments.
         // The `dotnet run …` scaffolding must be omitted; re-emitting it would duplicate the tool invocation.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
@@ -355,7 +355,8 @@ public async Task AddDotnetProject_InDebugSession_OmitsDotnetRunScaffolding_When
         var projectPath = Path.Combine(builder.AppHostDirectory, "MyService", "MyService.csproj");
         var app = builder.AddDotnetProject("svc", projectPath, o => o.ExcludeLaunchProfile = true)
                          .WithArgs("--config", "prod.yaml")
-                         .WithDebugSupport(_ => new ExecutableLaunchConfiguration("custom"), "custom", ctx => ctx.Args.Add("entrypoint-arg"));
+                         .WithEntrypointArgs("custom", ctx => ctx.Args.Add("entrypoint-arg"))
+                         .WithDebugSupport(_ => new ExecutableLaunchConfiguration("custom"), "custom");
 
         using var application = builder.Build();
         var args = await ArgumentEvaluator.GetArgumentListAsync(app.Resource, application.Services);
@@ -367,6 +368,35 @@ public async Task AddDotnetProject_InDebugSession_OmitsDotnetRunScaffolding_When
             arg => Assert.Equal("prod.yaml", arg));
     }
 
+    [Fact]
+    public async Task AddDotnetProject_InDebugSession_OmitsDotnetRunScaffolding_WhenOwnedEntrypointIsEmpty()
+    {
+        // Entrypoint ownership, rather than the number of values it produces, determines who supplies the project
+        // launch. A no-op custom entrypoint must still suppress `dotnet run`; DCP consequently cannot offer this
+        // IDE-only command line as a Process fallback.
+        using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
+
+        builder.Configuration["DEBUG_SESSION_PORT"] = "5678";
+        builder.Configuration["DEBUG_SESSION_INFO"] = JsonSerializer.Serialize(new RunSessionInfo
+        {
+            ProtocolsSupported = ["test"],
+            SupportedLaunchConfigurations = ["custom"]
+        });
+
+        var projectPath = Path.Combine(builder.AppHostDirectory, "MyService", "MyService.csproj");
+        var app = builder.AddDotnetProject("svc", projectPath, o => o.ExcludeLaunchProfile = true)
+                         .WithArgs("--config", "prod.yaml")
+                         .WithEntrypointArgs("custom", static _ => { })
+                         .WithDebugSupport(_ => new ExecutableLaunchConfiguration("custom"), "custom");
+
+        using var application = builder.Build();
+        var args = await ArgumentEvaluator.GetArgumentListAsync(app.Resource, application.Services);
+
+        Assert.Collection(args,
+            arg => Assert.Equal("--config", arg),
+            arg => Assert.Equal("prod.yaml", arg));
+    }
+
     [Theory]
     [InlineData(PersistenceMode.Persistent)]
     [InlineData(PersistenceMode.ParentProcess)]
diff --git a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
index 5d3b1af2347..f9b18b0ec58 100644
--- a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
+++ b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
@@ -3674,7 +3674,7 @@ public async Task PersistentPlainExecutable_ExtensionMode_RunsInProcess()
     [Fact]
     public async Task ProjectResource_WithEntrypointArgumentsDebugSupport_DoesNotOfferProcessFallback_InDebugSession()
     {
-        // A ProjectResource can, via the generic WithDebugSupport(entrypointArgsCallback: ...), declare a tool
+        // A ProjectResource can, via the generic WithEntrypointArgs API, declare a tool
         // invocation prefix (ProjectResource implements IResourceWithArgs). That prefix is withheld from Spec.Args
         // for the IDE, so DCP must NOT advertise a Process fallback that would later run a broken command. This
         // mirrors the guard already applied to plain executables in PreparePlainExecutables.
@@ -3688,10 +3688,11 @@ public async Task ProjectResource_WithEntrypointArgumentsDebugSupport_DoesNotOff
             projectBuilder.Resource.Annotations.Remove(defaultAnnotation);
         }
 
-        projectBuilder.WithDebugSupport(
-            mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
-            "test",
-            entrypointArgsCallback: ctx => ctx.Args.Add("run"));
+        projectBuilder
+            .WithEntrypointArgs("test", ctx => ctx.Args.Add("run"))
+            .WithDebugSupport(
+                mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
+                "test");
 
         using var app = builder.Build();
         var model = app.Services.GetRequiredService<DistributedApplicationModel>();
@@ -4443,10 +4444,11 @@ public async Task Project_WithTerminal_RunsAsProcess_InDebugSessionWhenDebugSupp
         });
 
         var resource = builder.AddProject<Projects.ServiceA>("ServiceA").WithTerminal();
-        resource.WithDebugSupport(
-            mode => new ProjectLaunchConfiguration { ProjectPath = "/test/path", Mode = mode },
-            "project",
-            entrypointArgsCallback: ctx => ctx.Args.Add("entrypoint-arg"));
+        resource
+            .WithEntrypointArgs("project", ctx => ctx.Args.Add("entrypoint-arg"))
+            .WithDebugSupport(
+                mode => new ProjectLaunchConfiguration { ProjectPath = "/test/path", Mode = mode },
+                "project");
 
         // Simulate a debug session whose capability list advertises "project" support.
         var configDict = new Dictionary<string, string?>
@@ -5910,10 +5912,10 @@ public async Task PlainExecutable_ExtensionMode_EntrypointArgsDebugSupport_Withh
         var debuggableExecutable = new TestExecutableResource("test-working-directory");
         builder.AddResource(debuggableExecutable)
             .WithArgs("app-arg")
+            .WithEntrypointArgs("test", static ctx => ctx.Args.Add("run"))
             .WithDebugSupport(
                 mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
-                "test",
-                entrypointArgsCallback: static ctx => ctx.Args.Add("run"));
+                "test");
 
         var configDict = new Dictionary<string, string?>
         {
@@ -5963,10 +5965,10 @@ public async Task PlainExecutable_ExtensionMode_EmptyEntrypointArgs_OffersProces
         var debuggableExecutable = new TestExecutableResource("test-working-directory");
         builder.AddResource(debuggableExecutable)
             .WithArgs("app-arg")
+            .WithEntrypointArgs("test", static _ => { })
             .WithDebugSupport(
                 mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
-                "test",
-                entrypointArgsCallback: static _ => { });
+                "test");
 
         var configDict = new Dictionary<string, string?>
         {
@@ -6001,10 +6003,10 @@ public async Task PlainExecutable_ExtensionMode_EntrypointArgsDebugSupport_Launc
         var resource = new TestExecutableResource("test-working-directory");
         builder.AddResource(resource)
             .WithArgs("app-arg")
+            .WithEntrypointArgs("test", static ctx => ctx.Args.Add("run"))
             .WithDebugSupport(
                 ThrowingLaunchConfiguration,
-                "test",
-                entrypointArgsCallback: static ctx => ctx.Args.Add("run"));
+                "test");
 
         var configDict = new Dictionary<string, string?>
         {
@@ -6034,6 +6036,7 @@ public async Task PlainExecutable_ExtensionMode_EntrypointArgsDebugSupport_Launc
         var exe = GetCreatedExecutableForResource(kubernetesService, "TestExecutable");
         Assert.Equal(ExecutionType.Process, exe.Spec.ExecutionType);
         Assert.Equal(["run", "app-arg"], exe.Spec.Args);
+        Assert.Null(exe.Spec.FallbackExecutionTypes);
 
         static Task<ExecutableLaunchConfiguration> ThrowingLaunchConfiguration(string mode, CancellationToken cancellationToken)
         {
@@ -6041,6 +6044,248 @@ static Task<ExecutableLaunchConfiguration> ThrowingLaunchConfiguration(string mo
         }
     }
 
+    [Fact]
+    public async Task PlainExecutable_ExtensionMode_NullEntrypointArgument_DoesNotOmitApplicationArgument()
+    {
+        // Entrypoint values can resolve to null and disappear from the final argument list. The resolved prefix
+        // boundary must shrink with them so the first ordinary argument remains executable.
+        var builder = DistributedApplication.CreateBuilder();
+
+        var resource = new TestExecutableResource("test-working-directory");
+        builder.AddResource(resource)
+            .WithArgs("app-arg")
+            .WithEntrypointArgs("test", static ctx => ctx.Args.Add(NullValueProvider.Instance))
+            .WithDebugSupport(
+                mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
+                "test");
+
+        var configDict = new Dictionary<string, string?>
+        {
+            [DcpExecutor.DebugSessionPortVar] = "12345",
+            [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["test"] }),
+            [KnownConfigNames.ExtensionEndpoint] = "http://localhost:1234"
+        };
+        var configuration = new ConfigurationBuilder().AddInMemoryCollection(configDict).Build();
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService, configuration: configuration);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetesService, "TestExecutable");
+        Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
+        Assert.Equal(["app-arg"], exe.Spec.Args);
+        Assert.Equal(ExecutionType.Process, Assert.Single(exe.Spec.FallbackExecutionTypes!));
+    }
+
+    [Fact]
+    public async Task DotnetProjectExecutable_EmptyOwnedEntrypoint_DoesNotOfferBrokenProcessFallback()
+    {
+        // DotnetProjectResource suppresses its `dotnet run` scaffold when a custom launch configuration owns the
+        // entrypoint. An empty entrypoint therefore leaves an IDE-only `dotnet <app-args>` command, not a runnable
+        // Process fallback.
+        var builder = DistributedApplication.CreateBuilder();
+
+        var resource = new TestDotnetProjectExecutableResource("test-working-directory");
+        builder.AddResource(resource)
+            .WithAnnotation(new TestProjectWithLaunchSettings())
+            .WithArgs("app-arg")
+            .WithEntrypointArgs("custom", static _ => { })
+            .WithDebugSupport(
+                mode => new ExecutableLaunchConfiguration("custom") { Mode = mode },
+                "custom");
+
+        var configDict = new Dictionary<string, string?>
+        {
+            [DcpExecutor.DebugSessionPortVar] = "12345",
+            [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["custom"] }),
+            [KnownConfigNames.ExtensionEndpoint] = "http://localhost:1234"
+        };
+        var configuration = new ConfigurationBuilder().AddInMemoryCollection(configDict).Build();
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService, configuration: configuration);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetesService, "TestDotnetProject");
+        Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
+        Assert.Equal(["app-arg"], exe.Spec.Args);
+        Assert.Null(exe.Spec.FallbackExecutionTypes);
+    }
+
+    [Fact]
+    public async Task DotnetProjectExecutable_EmptyOwnedEntrypoint_LaunchConfigFailureDoesNotRunBrokenProcessCommand()
+    {
+        var builder = DistributedApplication.CreateBuilder();
+
+        var resource = new TestDotnetProjectExecutableResource("test-working-directory");
+        builder.AddResource(resource)
+            .WithAnnotation(new TestProjectWithLaunchSettings())
+            .WithArgs("app-arg")
+            .WithEntrypointArgs("custom", static _ => { })
+            .WithDebugSupport(
+                ThrowingLaunchConfiguration,
+                "custom");
+
+        var configDict = new Dictionary<string, string?>
+        {
+            [DcpExecutor.DebugSessionPortVar] = "12345",
+            [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["custom"] }),
+            [KnownConfigNames.ExtensionEndpoint] = "http://localhost:1234"
+        };
+        var configuration = new ConfigurationBuilder().AddInMemoryCollection(configDict).Build();
+
+        var kubernetesService = new TestKubernetesService();
+        var failedResources = new List<IResource>();
+        var events = new DcpExecutorEvents();
+        events.Subscribe<OnResourceFailedToStartContext>(context =>
+        {
+            failedResources.Add(context.Resource);
+            return Task.CompletedTask;
+        });
+
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(
+            distributedAppModel,
+            kubernetesService: kubernetesService,
+            configuration: configuration,
+            events: events);
+
+        await appExecutor.RunApplicationAsync();
+
+        Assert.Empty(GetCreatedExecutablesForResource(kubernetesService, "TestDotnetProject"));
+        Assert.Same(resource, Assert.Single(failedResources));
+
+        static ExecutableLaunchConfiguration ThrowingLaunchConfiguration(string mode)
+        {
+            throw new InvalidOperationException("Launch configuration failed.");
+        }
+    }
+
+    [Fact]
+    public async Task PlainExecutable_ExtensionMode_ProcessFallbackIsRecomputedOnRestart()
+    {
+        // Restart invalidates entrypoint callback caches without rerunning preparation. Vary the prefix across
+        // creations to prove fallback metadata follows the newly resolved command rather than stale prepared state.
+        var builder = DistributedApplication.CreateBuilder();
+        var callbackCount = 0;
+
+        var resource = new TestExecutableResource("test-working-directory");
+        builder.AddResource(resource)
+            .WithArgs("app-arg")
+            .WithEntrypointArgs(
+                "test",
+                ctx =>
+                {
+                    if (Interlocked.Increment(ref callbackCount) == 2)
+                    {
+                        ctx.Args.Add("run");
+                    }
+                })
+            .WithDebugSupport(
+                mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
+                "test");
+
+        var configDict = new Dictionary<string, string?>
+        {
+            [DcpExecutor.DebugSessionPortVar] = "12345",
+            [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["test"] }),
+            [KnownConfigNames.ExtensionEndpoint] = "http://localhost:1234"
+        };
+        var configuration = new ConfigurationBuilder().AddInMemoryCollection(configDict).Build();
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService, configuration: configuration);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe1 = Assert.Single(GetCreatedExecutablesForResource(kubernetesService, "TestExecutable"));
+        Assert.Equal(ExecutionType.Process, Assert.Single(exe1.Spec.FallbackExecutionTypes!));
+
+        var reference = appExecutor.GetResource(exe1.Metadata.Name);
+        await appExecutor.StartResourceAsync(reference, CancellationToken.None);
+
+        var executables = GetCreatedExecutablesForResource(kubernetesService, "TestExecutable");
+        Assert.Equal(2, executables.Count);
+        var exe2 = executables[1];
+        Assert.Null(exe2.Spec.FallbackExecutionTypes);
+
+        await appExecutor.StartResourceAsync(reference, CancellationToken.None);
+
+        executables = GetCreatedExecutablesForResource(kubernetesService, "TestExecutable");
+        Assert.Equal(3, executables.Count);
+        var exe3 = executables[2];
+        Assert.Equal(ExecutionType.Process, Assert.Single(exe3.Spec.FallbackExecutionTypes!));
+        Assert.Equal(3, callbackCount);
+    }
+
+    [Fact]
+    public async Task PlainExecutable_ExtensionMode_ExecutionTypeIsRecomputedOnRestart()
+    {
+        var builder = DistributedApplication.CreateBuilder();
+        var callbackCount = 0;
+
+        var resource = new TestExecutableResource("test-working-directory");
+        builder.AddResource(resource)
+            .WithArgs("app-arg")
+            .WithDebugSupport(
+                mode =>
+                {
+                    if (Interlocked.Increment(ref callbackCount) == 2)
+                    {
+                        throw new InvalidOperationException("Launch configuration failed.");
+                    }
+
+                    return new ExecutableLaunchConfiguration("test") { Mode = mode };
+                },
+                "test");
+
+        var configDict = new Dictionary<string, string?>
+        {
+            [DcpExecutor.DebugSessionPortVar] = "12345",
+            [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["test"] }),
+            [KnownConfigNames.ExtensionEndpoint] = "http://localhost:1234"
+        };
+        var configuration = new ConfigurationBuilder().AddInMemoryCollection(configDict).Build();
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService, configuration: configuration);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe1 = Assert.Single(GetCreatedExecutablesForResource(kubernetesService, "TestExecutable"));
+        Assert.Equal(ExecutionType.IDE, exe1.Spec.ExecutionType);
+        Assert.Equal(ExecutionType.Process, Assert.Single(exe1.Spec.FallbackExecutionTypes!));
+
+        var reference = appExecutor.GetResource(exe1.Metadata.Name);
+        await appExecutor.StartResourceAsync(reference, CancellationToken.None);
+
+        var executables = GetCreatedExecutablesForResource(kubernetesService, "TestExecutable");
+        Assert.Equal(2, executables.Count);
+        var exe2 = executables[1];
+        Assert.Equal(ExecutionType.Process, exe2.Spec.ExecutionType);
+        Assert.Null(exe2.Spec.FallbackExecutionTypes);
+
+        await appExecutor.StartResourceAsync(reference, CancellationToken.None);
+
+        executables = GetCreatedExecutablesForResource(kubernetesService, "TestExecutable");
+        Assert.Equal(3, executables.Count);
+        var exe3 = executables[2];
+        Assert.Equal(ExecutionType.IDE, exe3.Spec.ExecutionType);
+        Assert.Equal(ExecutionType.Process, Assert.Single(exe3.Spec.FallbackExecutionTypes!));
+        Assert.Equal(3, callbackCount);
+    }
+
     [Fact]
     public async Task PlainExecutable_ProjectDebugSupportWithoutProjectMetadata_FailsToStart()
     {
@@ -7574,6 +7819,16 @@ private static X509Certificate2 CreateTestCertificate()
     private sealed class TestExecutableResource(string directory) : ExecutableResource("TestExecutable", "test", directory);
     private sealed class TestOtherExecutableResource(string directory) : ExecutableResource("TestOtherExecutable", "test-other", directory);
 
+    private sealed class NullValueProvider : IValueProvider
+    {
+        public static NullValueProvider Instance { get; } = new();
+
+        public ValueTask<string?> GetValueAsync(CancellationToken cancellationToken = default)
+        {
+            return ValueTask.FromResult<string?>(null);
+        }
+    }
+
     // Models a DotnetProjectResource: a plain ExecutableResource (launches `dotnet`) that carries
     // IProjectMetadata and a "project" SupportsDebuggingAnnotation. Used to verify the DCP project-launch
     // generalization without taking a dependency on Aspire.Hosting.Dotnet.
diff --git a/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs b/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs
index 7c2f8413b57..3386fc9f2fa 100644
--- a/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs
+++ b/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs
@@ -165,7 +165,7 @@ public void WithDebugSupportRejectsAValueTaskReturningSynchronousProducer()
     }
 
     [Fact]
-    public async Task WithDebugSupportEntrypointArgsLeadTheCommandLine()
+    public async Task WithEntrypointArgsLeadTheCommandLine()
     {
         // The entrypoint arguments are the tool-invocation prefix, so they always come first and the program's own
         // arguments follow, regardless of the launch configuration in effect.
@@ -173,7 +173,8 @@ public async Task WithDebugSupportEntrypointArgsLeadTheCommandLine()
 
         var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
             .WithArgs("base-arg")
-            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("entrypoint-arg"));
+            .WithEntrypointArgs("go", ctx => ctx.Args.Add("entrypoint-arg"))
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go");
 
         var args = await ArgumentEvaluator.GetArgumentListAsync(executable.Resource);
 
@@ -185,12 +186,12 @@ public async Task WithDebugSupportEntrypointArgsLeadTheCommandLine()
     [Theory]
     [InlineData(true)]
     [InlineData(false)]
-    public async Task WithDebugSupportEntrypointArgsAreOrderIndependent(bool debugSupportFirst)
+    public async Task WithEntrypointArgsAreOrderIndependent(bool entrypointArgsFirst)
     {
         // Regression coverage for https://github.com/microsoft/aspire/issues/18929: the entrypoint arguments used to
         // be applied by an ordinary WithArgs callback that *removed* the prefix, which only worked when
-        // WithDebugSupport happened to be called after the callback that added it. Declaring the prefix instead of
-        // subtracting it must produce the same command line either way.
+        // WithDebugSupport happened to be called after the callback that added it. Declaring the prefix separately
+        // instead of subtracting it must produce the same command line either way.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
         builder.Configuration["DEBUG_SESSION_PORT"] = "5678";
@@ -200,19 +201,20 @@ public async Task WithDebugSupportEntrypointArgsAreOrderIndependent(bool debugSu
             SupportedLaunchConfigurations = ["go"]
         });
 
-        var executable = builder.AddExecutable("myexe", "command", "workingdirectory");
+        var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go");
 
-        if (debugSupportFirst)
+        if (entrypointArgsFirst)
         {
             executable
-                .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("run"))
+                .WithEntrypointArgs("go", ctx => ctx.Args.Add("run"))
                 .WithArgs("base-arg");
         }
         else
         {
             executable
                 .WithArgs("base-arg")
-                .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("run"));
+                .WithEntrypointArgs("go", ctx => ctx.Args.Add("run"));
         }
 
         var args = await ArgumentEvaluator.GetArgumentListAsync(executable.Resource);
@@ -223,14 +225,15 @@ public async Task WithDebugSupportEntrypointArgsAreOrderIndependent(bool debugSu
     }
 
     [Fact]
-    public async Task WithDebugSupportEntrypointArgsSurviveAnArgsCallbackThatClearsTheList()
+    public async Task WithEntrypointArgsSurviveAnArgsCallbackThatClearsTheList()
     {
         // No WithArgs callback can observe or clear the entrypoint prefix: it is evaluated separately and inserted
         // ahead of the arguments those callbacks produce.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
         var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
-            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("entrypoint-arg"))
+            .WithEntrypointArgs("go", ctx => ctx.Args.Add("entrypoint-arg"))
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go")
             .WithArgs("discarded")
             .WithArgs(ctx =>
             {
@@ -246,7 +249,7 @@ public async Task WithDebugSupportEntrypointArgsSurviveAnArgsCallbackThatClearsT
     }
 
     [Fact]
-    public async Task WithDebugSupportEntrypointArgsRemainInTheAppModelDuringADebugSession()
+    public async Task WithEntrypointArgsRemainInTheAppModelDuringADebugSession()
     {
         // Withholding the prefix is a DCP-level concern. The application model must keep describing the real
         // command line so the dashboard, the manifest and GetArgumentValuesAsync() consumers stay accurate.
@@ -261,7 +264,8 @@ public async Task WithDebugSupportEntrypointArgsRemainInTheAppModelDuringADebugS
 
         var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
             .WithArgs("base-arg")
-            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("run"));
+            .WithEntrypointArgs("go", ctx => ctx.Args.Add("run"))
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go");
 
         var args = await ArgumentEvaluator.GetArgumentListAsync(executable.Resource);
 
@@ -271,14 +275,15 @@ public async Task WithDebugSupportEntrypointArgsRemainInTheAppModelDuringADebugS
     }
 
     [Fact]
-    public void WithDebugSupportRegistersEntrypointArgsForItsLaunchConfigurationType()
+    public void WithEntrypointArgsAreOwnedByMatchingLaunchConfigurationType()
     {
         // The entrypoint is owned by the launch configuration type it was declared with, so a launch configuration
         // of a different type does not claim it.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
         var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
-            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("run"))
+            .WithEntrypointArgs("go", ctx => ctx.Args.Add("run"))
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go")
             .WithDebugSupport(_ => new ExecutableLaunchConfiguration("project"), "project");
 
         var annotations = executable.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().ToList();
@@ -288,19 +293,7 @@ public void WithDebugSupportRegistersEntrypointArgsForItsLaunchConfigurationType
     }
 
     [Fact]
-    public void WithDebugSupportDoesNotRegisterEntrypointArgsWhenResourceHasNoArgs()
-    {
-        using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
-
-        var resource = builder.AddResource(new DebuggableResourceWithoutArgs("noargs"))
-            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("run"));
-
-        var annotation = resource.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().Single();
-        Assert.False(resource.Resource.OwnsEntrypointArguments(annotation));
-    }
-
-    [Fact]
-    public void WithDebugSupportDoesNotRegisterEntrypointArgsWhenNoCallbackProvided()
+    public void WithDebugSupportDoesNotOwnEntrypointArgumentsWithoutWithEntrypointArgs()
     {
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
@@ -312,7 +305,7 @@ public void WithDebugSupportDoesNotRegisterEntrypointArgsWhenNoCallbackProvided(
     }
 
     [Fact]
-    public async Task WithDebugSupportRegistersEntrypointArgsInPublishMode()
+    public async Task WithEntrypointArgsAreRegisteredInPublishMode()
     {
         // Debug support is run-mode only, but the entrypoint describes how the resource is invoked in general and
         // must survive into the manifest and generated container images.
@@ -320,7 +313,8 @@ public async Task WithDebugSupportRegistersEntrypointArgsInPublishMode()
 
         var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
             .WithArgs("base-arg")
-            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("run"));
+            .WithEntrypointArgs("go", ctx => ctx.Args.Add("run"))
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go");
 
         Assert.Empty(executable.Resource.Annotations.OfType<SupportsDebuggingAnnotation>());
 
@@ -332,7 +326,7 @@ public async Task WithDebugSupportRegistersEntrypointArgsInPublishMode()
     }
 
     [Fact]
-    public async Task WithDebugSupportEntrypointArgsAreNotCarriedIntoAPublishedContainer()
+    public async Task WithEntrypointArgsAreNotCarriedIntoAPublishedContainer()
     {
         // PublishAsDockerFile reuses the executable's annotations for the generated container resource, but a
         // container invokes the program through the image's ENTRYPOINT, so repeating the tool prefix in the
@@ -341,7 +335,8 @@ public async Task WithDebugSupportEntrypointArgsAreNotCarriedIntoAPublishedConta
 
         builder.AddExecutable("myexe", "command", "workingdirectory")
             .WithArgs("base-arg")
-            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go", ctx => ctx.Args.Add("run"))
+            .WithEntrypointArgs("go", ctx => ctx.Args.Add("run"))
+            .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go")
             .PublishAsDockerFile();
 
         var container = Assert.Single(builder.Resources.OfType<ContainerResource>());
@@ -350,6 +345,4 @@ public async Task WithDebugSupportEntrypointArgsAreNotCarriedIntoAPublishedConta
 
         Assert.Empty(args);
     }
-
-    private sealed class DebuggableResourceWithoutArgs(string name) : Resource(name);
 }

From e73adb225031078331498a79d11c9056a9d06d5a Mon Sep 17 00:00:00 2001
From: Karol Zadora-Przylecki <karolz@microsoft.com>
Date: Wed, 5 Aug 2026 16:54:42 -0700
Subject: [PATCH 03/13] Generalize entrypoint args into launch tool args

The leading-argument segment introduced for debug support is a generally
useful primitive, but it shipped welded to debugging: the launch
configuration type was mandatory, so there was no way to say "this
resource has a tool-invocation prefix" without also saying "an IDE
debugger performs it". Whether the prefix appeared in the dashboard was
likewise implicit in two call sites rather than a property of the
declaration.

That blocks the direction settled in #18904 (WithArgs = app args,
WithXyzArgs = tool args), which needs this segment underneath: without
it an integration cannot guarantee its tool args precede user WithArgs
args, so it resorts to registration-order tricks -- exactly what
DotnetToolResource does today.

Reshape the primitive so it can carry that layer later:

- Rename to WithLaunchToolArgs. "Entrypoint" already means the
  module/script in Python's WithEntrypoint and the image ENTRYPOINT on
  containers, roughly the opposite of the meaning here.
- Make ownedByLaunchConfigurationType optional. Null means the prefix is
  not a debugging concern and is always passed to the program, which is
  the `dotnet tool exec` shape.
- Add showInCommandLine, splitting two facts that BuildLaunchArgs had
  conflated: whether the prefix is withheld from the launched process
  (an IDE-ownership question) and whether it appears in the dashboard
  command line (a declaration question).

No behavior change. Go and Python keep the same shape, and
DotnetToolResource is deliberately not migrated here -- two tests cover
the shape it would use so the primitive stays able to absorb it.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: b93d3d93-3cb2-4632-af31-bd6a2ea495ef
---
 .../DotnetProjectHostingExtensions.cs         |   6 +-
 src/Aspire.Hosting.Go/GoHostingExtensions.cs  |   9 +-
 .../PythonAppResourceBuilderExtensions.cs     |   5 +-
 ...ArgumentsExecutionConfigurationGatherer.cs |  32 ++--
 .../DebugSupportExtensions.cs                 |  16 +-
 .../EntrypointArgsCallbackAnnotation.cs       | 101 -------------
 .../ExecutionConfigurationGathererContext.cs  |  21 +--
 .../LaunchToolArgsCallbackAnnotation.cs       | 129 ++++++++++++++++
 src/Aspire.Hosting/Dcp/DcpExecutor.cs         |   4 +-
 src/Aspire.Hosting/Dcp/ExecutableCreator.cs   |  96 +++++++-----
 .../ResourceBuilderExtensions.cs              |  67 ++++++---
 .../DotnetProjectResourceTests.cs             |  20 +--
 .../Aspire.Hosting.Go.Tests/AddGoAppTests.cs  |   4 +-
 .../AddPythonAppTests.cs                      |   8 +-
 .../Dcp/DcpExecutorTests.cs                   | 140 ++++++++++++++----
 ...ExecutableResourceBuilderExtensionTests.cs |  54 +++----
 16 files changed, 440 insertions(+), 272 deletions(-)
 delete mode 100644 src/Aspire.Hosting/ApplicationModel/EntrypointArgsCallbackAnnotation.cs
 create mode 100644 src/Aspire.Hosting/ApplicationModel/LaunchToolArgsCallbackAnnotation.cs

diff --git a/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs b/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
index a95d264199a..6151a5fa8a0 100644
--- a/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
+++ b/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
@@ -132,11 +132,11 @@ public static IResourceBuilder<DotnetProjectResource> AddDotnetProject(this IDis
         //   dotnet run --file <app.cs> --no-cache [--no-build] [--configuration <cfg>] --no-launch-profile
         resource.WithArgs(ctx =>
         {
-            // The active launch configuration supplies the project launch when it is "project" or owns a custom
-            // entrypoint. In those cases adding `dotnet run` would duplicate the tool invocation instead of
+            // The active launch configuration supplies the project launch when it is "project" or performs a custom
+            // tool invocation. In those cases adding `dotnet run` would duplicate the tool invocation instead of
             // contributing the process command.
             if (ctx.Resource.SupportsDebugging(builder.Configuration, out var debugAnnotation)
-                && (debugAnnotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project || ctx.Resource.OwnsEntrypointArguments(debugAnnotation)))
+                && (debugAnnotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project || ctx.Resource.HasLaunchToolArgsOwnedBy(debugAnnotation)))
             {
                 return;
             }
diff --git a/src/Aspire.Hosting.Go/GoHostingExtensions.cs b/src/Aspire.Hosting.Go/GoHostingExtensions.cs
index fcd7f49268b..d42c8b9d6e9 100644
--- a/src/Aspire.Hosting.Go/GoHostingExtensions.cs
+++ b/src/Aspire.Hosting.Go/GoHostingExtensions.cs
@@ -764,12 +764,12 @@ internal static IResourceBuilder<T> WithVSCodeDebugging<T>(this IResourceBuilder
                 };
             },
             "go")
-            .WithEntrypointArgs("go", static ctx =>
+            .WithLaunchToolArgs(static ctx =>
             {
                 // The executable resource normally starts as:
                 //   go run [-race] [-tags=...] [-ldflags=...] [-gcflags=...] <pkg> [app args]
-                // Everything up to and including <pkg> is the entrypoint: in IDE mode VS Code's Go debugger owns it
-                // via program/buildFlags, so it is not passed to the launched program.
+                // Everything up to and including <pkg> is the tool invocation: in IDE mode VS Code's Go debugger
+                // performs it via program/buildFlags, so it is not passed to the launched program.
                 if (ctx.Resource.HasAnnotationOfType<GoDelveServerAnnotation>())
                 {
                     // WithDelveServer replaces the whole command line with a headless `dlv debug ...` invocation and
@@ -802,7 +802,8 @@ internal static IResourceBuilder<T> WithVSCodeDebugging<T>(this IResourceBuilder
                 ctx.Args.Add(ctx.Resource.TryGetLastAnnotation<GoPackagePathAnnotation>(out var pkgAnnotation)
                     ? pkgAnnotation.PackagePath
                     : ".");
-            });
+            },
+            ownedByLaunchConfigurationType: "go");
     }
 
     /// <summary>
diff --git a/src/Aspire.Hosting.Python/PythonAppResourceBuilderExtensions.cs b/src/Aspire.Hosting.Python/PythonAppResourceBuilderExtensions.cs
index 7fe70758328..9ee2cdce0b7 100644
--- a/src/Aspire.Hosting.Python/PythonAppResourceBuilderExtensions.cs
+++ b/src/Aspire.Hosting.Python/PythonAppResourceBuilderExtensions.cs
@@ -1065,7 +1065,7 @@ public static IResourceBuilder<T> WithEntrypoint<T>(
         },
         ResourceAnnotationMutationBehavior.Replace);
 
-        builder.WithEntrypointArgs("python", static context =>
+        builder.WithLaunchToolArgs(static context =>
         {
             if (!context.Resource.TryGetLastAnnotation<PythonEntrypointAnnotation>(out var existingAnnotation))
             {
@@ -1089,7 +1089,8 @@ public static IResourceBuilder<T> WithEntrypoint<T>(
                     // Executable runs directly, no additional args needed for entrypoint
                     break;
             }
-        });
+        },
+        ownedByLaunchConfigurationType: "python");
 
         return builder;
     }
diff --git a/src/Aspire.Hosting/ApplicationModel/ArgumentsExecutionConfigurationGatherer.cs b/src/Aspire.Hosting/ApplicationModel/ArgumentsExecutionConfigurationGatherer.cs
index a3724b1c937..4e777f75f7d 100644
--- a/src/Aspire.Hosting/ApplicationModel/ArgumentsExecutionConfigurationGatherer.cs
+++ b/src/Aspire.Hosting/ApplicationModel/ArgumentsExecutionConfigurationGatherer.cs
@@ -33,50 +33,52 @@ public async ValueTask GatherAsync(IExecutionConfigurationGathererContext contex
             context.Arguments.AddRange(args);
         }
 
-        await GatherEntrypointArgumentsAsync(context, resource, resourceLogger, executionContext, cancellationToken).ConfigureAwait(false);
+        await GatherLaunchToolArgumentsAsync(context, resource, resourceLogger, executionContext, cancellationToken).ConfigureAwait(false);
     }
 
     /// <summary>
-    /// Evaluates the resource's entrypoint arguments (the tool-invocation prefix, e.g. <c>run ./cmd/api</c>) and
+    /// Evaluates the resource's launch tool arguments (the tool-invocation prefix, e.g. <c>run ./cmd/api</c>) and
     /// inserts them ahead of every other argument.
     /// </summary>
     /// <remarks>
     /// The callback is deliberately evaluated <em>after</em> the ordinary argument callbacks but its result is
     /// inserted <em>before</em> them. That is what makes the prefix order-independent: no <c>WithArgs</c> callback
-    /// can observe it, mutate it, or clear it, so it does not matter whether the entrypoint was declared before or
-    /// after the calls that add the program's own arguments.
+    /// can observe it, mutate it, or clear it, so it does not matter whether the tool invocation was declared before
+    /// or after the calls that add the program's own arguments.
     /// </remarks>
-    private static async ValueTask GatherEntrypointArgumentsAsync(IExecutionConfigurationGathererContext context, IResource resource, ILogger resourceLogger, DistributedApplicationExecutionContext executionContext, CancellationToken cancellationToken)
+    private static async ValueTask GatherLaunchToolArgumentsAsync(IExecutionConfigurationGathererContext context, IResource resource, ILogger resourceLogger, DistributedApplicationExecutionContext executionContext, CancellationToken cancellationToken)
     {
-        // Entrypoint arguments describe how a local tool (the resource's executable command) invokes the program.
+        // Launch tool arguments describe how a local tool (the resource's executable command) invokes the program.
         // A container invokes the program through the image's ENTRYPOINT instead, so the prefix must not be repeated
         // in its arguments. This matters for executables published as a Dockerfile (Go, Python, JavaScript), where
-        // PublishAsDockerFile() reuses the executable's annotations for the generated container resource.
+        // PublishAsDockerFile() reuses the executable's annotations for the generated container resource. Note that
+        // the container's own `WithArgs(c => c.Args.Clear())` cannot undo this, because the prefix is inserted after
+        // all the ordinary argument callbacks have run.
         if (resource is ContainerResource)
         {
             return;
         }
 
         // Only the last annotation applies, mirroring how the active SupportsDebuggingAnnotation is resolved:
-        // a resource can be handed entrypoint arguments more than once and the most recent declaration wins.
-        if (!resource.TryGetLastAnnotation<EntrypointArgsCallbackAnnotation>(out var entrypointAnnotation))
+        // a resource can be handed launch tool arguments more than once and the most recent declaration wins.
+        if (!resource.TryGetLastAnnotation<LaunchToolArgsCallbackAnnotation>(out var launchToolAnnotation))
         {
             return;
         }
 
-        var entrypointContext = new CommandLineArgsCallbackContext([], resource, cancellationToken)
+        var launchToolContext = new CommandLineArgsCallbackContext([], resource, cancellationToken)
         {
             Logger = resourceLogger,
             ExecutionContext = executionContext
         };
 
-        var entrypointArgs = await entrypointAnnotation.AsCallbackAnnotation().EvaluateOnceAsync(entrypointContext).ConfigureAwait(false);
-        if (entrypointArgs.Count == 0)
+        var launchToolArgs = await launchToolAnnotation.AsCallbackAnnotation().EvaluateOnceAsync(launchToolContext).ConfigureAwait(false);
+        if (launchToolArgs.Count == 0)
         {
             return;
         }
 
-        context.Arguments.InsertRange(0, entrypointArgs);
-        context.AddAdditionalData(new EntrypointArgumentsData(entrypointArgs.Count));
+        context.Arguments.InsertRange(0, launchToolArgs);
+        context.AddAdditionalData(new LaunchToolArgumentsData(launchToolArgs.Count, launchToolAnnotation.ShowInCommandLine));
     }
-}
\ No newline at end of file
+}
diff --git a/src/Aspire.Hosting/ApplicationModel/DebugSupportExtensions.cs b/src/Aspire.Hosting/ApplicationModel/DebugSupportExtensions.cs
index a2fe01f618f..5e1d6f9d6d7 100644
--- a/src/Aspire.Hosting/ApplicationModel/DebugSupportExtensions.cs
+++ b/src/Aspire.Hosting/ApplicationModel/DebugSupportExtensions.cs
@@ -74,19 +74,25 @@ public static bool SupportsDebugging(this IResource resource, IConfiguration con
     }
 
     /// <summary>
-    /// Determines whether the launch configuration owns the resource's entrypoint arguments.
+    /// Determines whether the launch configuration performs the resource's tool invocation itself, meaning the
+    /// resource's launch tool arguments must not also be passed to the launched program.
     /// </summary>
     /// <param name="resource">The resource to inspect.</param>
     /// <param name="supportsDebuggingAnnotation">The launch configuration annotation to compare.</param>
-    /// <returns><see langword="true"/> when the launch configuration supplies the entrypoint; otherwise, <see langword="false"/>.</returns>
+    /// <returns><see langword="true"/> when the launch configuration supplies the tool invocation; otherwise, <see langword="false"/>.</returns>
+    /// <remarks>
+    /// This is <see langword="false"/> for a resource whose launch tool arguments declare no owning launch
+    /// configuration type, because such a prefix is always passed to the program.
+    /// </remarks>
     [AspireExportIgnore(Reason = "Debug support inspection is a local .NET helper and is not part of the ATS surface.")]
-    public static bool OwnsEntrypointArguments(this IResource resource, SupportsDebuggingAnnotation supportsDebuggingAnnotation)
+    public static bool HasLaunchToolArgsOwnedBy(this IResource resource, SupportsDebuggingAnnotation supportsDebuggingAnnotation)
     {
         ArgumentNullException.ThrowIfNull(resource);
         ArgumentNullException.ThrowIfNull(supportsDebuggingAnnotation);
 
-        return resource.TryGetLastAnnotation<EntrypointArgsCallbackAnnotation>(out var entrypointAnnotation)
-            && string.Equals(entrypointAnnotation.LaunchConfigurationType, supportsDebuggingAnnotation.LaunchConfigurationType, StringComparison.Ordinal);
+        return resource.TryGetLastAnnotation<LaunchToolArgsCallbackAnnotation>(out var launchToolAnnotation)
+            && launchToolAnnotation.OwningLaunchConfigurationType is string owner
+            && string.Equals(owner, supportsDebuggingAnnotation.LaunchConfigurationType, StringComparison.Ordinal);
     }
 
     /// <summary>
diff --git a/src/Aspire.Hosting/ApplicationModel/EntrypointArgsCallbackAnnotation.cs b/src/Aspire.Hosting/ApplicationModel/EntrypointArgsCallbackAnnotation.cs
deleted file mode 100644
index a3311552837..00000000000
--- a/src/Aspire.Hosting/ApplicationModel/EntrypointArgsCallbackAnnotation.cs
+++ /dev/null
@@ -1,101 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.Immutable;
-
-namespace Aspire.Hosting.ApplicationModel;
-
-using IArgCallbackAnnotation = ICallbackResourceAnnotation<CommandLineArgsCallbackContext, IList<object>>;
-
-/// <summary>
-/// Carries the <em>entrypoint arguments</em> of a resource: the tool-invocation prefix that hosts the
-/// program, such as <c>run -tags=netgo ./cmd/api</c> for <c>go</c> or <c>-m flask</c> for <c>python</c>.
-/// </summary>
-/// <remarks>
-/// <para>
-/// Entrypoint arguments are modelled separately from ordinary <see cref="CommandLineArgsCallbackAnnotation"/>
-/// arguments for two reasons:
-/// </para>
-/// <list type="number">
-/// <item><description>
-/// They are always placed <em>first</em>, no matter when the annotation was added. The callback is evaluated
-/// against its own empty argument list and the result is inserted ahead of every other argument, so no
-/// <c>WithArgs</c> callback can observe it, mutate it, or clear it, and no registration order is implied.
-/// </description></item>
-/// <item><description>
-/// When an IDE debug launch configuration owns the entrypoint (the debugger launches the built binary or the
-/// interpreter itself), the prefix must not be passed to the program. Because it is a separate, structurally
-/// leading list, it can simply be withheld instead of being textually subtracted from the final command line.
-/// </description></item>
-/// </list>
-/// </remarks>
-internal sealed class EntrypointArgsCallbackAnnotation : IResourceAnnotation, IArgCallbackAnnotation
-{
-    private Task<IList<object>>? _callbackTask;
-    private readonly object _lock = new();
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="EntrypointArgsCallbackAnnotation"/> class.
-    /// </summary>
-    /// <param name="launchConfigurationType">
-    /// The debug launch configuration type that owns this entrypoint, for example "go" or "python".
-    /// </param>
-    /// <param name="callback">
-    /// Callback that produces the entrypoint arguments. It is invoked with an empty
-    /// <see cref="CommandLineArgsCallbackContext.Args"/> list; everything it adds becomes the leading arguments.
-    /// </param>
-    public EntrypointArgsCallbackAnnotation(string launchConfigurationType, Func<CommandLineArgsCallbackContext, Task> callback)
-    {
-        ArgumentException.ThrowIfNullOrEmpty(launchConfigurationType);
-        ArgumentNullException.ThrowIfNull(callback);
-
-        LaunchConfigurationType = launchConfigurationType;
-        Callback = callback;
-    }
-
-    /// <summary>
-    /// Gets the debug launch configuration type that owns this entrypoint.
-    /// </summary>
-    public string LaunchConfigurationType { get; }
-
-    /// <summary>
-    /// Gets the callback that produces the entrypoint arguments.
-    /// </summary>
-    public Func<CommandLineArgsCallbackContext, Task> Callback { get; }
-
-    internal IArgCallbackAnnotation AsCallbackAnnotation() => this;
-
-    Task<IList<object>> IArgCallbackAnnotation.EvaluateOnceAsync(CommandLineArgsCallbackContext context)
-    {
-        lock (_lock)
-        {
-            _callbackTask ??= ExecuteCallbackAsync(context);
-            return _callbackTask;
-        }
-    }
-
-    void IArgCallbackAnnotation.ForgetCachedResult()
-    {
-        lock (_lock)
-        {
-            _callbackTask = null;
-        }
-    }
-
-    private async Task<IList<object>> ExecuteCallbackAsync(CommandLineArgsCallbackContext context)
-    {
-        await Callback(context).ConfigureAwait(false);
-        return context.Args.ToImmutableList();
-    }
-}
-
-/// <summary>
-/// Reports how many of the leading arguments in an execution configuration were produced by an
-/// <see cref="EntrypointArgsCallbackAnnotation"/>, so that consumers that compose the actual command line
-/// (such as the DCP executable creator) can tell the tool-invocation prefix apart from the program arguments.
-/// </summary>
-/// <param name="Count">
-/// The number of leading arguments that form the entrypoint prefix. This is normalized after value resolution to
-/// exclude arguments that resolve to <see langword="null"/>.
-/// </param>
-internal sealed record EntrypointArgumentsData(int Count) : IExecutionConfigurationData;
diff --git a/src/Aspire.Hosting/ApplicationModel/ExecutionConfigurationGathererContext.cs b/src/Aspire.Hosting/ApplicationModel/ExecutionConfigurationGathererContext.cs
index 2b2288bf5ba..67a8b2aaf38 100644
--- a/src/Aspire.Hosting/ApplicationModel/ExecutionConfigurationGathererContext.cs
+++ b/src/Aspire.Hosting/ApplicationModel/ExecutionConfigurationGathererContext.cs
@@ -44,8 +44,8 @@ internal async Task<IExecutionConfigurationResult> ResolveAsync(
         List<(object Unprocessed, string Value, bool IsSensitive)> resolvedArguments = new(Arguments.Count);
         Dictionary<string, (object Unprocessed, string Value)> resolvedEnvironmentVariables = new(EnvironmentVariables.Count);
         List<Exception> exceptions = new();
-        var entrypointArgumentsData = AdditionalConfigurationData.OfType<EntrypointArgumentsData>().FirstOrDefault();
-        var resolvedEntrypointArgumentCount = 0;
+        var launchToolArgumentsData = AdditionalConfigurationData.OfType<LaunchToolArgumentsData>().FirstOrDefault();
+        var resolvedLaunchToolArgumentCount = 0;
 
         for (var argumentIndex = 0; argumentIndex < Arguments.Count; argumentIndex++)
         {
@@ -57,11 +57,11 @@ internal async Task<IExecutionConfigurationResult> ResolveAsync(
                 if (resolvedValue?.Value != null)
                 {
                     resolvedArguments.Add((argument, resolvedValue.Value, resolvedValue.IsSensitive));
-                    if (entrypointArgumentsData is not null && argumentIndex < entrypointArgumentsData.Count)
+                    if (launchToolArgumentsData is not null && argumentIndex < launchToolArgumentsData.Count)
                     {
-                        // Resolution drops null values. Count only entrypoint values that survived so a missing prefix
-                        // value cannot make consumers treat the first ordinary argument as part of the prefix.
-                        resolvedEntrypointArgumentCount++;
+                        // Resolution drops null values. Count only launch tool values that survived so a missing
+                        // prefix value cannot make consumers treat the first ordinary argument as part of the prefix.
+                        resolvedLaunchToolArgumentCount++;
                     }
 
                     if (argument is IValueProvider or IManifestExpressionProvider)
@@ -99,12 +99,15 @@ internal async Task<IExecutionConfigurationResult> ResolveAsync(
         }
 
         var resolvedAdditionalConfigurationData = AdditionalConfigurationData;
-        if (entrypointArgumentsData is not null && entrypointArgumentsData.Count != resolvedEntrypointArgumentCount)
+        if (launchToolArgumentsData is not null && launchToolArgumentsData.Count != resolvedLaunchToolArgumentCount)
         {
             resolvedAdditionalConfigurationData = AdditionalConfigurationData
-                .Where(data => data is not EntrypointArgumentsData)
+                .Where(data => data is not LaunchToolArgumentsData)
                 .ToHashSet();
-            resolvedAdditionalConfigurationData.Add(new EntrypointArgumentsData(resolvedEntrypointArgumentCount));
+
+            // Only the count is recomputed here; every other facet of the declaration (such as whether the prefix is
+            // shown in the dashboard command line) is unaffected by value resolution and must be carried over.
+            resolvedAdditionalConfigurationData.Add(launchToolArgumentsData with { Count = resolvedLaunchToolArgumentCount });
         }
 
         return new ExecutionConfigurationResult
diff --git a/src/Aspire.Hosting/ApplicationModel/LaunchToolArgsCallbackAnnotation.cs b/src/Aspire.Hosting/ApplicationModel/LaunchToolArgsCallbackAnnotation.cs
new file mode 100644
index 00000000000..23a06aa43b7
--- /dev/null
+++ b/src/Aspire.Hosting/ApplicationModel/LaunchToolArgsCallbackAnnotation.cs
@@ -0,0 +1,129 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Immutable;
+
+namespace Aspire.Hosting.ApplicationModel;
+
+using IArgCallbackAnnotation = ICallbackResourceAnnotation<CommandLineArgsCallbackContext, IList<object>>;
+
+/// <summary>
+/// Carries the <em>launch tool arguments</em> of a resource: the tool-invocation prefix that hosts the
+/// program, such as <c>run -tags=netgo ./cmd/api</c> for <c>go</c>, <c>-m flask</c> for <c>python</c>, or
+/// <c>tool exec &lt;package&gt; --yes --</c> for <c>dotnet</c>.
+/// </summary>
+/// <remarks>
+/// <para>
+/// Launch tool arguments are modelled separately from ordinary <see cref="CommandLineArgsCallbackAnnotation"/>
+/// arguments for two reasons:
+/// </para>
+/// <list type="number">
+/// <item><description>
+/// They are always placed <em>first</em>, no matter when the annotation was added. The callback is evaluated
+/// against its own empty argument list and the result is inserted ahead of every other argument, so no
+/// <c>WithArgs</c> callback can observe it, mutate it, or clear it, and no registration order is implied.
+/// </description></item>
+/// <item><description>
+/// When an IDE debug launch configuration owns the tool invocation (the debugger launches the built binary or
+/// the interpreter itself), the prefix must not be passed to the program. Because it is a separate,
+/// structurally leading list, it can simply be withheld instead of being textually subtracted from the final
+/// command line.
+/// </description></item>
+/// </list>
+/// </remarks>
+internal sealed class LaunchToolArgsCallbackAnnotation : IResourceAnnotation, IArgCallbackAnnotation
+{
+    private Task<IList<object>>? _callbackTask;
+    private readonly object _lock = new();
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LaunchToolArgsCallbackAnnotation"/> class.
+    /// </summary>
+    /// <param name="callback">
+    /// Callback that produces the launch tool arguments. It is invoked with an empty
+    /// <see cref="CommandLineArgsCallbackContext.Args"/> list; everything it adds becomes the leading arguments.
+    /// </param>
+    /// <param name="owningLaunchConfigurationType">
+    /// The debug launch configuration type that supplies this tool invocation itself, for example "go" or
+    /// "python", or <see langword="null"/> when no launch configuration owns it. See
+    /// <see cref="OwningLaunchConfigurationType"/>.
+    /// </param>
+    /// <param name="showInCommandLine">
+    /// Whether these arguments are part of the command line shown for the resource in the dashboard.
+    /// </param>
+    public LaunchToolArgsCallbackAnnotation(Func<CommandLineArgsCallbackContext, Task> callback, string? owningLaunchConfigurationType, bool showInCommandLine)
+    {
+        ArgumentNullException.ThrowIfNull(callback);
+
+        Callback = callback;
+        OwningLaunchConfigurationType = owningLaunchConfigurationType;
+        ShowInCommandLine = showInCommandLine;
+    }
+
+    /// <summary>
+    /// Gets the debug launch configuration type that supplies this tool invocation itself, or
+    /// <see langword="null"/> when no launch configuration owns it.
+    /// </summary>
+    /// <remarks>
+    /// When this is <see langword="null"/> the arguments are always passed to the launched program, which is the
+    /// right shape for a tool invocation that is not a debugging concern at all (for example
+    /// <c>dotnet tool exec</c>). A non-null value means an IDE launched through a matching launch configuration
+    /// already performs this invocation, so the arguments are withheld in that case.
+    /// </remarks>
+    public string? OwningLaunchConfigurationType { get; }
+
+    /// <summary>
+    /// Gets a value indicating whether these arguments are part of the command line shown for the resource in
+    /// the dashboard.
+    /// </summary>
+    /// <remarks>
+    /// Set this to <see langword="false"/> for a prefix that is pure invocation plumbing the user did not write
+    /// and cannot act on. Note that a prefix which is actually executed remains visible in the resource details
+    /// pane regardless, because that pane reports the process's effective arguments.
+    /// </remarks>
+    public bool ShowInCommandLine { get; }
+
+    /// <summary>
+    /// Gets the callback that produces the launch tool arguments.
+    /// </summary>
+    public Func<CommandLineArgsCallbackContext, Task> Callback { get; }
+
+    internal IArgCallbackAnnotation AsCallbackAnnotation() => this;
+
+    Task<IList<object>> IArgCallbackAnnotation.EvaluateOnceAsync(CommandLineArgsCallbackContext context)
+    {
+        lock (_lock)
+        {
+            _callbackTask ??= ExecuteCallbackAsync(context);
+            return _callbackTask;
+        }
+    }
+
+    void IArgCallbackAnnotation.ForgetCachedResult()
+    {
+        lock (_lock)
+        {
+            _callbackTask = null;
+        }
+    }
+
+    private async Task<IList<object>> ExecuteCallbackAsync(CommandLineArgsCallbackContext context)
+    {
+        await Callback(context).ConfigureAwait(false);
+        return context.Args.ToImmutableList();
+    }
+}
+
+/// <summary>
+/// Reports how many of the leading arguments in an execution configuration were produced by a
+/// <see cref="LaunchToolArgsCallbackAnnotation"/>, so that consumers that compose the actual command line
+/// (such as the DCP executable creator) can tell the tool-invocation prefix apart from the program arguments.
+/// </summary>
+/// <param name="Count">
+/// The number of leading arguments that form the tool-invocation prefix. This is normalized after value
+/// resolution to exclude arguments that resolve to <see langword="null"/>.
+/// </param>
+/// <param name="ShowInCommandLine">
+/// Mirrors <see cref="LaunchToolArgsCallbackAnnotation.ShowInCommandLine"/>.
+/// </param>
+internal sealed record LaunchToolArgumentsData(int Count, bool ShowInCommandLine) : IExecutionConfigurationData;
diff --git a/src/Aspire.Hosting/Dcp/DcpExecutor.cs b/src/Aspire.Hosting/Dcp/DcpExecutor.cs
index 3e297026163..87228f79059 100644
--- a/src/Aspire.Hosting/Dcp/DcpExecutor.cs
+++ b/src/Aspire.Hosting/Dcp/DcpExecutor.cs
@@ -1353,9 +1353,9 @@ private static void ForgetCachedCallbackResults(IResource resource)
             }
         }
 
-        if (resource.TryGetAnnotationsOfType<EntrypointArgsCallbackAnnotation>(out var entrypointArgsCallbacks))
+        if (resource.TryGetAnnotationsOfType<LaunchToolArgsCallbackAnnotation>(out var launchToolArgsCallbacks))
         {
-            foreach (var callback in entrypointArgsCallbacks)
+            foreach (var callback in launchToolArgsCallbacks)
             {
                 ((ICallbackResourceAnnotation<CommandLineArgsCallbackContext, IList<object>>)callback).ForgetCachedResult();
             }
diff --git a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
index ebd84d9eba2..3d6459c58a1 100644
--- a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
+++ b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
@@ -101,16 +101,25 @@ public async Task CreateObjectAsync(RenderedModelResource<Executable> er, EmptyC
 
         // The launch configuration is applied before the command line is composed because applying it can switch the
         // execution type to Process, and the composition depends on the final execution type: an IDE-launched
-        // resource does not receive its entrypoint arguments, a process-launched one does.
-        var resolvedEntrypointArgumentCount = configuration.AdditionalConfigurationData.OfType<EntrypointArgumentsData>().FirstOrDefault()?.Count ?? 0;
-        await ApplyLaunchConfigurationAsync(er, exe, resolvedEntrypointArgumentCount, cancellationToken).ConfigureAwait(false);
-
-        var omittedEntrypointArgumentCount = OmitEntrypointArguments(er, spec)
-            ? resolvedEntrypointArgumentCount
+        // resource does not receive the launch tool arguments its launch configuration already performs, a
+        // process-launched one does.
+        var launchToolArgumentsData = configuration.AdditionalConfigurationData.OfType<LaunchToolArgumentsData>().FirstOrDefault();
+        var resolvedLaunchToolArgumentCount = launchToolArgumentsData?.Count ?? 0;
+        await ApplyLaunchConfigurationAsync(er, exe, resolvedLaunchToolArgumentCount, cancellationToken).ConfigureAwait(false);
+
+        var omittedLaunchToolArgumentCount = OmitLaunchToolArguments(er, spec)
+            ? resolvedLaunchToolArgumentCount
             : 0;
 
         var executableArgumentStartIndex = spec.Args?.Count ?? 0;
-        var launchArgs = BuildLaunchArgs(er, spec, configuration.Arguments, executableArgumentStartIndex, omittedEntrypointArgumentCount);
+        var launchArgs = BuildLaunchArgs(
+            er,
+            spec,
+            configuration.Arguments,
+            executableArgumentStartIndex,
+            resolvedLaunchToolArgumentCount,
+            omittedLaunchToolArgumentCount,
+            launchToolArgumentsData?.ShowInCommandLine ?? true);
         if (!HasProjectLaunchArgsOverride(er.ModelResource))
         {
             AddDotnetRunArgsForExecutableAnnotatedProject(er, launchArgs, executableArgumentStartIndex);
@@ -127,7 +136,7 @@ public async Task CreateObjectAsync(RenderedModelResource<Executable> er, EmptyC
 
         // Argument and launch-configuration callbacks can change on restart. Derive fallback availability from the
         // final execution type and resolved command line every time instead of carrying a preparation-time guess.
-        spec.FallbackExecutionTypes = ShouldOfferProcessFallback(er.ModelResource, spec, omittedEntrypointArgumentCount)
+        spec.FallbackExecutionTypes = ShouldOfferProcessFallback(er.ModelResource, spec, omittedLaunchToolArgumentCount)
             ? [ExecutionType.Process]
             : null;
 
@@ -188,7 +197,7 @@ public async Task CreateObjectAsync(RenderedModelResource<Executable> er, EmptyC
     /// executables, so their "project" launch configuration is applied here for IDE/F5 parity with <c>AddProject</c>.
     /// All other types (plain executables and project subtypes like azure-functions) are also handled here.
     /// </remarks>
-    private async Task ApplyLaunchConfigurationAsync(RenderedModelResource<Executable> er, Executable exe, int resolvedEntrypointArgumentCount, CancellationToken cancellationToken)
+    private async Task ApplyLaunchConfigurationAsync(RenderedModelResource<Executable> er, Executable exe, int resolvedLaunchToolArgumentCount, CancellationToken cancellationToken)
     {
         if (er.ModelResource.HasAnnotationOfType<ForceProcessExecutionAnnotation>()
             || HasProjectLaunchArgsOverride(er.ModelResource)
@@ -232,36 +241,36 @@ private async Task ApplyLaunchConfigurationAsync(RenderedModelResource<Executabl
         }
         catch (Exception ex)
         {
-            if (HasIncompleteProcessCommand(er.ModelResource, supportsDebuggingAnnotation, resolvedEntrypointArgumentCount))
+            if (HasIncompleteProcessCommand(er.ModelResource, supportsDebuggingAnnotation, resolvedLaunchToolArgumentCount))
             {
                 // This project-backed executable suppressed its process scaffold because the custom launch
-                // configuration owns the entrypoint. With no resolved entrypoint to replace it, Process execution
-                // would run a bare tool command such as `dotnet <app-args>`.
+                // configuration performs the tool invocation. With no resolved prefix to replace it, Process
+                // execution would run a bare tool command such as `dotnet <app-args>`.
                 throw;
             }
 
-            // The command line is composed after this point, so Process execution receives the full entrypoint.
+            // The command line is composed after this point, so Process execution receives the full tool invocation.
             _logger.LogWarning(ex, "Failed to apply launch configuration for resource '{ResourceName}'. Falling back to process execution.", er.ModelResource.Name);
             exe.Spec.ExecutionType = ExecutionType.Process;
         }
     }
 
     /// <summary>
-    /// Determines whether the resource's entrypoint arguments must be omitted from the DCP executable spec because
-    /// it will be handled by IDE launch configuration.
+    /// Determines whether the resource's launch tool arguments must be omitted from the DCP executable spec because
+    /// the IDE launch configuration performs that tool invocation itself.
     /// </summary>
-    private bool OmitEntrypointArguments(RenderedModelResource<Executable> er, ExecutableSpec spec)
+    private bool OmitLaunchToolArguments(RenderedModelResource<Executable> er, ExecutableSpec spec)
     {
         if (spec.ExecutionType != ExecutionType.IDE)
         {
             return false;
         }
 
-        // Only withhold when the launch configuration that declared the entrypoint is the one actually in use.
-        // A launch configuration of a different type knows nothing about this entrypoint, so in that case the
-        // resource keeps its full command line.
+        // Only withhold when the launch configuration that claimed the tool invocation is the one actually in use.
+        // A launch configuration of a different type knows nothing about it, so in that case the resource keeps its
+        // full command line.
         return er.ModelResource.SupportsDebugging(_configuration, out var activeAnnotation)
-            && er.ModelResource.OwnsEntrypointArguments(activeAnnotation);
+            && er.ModelResource.HasLaunchToolArgsOwnedBy(activeAnnotation);
     }
 
     /// <summary>
@@ -270,12 +279,12 @@ private bool OmitEntrypointArguments(RenderedModelResource<Executable> er, Execu
     /// <remarks>
     /// A Process fallback runs the DCP Executable spec's command and args "as is", so it is only meaningful when
     /// those args form a runnable command. A DCP Executable spec has a single <c>args</c> field, so it cannot carry
-    /// both the IDE form and the process form of the command line: when the entrypoint prefix is omitted for the
+    /// both the IDE form and the process form of the command line: when the tool-invocation prefix is omitted for the
     /// IDE, no fallback can be offered.
     /// </remarks>
-    private bool ShouldOfferProcessFallback(IResource modelResource, ExecutableSpec spec, int omittedEntrypointArgumentCount)
+    private bool ShouldOfferProcessFallback(IResource modelResource, ExecutableSpec spec, int omittedLaunchToolArgumentCount)
     {
-        if (spec.ExecutionType != ExecutionType.IDE || omittedEntrypointArgumentCount > 0)
+        if (spec.ExecutionType != ExecutionType.IDE || omittedLaunchToolArgumentCount > 0)
         {
             return false;
         }
@@ -292,17 +301,17 @@ private bool ShouldOfferProcessFallback(IResource modelResource, ExecutableSpec
         }
 
         // A project-backed plain executable suppresses its `dotnet run` process scaffold when the active launch
-        // configuration owns the entrypoint. Even when that entrypoint resolves empty, the remaining command line
-        // is IDE-only and cannot be reused as a Process fallback.
-        return !HasIncompleteProcessCommand(modelResource, annotation, omittedEntrypointArgumentCount);
+        // configuration performs the tool invocation. Even when that prefix resolves empty, the remaining command
+        // line is IDE-only and cannot be reused as a Process fallback.
+        return !HasIncompleteProcessCommand(modelResource, annotation, omittedLaunchToolArgumentCount);
     }
 
-    private static bool HasIncompleteProcessCommand(IResource modelResource, SupportsDebuggingAnnotation annotation, int entrypointArgumentCount)
+    private static bool HasIncompleteProcessCommand(IResource modelResource, SupportsDebuggingAnnotation annotation, int launchToolArgumentCount)
     {
-        return entrypointArgumentCount == 0
+        return launchToolArgumentCount == 0
             && modelResource is not ProjectResource
             && modelResource.HasAnnotationOfType<IProjectMetadata>()
-            && modelResource.OwnsEntrypointArguments(annotation);
+            && modelResource.HasLaunchToolArgsOwnedBy(annotation);
     }
 
     private async Task PrepareProjectExecutablesAsync(CancellationToken cancellationToken)
@@ -699,7 +708,9 @@ private static List<LaunchArgument> BuildLaunchArgs(
         ExecutableSpec spec,
         IEnumerable<(string Value, bool IsSensitive)> appHostArgs,
         int executableArgumentStartIndex,
-        int omittedEntrypointArgumentCount
+        int launchToolArgumentCount,
+        int omittedLaunchToolArgumentCount,
+        bool showLaunchToolArgsInCommandLine
     )
     {
         // Launch args is the final list of args that are displayed in the UI and possibly added to the executable spec.
@@ -760,12 +771,25 @@ LaunchArgument CreateLaunchArgument(string value, bool isSensitive, bool executa
             return launchArgs;
         }
 
-        // In the situation where args are combined (process execution) the app host args are added after the launch profile args.
-        // Entrypoint arguments (the tool-invocation prefix such as `run ./cmd/api`) are always the leading app host
-        // args. When the IDE launch configuration owns them they must not be passed to the launched program, but they
-        // are still shown in the dashboard so the resource's real command line stays visible — the same treatment
-        // project launch-profile args get above.
-        launchArgs.AddRange(appHostArgList.Select((a, i) => CreateLaunchArgument(a.Value, a.IsSensitive, executable: i >= omittedEntrypointArgumentCount, display: true)));
+        // In the situation where args are combined (process execution) the app host args are added after the launch
+        // profile args. Launch tool arguments (the tool-invocation prefix such as `run ./cmd/api`) are always the
+        // leading app host args, and the two decisions about them are independent:
+        //
+        // - Executable: withheld only when the active IDE launch configuration performs the tool invocation itself,
+        //   because passing it on would run it twice.
+        // - Display: withheld only when the declaration asked for it. A prefix that the IDE performs is deliberately
+        //   still shown, because it is absent from the process's effective args and hiding it here too would leave
+        //   the dashboard showing a bare `go` plus the program arguments — the same treatment project launch-profile
+        //   args get above.
+        launchArgs.AddRange(appHostArgList.Select((a, i) =>
+        {
+            var isLaunchToolArg = i < launchToolArgumentCount;
+            return CreateLaunchArgument(
+                a.Value,
+                a.IsSensitive,
+                executable: i >= omittedLaunchToolArgumentCount,
+                display: showLaunchToolArgsInCommandLine || !isLaunchToolArg);
+        }));
 
         return launchArgs;
     }
diff --git a/src/Aspire.Hosting/ResourceBuilderExtensions.cs b/src/Aspire.Hosting/ResourceBuilderExtensions.cs
index 5eb37d9772a..7b95bb11780 100644
--- a/src/Aspire.Hosting/ResourceBuilderExtensions.cs
+++ b/src/Aspire.Hosting/ResourceBuilderExtensions.cs
@@ -4761,50 +4761,75 @@ public static IResourceBuilder<T> WithComputeEnvironment<T>(this IResourceBuilde
     }
 
     /// <summary>
-    /// Declares the resource's <em>entrypoint arguments</em>: the tool-invocation prefix that hosts the program,
-    /// for example <c>run ./cmd/api</c> for <c>go</c> or <c>-m flask</c> for <c>python</c>.
+    /// Declares the resource's <em>launch tool arguments</em>: the tool-invocation prefix that hosts the program,
+    /// for example <c>run ./cmd/api</c> for <c>go</c>, <c>-m flask</c> for <c>python</c>, or
+    /// <c>tool exec &lt;package&gt; --yes --</c> for <c>dotnet</c>.
     /// </summary>
     /// <param name="builder">The resource builder.</param>
-    /// <param name="launchConfigurationType">
-    /// The debug launch configuration type that owns this entrypoint, for example "go" or "python". This is the same
-    /// value passed to <c>WithDebugSupport</c>.
-    /// </param>
     /// <param name="callback">
-    /// Callback that produces the entrypoint arguments. It is invoked with an <em>empty</em>
+    /// Callback that produces the launch tool arguments. It is invoked with an <em>empty</em>
     /// <see cref="CommandLineArgsCallbackContext.Args"/> list; everything it adds becomes the leading arguments.
     /// </param>
+    /// <param name="ownedByLaunchConfigurationType">
+    /// The debug launch configuration type that performs this tool invocation itself, for example "go" or "python"
+    /// — the same value passed to <c>WithDebugSupport</c>. Leave this <see langword="null"/> (the default) when the
+    /// prefix is not a debugging concern and must always be passed to the launched program.
+    /// </param>
+    /// <param name="showInCommandLine">
+    /// Whether these arguments are part of the command line shown for the resource in the dashboard. Pass
+    /// <see langword="false"/> for a prefix that is pure invocation plumbing the user did not write and cannot act on.
+    /// </param>
     /// <returns>A reference to the <see cref="IResourceBuilder{T}"/>.</returns>
     /// <remarks>
     /// <para>
-    /// Entrypoint arguments are always placed ahead of every argument contributed by <c>WithArgs</c>, no matter when
+    /// Launch tool arguments are always placed ahead of every argument contributed by <c>WithArgs</c>, no matter when
     /// this method is called, and no <c>WithArgs</c> callback can observe or modify them. Declaring the tool
     /// invocation this way therefore avoids any dependency on the order in which resource builder methods are called.
     /// </para>
     /// <para>
-    /// When the resource is launched by an IDE using a launch configuration of
-    /// <paramref name="launchConfigurationType"/> (see <c>WithDebugSupport</c>), the launch configuration
-    /// already carries the tool invocation, so these arguments are not passed to the launched program. In every other
-    /// case — process execution, publish, or when a launch configuration of a different type is active — they are
-    /// part of the resource's command line.
+    /// When <paramref name="ownedByLaunchConfigurationType"/> is supplied and the resource is launched by an IDE
+    /// using a launch configuration of that type (see <c>WithDebugSupport</c>), the launch configuration already
+    /// carries the tool invocation, so these arguments are not passed to the launched program. In every other case
+    /// — process execution, publish, or when a launch configuration of a different type is active — they are part of
+    /// the resource's command line.
     /// </para>
     /// <para>
-    /// Calling this method more than once is allowed; the most recent declaration wins.
+    /// This has no effect on a container resource, which invokes its program through the image's <c>ENTRYPOINT</c>
+    /// rather than through a local tool. That matters for executables published as a Dockerfile, because
+    /// <see cref="ExecutableResourceBuilderExtensions.PublishAsDockerFile{T}(IResourceBuilder{T})"/> carries the
+    /// executable's annotations over to the generated container resource.
+    /// </para>
+    /// <para>
+    /// Calling this method more than once is allowed; the most recent declaration wins. It therefore declares a
+    /// single tool invocation rather than accumulating one, which is why it is the integration's own description of
+    /// how it launches the program, not a place for callers to append flags.
     /// </para>
     /// </remarks>
     [Experimental("ASPIREEXTENSION001", UrlFormat = "https://aka.ms/aspire/diagnostics/{0}")]
-    [AspireExportIgnore(Reason = "Generic debug launch configuration support is not part of the ATS surface.")]
-    public static IResourceBuilder<T> WithEntrypointArgs<T>(this IResourceBuilder<T> builder, string launchConfigurationType, Action<CommandLineArgsCallbackContext> callback)
+    [AspireExportIgnore(Reason = "Generic launch tool argument support is not part of the ATS surface.")]
+    public static IResourceBuilder<T> WithLaunchToolArgs<T>(
+        this IResourceBuilder<T> builder,
+        Action<CommandLineArgsCallbackContext> callback,
+        string? ownedByLaunchConfigurationType = null,
+        bool showInCommandLine = true)
         where T : IResourceWithArgs
     {
         ArgumentNullException.ThrowIfNull(builder);
-        ArgumentException.ThrowIfNullOrEmpty(launchConfigurationType);
         ArgumentNullException.ThrowIfNull(callback);
 
-        return builder.WithAnnotation(new EntrypointArgsCallbackAnnotation(launchConfigurationType, ctx =>
+        if (ownedByLaunchConfigurationType is not null)
         {
-            callback(ctx);
-            return Task.CompletedTask;
-        }));
+            ArgumentException.ThrowIfNullOrEmpty(ownedByLaunchConfigurationType);
+        }
+
+        return builder.WithAnnotation(new LaunchToolArgsCallbackAnnotation(
+            ctx =>
+            {
+                callback(ctx);
+                return Task.CompletedTask;
+            },
+            ownedByLaunchConfigurationType,
+            showInCommandLine));
     }
 
     /// <summary>
diff --git a/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs b/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
index 7ff67808987..89206e6ec89 100644
--- a/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
+++ b/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
@@ -338,10 +338,10 @@ public async Task AddDotnetProject_InDebugSession_KeepsDotnetRunArgs_WhenActiveC
     }
 
     [Fact]
-    public async Task AddDotnetProject_InDebugSession_OmitsDotnetRunScaffolding_WhenActiveCustomDebugSupportOwnsEntrypointArgs()
+    public async Task AddDotnetProject_InDebugSession_OmitsDotnetRunScaffolding_WhenActiveCustomDebugSupportOwnsLaunchToolArgs()
     {
-        // A stacked custom debug configuration with entrypoint arguments owns the tool invocation, so no
-        // Process fallback is offered and Spec.Args is composed from that entrypoint plus the program arguments.
+        // A stacked custom debug configuration with launch tool arguments owns the tool invocation, so no
+        // Process fallback is offered and Spec.Args is composed from that prefix plus the program arguments.
         // The `dotnet run …` scaffolding must be omitted; re-emitting it would duplicate the tool invocation.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
@@ -355,24 +355,24 @@ public async Task AddDotnetProject_InDebugSession_OmitsDotnetRunScaffolding_When
         var projectPath = Path.Combine(builder.AppHostDirectory, "MyService", "MyService.csproj");
         var app = builder.AddDotnetProject("svc", projectPath, o => o.ExcludeLaunchProfile = true)
                          .WithArgs("--config", "prod.yaml")
-                         .WithEntrypointArgs("custom", ctx => ctx.Args.Add("entrypoint-arg"))
+                         .WithLaunchToolArgs(ctx => ctx.Args.Add("launch-tool-arg"), ownedByLaunchConfigurationType: "custom")
                          .WithDebugSupport(_ => new ExecutableLaunchConfiguration("custom"), "custom");
 
         using var application = builder.Build();
         var args = await ArgumentEvaluator.GetArgumentListAsync(app.Resource, application.Services);
 
-        // Only the custom entrypoint plus the user args remain; no `dotnet run …` scaffolding.
+        // Only the custom tool invocation plus the user args remain; no `dotnet run …` scaffolding.
         Assert.Collection(args,
-            arg => Assert.Equal("entrypoint-arg", arg),
+            arg => Assert.Equal("launch-tool-arg", arg),
             arg => Assert.Equal("--config", arg),
             arg => Assert.Equal("prod.yaml", arg));
     }
 
     [Fact]
-    public async Task AddDotnetProject_InDebugSession_OmitsDotnetRunScaffolding_WhenOwnedEntrypointIsEmpty()
+    public async Task AddDotnetProject_InDebugSession_OmitsDotnetRunScaffolding_WhenOwnedLaunchToolArgsAreEmpty()
     {
-        // Entrypoint ownership, rather than the number of values it produces, determines who supplies the project
-        // launch. A no-op custom entrypoint must still suppress `dotnet run`; DCP consequently cannot offer this
+        // Launch tool argument ownership, rather than the number of values produced, determines who supplies the project
+        // launch. A no-op custom tool invocation must still suppress `dotnet run`; DCP consequently cannot offer this
         // IDE-only command line as a Process fallback.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
@@ -386,7 +386,7 @@ public async Task AddDotnetProject_InDebugSession_OmitsDotnetRunScaffolding_When
         var projectPath = Path.Combine(builder.AppHostDirectory, "MyService", "MyService.csproj");
         var app = builder.AddDotnetProject("svc", projectPath, o => o.ExcludeLaunchProfile = true)
                          .WithArgs("--config", "prod.yaml")
-                         .WithEntrypointArgs("custom", static _ => { })
+                         .WithLaunchToolArgs(static _ => { }, ownedByLaunchConfigurationType: "custom")
                          .WithDebugSupport(_ => new ExecutableLaunchConfiguration("custom"), "custom");
 
         using var application = builder.Build();
diff --git a/tests/Aspire.Hosting.Go.Tests/AddGoAppTests.cs b/tests/Aspire.Hosting.Go.Tests/AddGoAppTests.cs
index 670e366d671..ce352fbd1fe 100644
--- a/tests/Aspire.Hosting.Go.Tests/AddGoAppTests.cs
+++ b/tests/Aspire.Hosting.Go.Tests/AddGoAppTests.cs
@@ -540,7 +540,7 @@ public async Task WithVSCodeDebugging_OmitsBuildFlagsWhenNoneConfigured()
     [Fact]
     public async Task WithVSCodeDebugging_KeepsGoToolArgumentsInTheAppModel()
     {
-        // The `go run [build flags] <pkg>` prefix is declared as entrypoint arguments, so it stays part of the
+        // The `go run [build flags] <pkg>` prefix is declared as launch tool arguments, so it stays part of the
         // resource's command line even during a debug session. Withholding it from the launched program is a
         // DCP-level concern (see DcpExecutorTests), which keeps the app model and the dashboard accurate.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
@@ -580,7 +580,7 @@ public async Task WithVSCodeDebugging_KeepsGoToolArgumentsInTheAppModel()
 
         // The "go" launch configuration owns that prefix, which is what makes DCP withhold it from the debugger.
         var debugAnnotation = app.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().Last();
-        Assert.True(app.Resource.OwnsEntrypointArguments(debugAnnotation));
+        Assert.True(app.Resource.HasLaunchToolArgsOwnedBy(debugAnnotation));
     }
 
     [Fact]
diff --git a/tests/Aspire.Hosting.Python.Tests/AddPythonAppTests.cs b/tests/Aspire.Hosting.Python.Tests/AddPythonAppTests.cs
index 0c3cec1aca8..48fb04d1718 100644
--- a/tests/Aspire.Hosting.Python.Tests/AddPythonAppTests.cs
+++ b/tests/Aspire.Hosting.Python.Tests/AddPythonAppTests.cs
@@ -1419,9 +1419,9 @@ public async Task WithDebugSupport_KeepsScriptArgumentInTheAppModelForScriptEntr
             arg => Assert.Equal("arg1", arg),
             arg => Assert.Equal("arg2", arg));
 
-        // The "python" launch configuration owns the entrypoint, which is what makes DCP withhold it.
+        // The "python" launch configuration owns the launch tool arguments, which is what makes DCP withhold them.
         var debugAnnotation = resource.Annotations.OfType<SupportsDebuggingAnnotation>().Last();
-        Assert.True(resource.OwnsEntrypointArguments(debugAnnotation));
+        Assert.True(resource.HasLaunchToolArgsOwnedBy(debugAnnotation));
     }
 
     [Fact]
@@ -1503,9 +1503,9 @@ public async Task WithDebugSupport_KeepsModuleArgumentsInTheAppModelForModuleEnt
             arg => Assert.Equal("flask", arg),
             arg => Assert.Equal("run", arg));
 
-        // The "python" launch configuration owns the entrypoint, which is what makes DCP withhold it.
+        // The "python" launch configuration owns the launch tool arguments, which is what makes DCP withhold them.
         var debugAnnotation = resource.Annotations.OfType<SupportsDebuggingAnnotation>().Last();
-        Assert.True(resource.OwnsEntrypointArguments(debugAnnotation));
+        Assert.True(resource.HasLaunchToolArgsOwnedBy(debugAnnotation));
     }
 
     [Fact]
diff --git a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
index f9b18b0ec58..b0b89d448be 100644
--- a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
+++ b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
@@ -3672,16 +3672,16 @@ public async Task PersistentPlainExecutable_ExtensionMode_RunsInProcess()
     }
 
     [Fact]
-    public async Task ProjectResource_WithEntrypointArgumentsDebugSupport_DoesNotOfferProcessFallback_InDebugSession()
+    public async Task ProjectResource_WithLaunchToolArgsDebugSupport_DoesNotOfferProcessFallback_InDebugSession()
     {
-        // A ProjectResource can, via the generic WithEntrypointArgs API, declare a tool
+        // A ProjectResource can, via the generic WithLaunchToolArgs API, declare a tool
         // invocation prefix (ProjectResource implements IResourceWithArgs). That prefix is withheld from Spec.Args
         // for the IDE, so DCP must NOT advertise a Process fallback that would later run a broken command. This
         // mirrors the guard already applied to plain executables in PreparePlainExecutables.
         var builder = DistributedApplication.CreateBuilder();
         var projectBuilder = builder.AddProject<TestProject>("proj", launchProfileName: null);
 
-        // Replace the default "project" debug support with a custom launch type that also owns entrypoint arguments.
+        // Replace the default "project" debug support with a custom launch type that also owns the launch tool arguments.
         var defaultAnnotation = projectBuilder.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().FirstOrDefault();
         if (defaultAnnotation is not null)
         {
@@ -3689,7 +3689,7 @@ public async Task ProjectResource_WithEntrypointArgumentsDebugSupport_DoesNotOff
         }
 
         projectBuilder
-            .WithEntrypointArgs("test", ctx => ctx.Args.Add("run"))
+            .WithLaunchToolArgs(ctx => ctx.Args.Add("run"), ownedByLaunchConfigurationType: "test")
             .WithDebugSupport(
                 mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
                 "test");
@@ -3716,11 +3716,11 @@ public async Task ProjectResource_WithEntrypointArgumentsDebugSupport_DoesNotOff
     }
 
     [Fact]
-    public async Task ProjectResource_WithoutEntrypointArguments_OffersProcessFallback_InDebugSession()
+    public async Task ProjectResource_WithoutLaunchToolArgs_OffersProcessFallback_InDebugSession()
     {
-        // The common case: a default AddProject ("project" launch type, no entrypoint arguments) keeps the
+        // The common case: a default AddProject ("project" launch type, no launch tool arguments) keeps the
         // Process fallback so an IDE launch rejection can still start the project. Guards against the
-        // entrypoint-argument guard accidentally dropping the fallback for ordinary projects.
+        // launch-tool-argument guard accidentally dropping the fallback for ordinary projects.
         var builder = DistributedApplication.CreateBuilder();
         builder.AddProject<Projects.ServiceA>("proj", launchProfileName: null);
 
@@ -4445,7 +4445,7 @@ public async Task Project_WithTerminal_RunsAsProcess_InDebugSessionWhenDebugSupp
 
         var resource = builder.AddProject<Projects.ServiceA>("ServiceA").WithTerminal();
         resource
-            .WithEntrypointArgs("project", ctx => ctx.Args.Add("entrypoint-arg"))
+            .WithLaunchToolArgs(ctx => ctx.Args.Add("launch-tool-arg"), ownedByLaunchConfigurationType: "project")
             .WithDebugSupport(
                 mode => new ProjectLaunchConfiguration { ProjectPath = "/test/path", Mode = mode },
                 "project");
@@ -4473,9 +4473,9 @@ public async Task Project_WithTerminal_RunsAsProcess_InDebugSessionWhenDebugSupp
 
         var exe = GetCreatedExecutableForResource(kubernetesService, "ServiceA");
         Assert.Equal(ExecutionType.Process, exe.Spec.ExecutionType);
-        // Process execution keeps the full command line, so the entrypoint prefix is passed through.
+        // Process execution keeps the full command line, so the tool-invocation prefix is passed through.
         Assert.NotNull(exe.Spec.Args);
-        Assert.Contains("entrypoint-arg", exe.Spec.Args);
+        Assert.Contains("launch-tool-arg", exe.Spec.Args);
         Assert.NotNull(exe.Spec.Terminal);
     }
 
@@ -5901,9 +5901,9 @@ static Task<ProjectLaunchConfiguration> CreateProjectLaunchConfiguration(string
     }
 
     [Fact]
-    public async Task PlainExecutable_ExtensionMode_EntrypointArgsDebugSupport_WithholdsPrefixAndOmitsProcessFallback()
+    public async Task PlainExecutable_ExtensionMode_LaunchToolArgsDebugSupport_WithholdsPrefixAndOmitsProcessFallback()
     {
-        // A non-"project" debuggable executable that declares entrypoint arguments (e.g. Go/Python, where the IDE
+        // A non-"project" debuggable executable that declares launch tool arguments (e.g. Go/Python, where the IDE
         // debugger owns the `go run <pkg>` / `python -m <mod>` tool invocation) must not pass the prefix to the
         // launched program. Because the DCP Executable spec has a single args field, the resulting Spec.Args cannot
         // also serve a Process fallback, so no fallback is advertised even though the launch type is not "project".
@@ -5912,7 +5912,7 @@ public async Task PlainExecutable_ExtensionMode_EntrypointArgsDebugSupport_Withh
         var debuggableExecutable = new TestExecutableResource("test-working-directory");
         builder.AddResource(debuggableExecutable)
             .WithArgs("app-arg")
-            .WithEntrypointArgs("test", static ctx => ctx.Args.Add("run"))
+            .WithLaunchToolArgs(static ctx => ctx.Args.Add("run"), ownedByLaunchConfigurationType: "test")
             .WithDebugSupport(
                 mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
                 "test");
@@ -5955,9 +5955,9 @@ public async Task PlainExecutable_ExtensionMode_EntrypointArgsDebugSupport_Withh
     }
 
     [Fact]
-    public async Task PlainExecutable_ExtensionMode_EmptyEntrypointArgs_OffersProcessFallback()
+    public async Task PlainExecutable_ExtensionMode_EmptyLaunchToolArgs_OffersProcessFallback()
     {
-        // Declaring entrypoint arguments does not always produce a prefix — a Python "Executable" entrypoint
+        // Declaring launch tool arguments does not always produce a prefix — a Python "Executable" entrypoint
         // contributes nothing, for example. Nothing is withheld from Spec.Args in that case, so the Process
         // fallback remains usable and must be advertised.
         var builder = DistributedApplication.CreateBuilder();
@@ -5965,7 +5965,7 @@ public async Task PlainExecutable_ExtensionMode_EmptyEntrypointArgs_OffersProces
         var debuggableExecutable = new TestExecutableResource("test-working-directory");
         builder.AddResource(debuggableExecutable)
             .WithArgs("app-arg")
-            .WithEntrypointArgs("test", static _ => { })
+            .WithLaunchToolArgs(static _ => { }, ownedByLaunchConfigurationType: "test")
             .WithDebugSupport(
                 mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
                 "test");
@@ -5994,16 +5994,94 @@ public async Task PlainExecutable_ExtensionMode_EmptyEntrypointArgs_OffersProces
     }
 
     [Fact]
-    public async Task PlainExecutable_ExtensionMode_EntrypointArgsDebugSupport_LaunchConfigFailure_FallsBackWithFullCommandLine()
+    public async Task PlainExecutable_UnownedLaunchToolArgs_AreExecutedButCanBeHiddenFromTheCommandLine()
+    {
+        // Forward-compatibility coverage for https://github.com/microsoft/aspire/issues/18904: a tool-invocation
+        // prefix that is not a debugging concern at all (the `dotnet tool exec <pkg> --yes --` shape) declares no
+        // owning launch configuration type, so it is always executed, and opts out of the displayed command line
+        // because it is plumbing the user neither wrote nor can act on.
+        var builder = DistributedApplication.CreateBuilder();
+
+        var resource = new TestExecutableResource("test-working-directory");
+        builder.AddResource(resource)
+            .WithArgs("app-arg")
+            .WithLaunchToolArgs(
+                static ctx =>
+                {
+                    ctx.Args.Add("tool");
+                    ctx.Args.Add("exec");
+                },
+                showInCommandLine: false);
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetesService, "TestExecutable");
+        Assert.Equal(ExecutionType.Process, exe.Spec.ExecutionType);
+        Assert.Equal(["tool", "exec", "app-arg"], exe.Spec.Args);
+
+        // The prefix runs but is absent from the dashboard command line. It stays visible in the resource details
+        // pane regardless, because that pane reports the process's effective arguments.
+        Assert.True(exe.TryGetAnnotationAsObjectList<AppLaunchArgumentAnnotation>(CustomResource.ResourceAppArgsAnnotation, out var displayArgs));
+        var displayArg = Assert.Single(displayArgs);
+        Assert.Equal("app-arg", displayArg.Argument);
+        Assert.Equal(2, displayArg.EffectiveArgumentIndex);
+    }
+
+    [Fact]
+    public async Task PlainExecutable_ExtensionMode_UnownedLaunchToolArgs_AreNotWithheldFromTheLaunchedProgram()
+    {
+        // Launch tool arguments that name no owning launch configuration type are not a debugging concern, so an
+        // active launch configuration must not withhold them — otherwise the launched program would lose a prefix
+        // no debugger ever performs. The Process fallback stays available for the same reason.
+        var builder = DistributedApplication.CreateBuilder();
+
+        var resource = new TestExecutableResource("test-working-directory");
+        builder.AddResource(resource)
+            .WithArgs("app-arg")
+            .WithLaunchToolArgs(static ctx => ctx.Args.Add("run"))
+            .WithDebugSupport(
+                mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
+                "test");
+
+        var configDict = new Dictionary<string, string?>
+        {
+            [DcpExecutor.DebugSessionPortVar] = "12345",
+            [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["test"] }),
+            [KnownConfigNames.ExtensionEndpoint] = "http://localhost:1234",
+            [KnownConfigNames.DebugSessionRunMode] = "Debug"
+        };
+        var configuration = new ConfigurationBuilder().AddInMemoryCollection(configDict).Build();
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService, configuration: configuration);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetesService, "TestExecutable");
+        Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
+        Assert.Equal(["run", "app-arg"], exe.Spec.Args);
+        Assert.NotNull(exe.Spec.FallbackExecutionTypes);
+        Assert.Equal(ExecutionType.Process, Assert.Single(exe.Spec.FallbackExecutionTypes));
+    }
+
+    [Fact]
+    public async Task PlainExecutable_ExtensionMode_LaunchToolArgsDebugSupport_LaunchConfigFailure_FallsBackWithFullCommandLine()
     {
         // When the launch configuration producer throws, the resource switches to Process execution before its
-        // command line is composed, so the entrypoint prefix is emitted and the fallback runs the real command.
+        // command line is composed, so the tool-invocation prefix is emitted and the fallback runs the real command.
         var builder = DistributedApplication.CreateBuilder();
 
         var resource = new TestExecutableResource("test-working-directory");
         builder.AddResource(resource)
             .WithArgs("app-arg")
-            .WithEntrypointArgs("test", static ctx => ctx.Args.Add("run"))
+            .WithLaunchToolArgs(static ctx => ctx.Args.Add("run"), ownedByLaunchConfigurationType: "test")
             .WithDebugSupport(
                 ThrowingLaunchConfiguration,
                 "test");
@@ -6045,16 +6123,16 @@ static Task<ExecutableLaunchConfiguration> ThrowingLaunchConfiguration(string mo
     }
 
     [Fact]
-    public async Task PlainExecutable_ExtensionMode_NullEntrypointArgument_DoesNotOmitApplicationArgument()
+    public async Task PlainExecutable_ExtensionMode_NullLaunchToolArgument_DoesNotOmitApplicationArgument()
     {
-        // Entrypoint values can resolve to null and disappear from the final argument list. The resolved prefix
+        // Launch tool argument values can resolve to null and disappear from the final argument list. The resolved prefix
         // boundary must shrink with them so the first ordinary argument remains executable.
         var builder = DistributedApplication.CreateBuilder();
 
         var resource = new TestExecutableResource("test-working-directory");
         builder.AddResource(resource)
             .WithArgs("app-arg")
-            .WithEntrypointArgs("test", static ctx => ctx.Args.Add(NullValueProvider.Instance))
+            .WithLaunchToolArgs(static ctx => ctx.Args.Add(NullValueProvider.Instance), ownedByLaunchConfigurationType: "test")
             .WithDebugSupport(
                 mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
                 "test");
@@ -6081,10 +6159,10 @@ public async Task PlainExecutable_ExtensionMode_NullEntrypointArgument_DoesNotOm
     }
 
     [Fact]
-    public async Task DotnetProjectExecutable_EmptyOwnedEntrypoint_DoesNotOfferBrokenProcessFallback()
+    public async Task DotnetProjectExecutable_EmptyOwnedLaunchToolArgs_DoesNotOfferBrokenProcessFallback()
     {
         // DotnetProjectResource suppresses its `dotnet run` scaffold when a custom launch configuration owns the
-        // entrypoint. An empty entrypoint therefore leaves an IDE-only `dotnet <app-args>` command, not a runnable
+        // tool invocation. An empty prefix therefore leaves an IDE-only `dotnet <app-args>` command, not a runnable
         // Process fallback.
         var builder = DistributedApplication.CreateBuilder();
 
@@ -6092,7 +6170,7 @@ public async Task DotnetProjectExecutable_EmptyOwnedEntrypoint_DoesNotOfferBroke
         builder.AddResource(resource)
             .WithAnnotation(new TestProjectWithLaunchSettings())
             .WithArgs("app-arg")
-            .WithEntrypointArgs("custom", static _ => { })
+            .WithLaunchToolArgs(static _ => { }, ownedByLaunchConfigurationType: "custom")
             .WithDebugSupport(
                 mode => new ExecutableLaunchConfiguration("custom") { Mode = mode },
                 "custom");
@@ -6119,7 +6197,7 @@ public async Task DotnetProjectExecutable_EmptyOwnedEntrypoint_DoesNotOfferBroke
     }
 
     [Fact]
-    public async Task DotnetProjectExecutable_EmptyOwnedEntrypoint_LaunchConfigFailureDoesNotRunBrokenProcessCommand()
+    public async Task DotnetProjectExecutable_EmptyOwnedLaunchToolArgs_LaunchConfigFailureDoesNotRunBrokenProcessCommand()
     {
         var builder = DistributedApplication.CreateBuilder();
 
@@ -6127,7 +6205,7 @@ public async Task DotnetProjectExecutable_EmptyOwnedEntrypoint_LaunchConfigFailu
         builder.AddResource(resource)
             .WithAnnotation(new TestProjectWithLaunchSettings())
             .WithArgs("app-arg")
-            .WithEntrypointArgs("custom", static _ => { })
+            .WithLaunchToolArgs(static _ => { }, ownedByLaunchConfigurationType: "custom")
             .WithDebugSupport(
                 ThrowingLaunchConfiguration,
                 "custom");
@@ -6171,7 +6249,7 @@ static ExecutableLaunchConfiguration ThrowingLaunchConfiguration(string mode)
     [Fact]
     public async Task PlainExecutable_ExtensionMode_ProcessFallbackIsRecomputedOnRestart()
     {
-        // Restart invalidates entrypoint callback caches without rerunning preparation. Vary the prefix across
+        // Restart invalidates launch tool callback caches without rerunning preparation. Vary the prefix across
         // creations to prove fallback metadata follows the newly resolved command rather than stale prepared state.
         var builder = DistributedApplication.CreateBuilder();
         var callbackCount = 0;
@@ -6179,15 +6257,15 @@ public async Task PlainExecutable_ExtensionMode_ProcessFallbackIsRecomputedOnRes
         var resource = new TestExecutableResource("test-working-directory");
         builder.AddResource(resource)
             .WithArgs("app-arg")
-            .WithEntrypointArgs(
-                "test",
+            .WithLaunchToolArgs(
                 ctx =>
                 {
                     if (Interlocked.Increment(ref callbackCount) == 2)
                     {
                         ctx.Args.Add("run");
                     }
-                })
+                },
+                ownedByLaunchConfigurationType: "test")
             .WithDebugSupport(
                 mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
                 "test");
diff --git a/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs b/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs
index 3386fc9f2fa..0bd545a9944 100644
--- a/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs
+++ b/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs
@@ -165,30 +165,30 @@ public void WithDebugSupportRejectsAValueTaskReturningSynchronousProducer()
     }
 
     [Fact]
-    public async Task WithEntrypointArgsLeadTheCommandLine()
+    public async Task WithLaunchToolArgsLeadTheCommandLine()
     {
-        // The entrypoint arguments are the tool-invocation prefix, so they always come first and the program's own
+        // The launch tool arguments are the tool-invocation prefix, so they always come first and the program's own
         // arguments follow, regardless of the launch configuration in effect.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
         var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
             .WithArgs("base-arg")
-            .WithEntrypointArgs("go", ctx => ctx.Args.Add("entrypoint-arg"))
+            .WithLaunchToolArgs(ctx => ctx.Args.Add("launch-tool-arg"), ownedByLaunchConfigurationType: "go")
             .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go");
 
         var args = await ArgumentEvaluator.GetArgumentListAsync(executable.Resource);
 
         Assert.Collection(args,
-            arg => Assert.Equal("entrypoint-arg", arg),
+            arg => Assert.Equal("launch-tool-arg", arg),
             arg => Assert.Equal("base-arg", arg));
     }
 
     [Theory]
     [InlineData(true)]
     [InlineData(false)]
-    public async Task WithEntrypointArgsAreOrderIndependent(bool entrypointArgsFirst)
+    public async Task WithLaunchToolArgsAreOrderIndependent(bool launchToolArgsFirst)
     {
-        // Regression coverage for https://github.com/microsoft/aspire/issues/18929: the entrypoint arguments used to
+        // Regression coverage for https://github.com/microsoft/aspire/issues/18929: the launch tool arguments used to
         // be applied by an ordinary WithArgs callback that *removed* the prefix, which only worked when
         // WithDebugSupport happened to be called after the callback that added it. Declaring the prefix separately
         // instead of subtracting it must produce the same command line either way.
@@ -204,17 +204,17 @@ public async Task WithEntrypointArgsAreOrderIndependent(bool entrypointArgsFirst
         var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
             .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go");
 
-        if (entrypointArgsFirst)
+        if (launchToolArgsFirst)
         {
             executable
-                .WithEntrypointArgs("go", ctx => ctx.Args.Add("run"))
+                .WithLaunchToolArgs(ctx => ctx.Args.Add("run"), ownedByLaunchConfigurationType: "go")
                 .WithArgs("base-arg");
         }
         else
         {
             executable
                 .WithArgs("base-arg")
-                .WithEntrypointArgs("go", ctx => ctx.Args.Add("run"));
+                .WithLaunchToolArgs(ctx => ctx.Args.Add("run"), ownedByLaunchConfigurationType: "go");
         }
 
         var args = await ArgumentEvaluator.GetArgumentListAsync(executable.Resource);
@@ -225,14 +225,14 @@ public async Task WithEntrypointArgsAreOrderIndependent(bool entrypointArgsFirst
     }
 
     [Fact]
-    public async Task WithEntrypointArgsSurviveAnArgsCallbackThatClearsTheList()
+    public async Task WithLaunchToolArgsSurviveAnArgsCallbackThatClearsTheList()
     {
-        // No WithArgs callback can observe or clear the entrypoint prefix: it is evaluated separately and inserted
+        // No WithArgs callback can observe or clear the tool-invocation prefix: it is evaluated separately and inserted
         // ahead of the arguments those callbacks produce.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
         var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
-            .WithEntrypointArgs("go", ctx => ctx.Args.Add("entrypoint-arg"))
+            .WithLaunchToolArgs(ctx => ctx.Args.Add("launch-tool-arg"), ownedByLaunchConfigurationType: "go")
             .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go")
             .WithArgs("discarded")
             .WithArgs(ctx =>
@@ -244,12 +244,12 @@ public async Task WithEntrypointArgsSurviveAnArgsCallbackThatClearsTheList()
         var args = await ArgumentEvaluator.GetArgumentListAsync(executable.Resource);
 
         Assert.Collection(args,
-            arg => Assert.Equal("entrypoint-arg", arg),
+            arg => Assert.Equal("launch-tool-arg", arg),
             arg => Assert.Equal("only-arg", arg));
     }
 
     [Fact]
-    public async Task WithEntrypointArgsRemainInTheAppModelDuringADebugSession()
+    public async Task WithLaunchToolArgsRemainInTheAppModelDuringADebugSession()
     {
         // Withholding the prefix is a DCP-level concern. The application model must keep describing the real
         // command line so the dashboard, the manifest and GetArgumentValuesAsync() consumers stay accurate.
@@ -264,7 +264,7 @@ public async Task WithEntrypointArgsRemainInTheAppModelDuringADebugSession()
 
         var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
             .WithArgs("base-arg")
-            .WithEntrypointArgs("go", ctx => ctx.Args.Add("run"))
+            .WithLaunchToolArgs(ctx => ctx.Args.Add("run"), ownedByLaunchConfigurationType: "go")
             .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go");
 
         var args = await ArgumentEvaluator.GetArgumentListAsync(executable.Resource);
@@ -275,25 +275,25 @@ public async Task WithEntrypointArgsRemainInTheAppModelDuringADebugSession()
     }
 
     [Fact]
-    public void WithEntrypointArgsAreOwnedByMatchingLaunchConfigurationType()
+    public void WithLaunchToolArgsAreOwnedByMatchingLaunchConfigurationType()
     {
-        // The entrypoint is owned by the launch configuration type it was declared with, so a launch configuration
+        // The tool invocation is owned by the launch configuration type it was declared with, so a launch configuration
         // of a different type does not claim it.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
         var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
-            .WithEntrypointArgs("go", ctx => ctx.Args.Add("run"))
+            .WithLaunchToolArgs(ctx => ctx.Args.Add("run"), ownedByLaunchConfigurationType: "go")
             .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go")
             .WithDebugSupport(_ => new ExecutableLaunchConfiguration("project"), "project");
 
         var annotations = executable.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().ToList();
         Assert.Collection(annotations,
-            annotation => Assert.True(executable.Resource.OwnsEntrypointArguments(annotation)),
-            annotation => Assert.False(executable.Resource.OwnsEntrypointArguments(annotation)));
+            annotation => Assert.True(executable.Resource.HasLaunchToolArgsOwnedBy(annotation)),
+            annotation => Assert.False(executable.Resource.HasLaunchToolArgsOwnedBy(annotation)));
     }
 
     [Fact]
-    public void WithDebugSupportDoesNotOwnEntrypointArgumentsWithoutWithEntrypointArgs()
+    public void WithDebugSupportDoesNotOwnLaunchToolArgsWithoutWithLaunchToolArgs()
     {
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
@@ -301,19 +301,19 @@ public void WithDebugSupportDoesNotOwnEntrypointArgumentsWithoutWithEntrypointAr
             .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go");
 
         var annotation = executable.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().Single();
-        Assert.False(executable.Resource.OwnsEntrypointArguments(annotation));
+        Assert.False(executable.Resource.HasLaunchToolArgsOwnedBy(annotation));
     }
 
     [Fact]
-    public async Task WithEntrypointArgsAreRegisteredInPublishMode()
+    public async Task WithLaunchToolArgsAreRegisteredInPublishMode()
     {
-        // Debug support is run-mode only, but the entrypoint describes how the resource is invoked in general and
+        // Debug support is run-mode only, but the launch tool arguments describe how the resource is invoked in general and
         // must survive into the manifest and generated container images.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Publish);
 
         var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
             .WithArgs("base-arg")
-            .WithEntrypointArgs("go", ctx => ctx.Args.Add("run"))
+            .WithLaunchToolArgs(ctx => ctx.Args.Add("run"), ownedByLaunchConfigurationType: "go")
             .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go");
 
         Assert.Empty(executable.Resource.Annotations.OfType<SupportsDebuggingAnnotation>());
@@ -326,7 +326,7 @@ public async Task WithEntrypointArgsAreRegisteredInPublishMode()
     }
 
     [Fact]
-    public async Task WithEntrypointArgsAreNotCarriedIntoAPublishedContainer()
+    public async Task WithLaunchToolArgsAreNotCarriedIntoAPublishedContainer()
     {
         // PublishAsDockerFile reuses the executable's annotations for the generated container resource, but a
         // container invokes the program through the image's ENTRYPOINT, so repeating the tool prefix in the
@@ -335,7 +335,7 @@ public async Task WithEntrypointArgsAreNotCarriedIntoAPublishedContainer()
 
         builder.AddExecutable("myexe", "command", "workingdirectory")
             .WithArgs("base-arg")
-            .WithEntrypointArgs("go", ctx => ctx.Args.Add("run"))
+            .WithLaunchToolArgs(ctx => ctx.Args.Add("run"), ownedByLaunchConfigurationType: "go")
             .WithDebugSupport(_ => new ExecutableLaunchConfiguration("go"), "go")
             .PublishAsDockerFile();
 

From 73b2312aaa394683e55facf7c56d08a263b320e7 Mon Sep 17 00:00:00 2001
From: Karol Zadora-Przylecki <karolz@microsoft.com>
Date: Thu, 6 Aug 2026 13:22:52 -0700
Subject: [PATCH 04/13] Address feedback from Adam

---
 .../PythonAppResourceBuilderExtensions.cs     |   8 +-
 ...ArgumentsExecutionConfigurationGatherer.cs |  17 +-
 .../ExecutionConfigurationGathererContext.cs  |  77 +++++----
 .../LaunchToolArgsCallbackAnnotation.cs       |   9 +-
 .../ApplicationModel/ResourceExtensions.cs    |  47 ++++++
 src/Aspire.Hosting/Dcp/ExecutableCreator.cs   |  14 +-
 .../AddPythonAppTests.cs                      |   5 +-
 .../Dcp/DcpExecutorTests.cs                   | 158 ++++++++++++++++++
 ...ExecutableResourceBuilderExtensionTests.cs |  41 ++++-
 .../ResourceDependencyTests.cs                |  61 +++++++
 10 files changed, 380 insertions(+), 57 deletions(-)

diff --git a/src/Aspire.Hosting.Python/PythonAppResourceBuilderExtensions.cs b/src/Aspire.Hosting.Python/PythonAppResourceBuilderExtensions.cs
index 9ee2cdce0b7..ba2d5eb70c1 100644
--- a/src/Aspire.Hosting.Python/PythonAppResourceBuilderExtensions.cs
+++ b/src/Aspire.Hosting.Python/PythonAppResourceBuilderExtensions.cs
@@ -1020,8 +1020,8 @@ public static IResourceBuilder<T> WithDebugging<T>(
     /// <item><description><b>Executable</b>: Runs the executable directly from the virtual environment</description></item>
     /// </list>
     /// <para>
-    /// <b>Note:</b> The entrypoint arguments always lead the resource's command line, so arguments added with
-    /// <c>WithArgs</c> before or after this call are preserved and stay after the entrypoint.
+    /// <b>Important:</b> This method resets all command-line arguments. If you need to add arguments after changing
+    /// the entrypoint, call <c>WithArgs</c> after this method.
     /// </para>
     /// </remarks>
     /// <example>
@@ -1065,6 +1065,10 @@ public static IResourceBuilder<T> WithEntrypoint<T>(
         },
         ResourceAnnotationMutationBehavior.Replace);
 
+        // Arguments already registered for the previous entrypoint may be invalid for the replacement. Keep this
+        // clear in the ordinary argument segment so arguments registered after WithEntrypoint are preserved.
+        builder.WithArgs(static context => context.Args.Clear());
+
         builder.WithLaunchToolArgs(static context =>
         {
             if (!context.Resource.TryGetLastAnnotation<PythonEntrypointAnnotation>(out var existingAnnotation))
diff --git a/src/Aspire.Hosting/ApplicationModel/ArgumentsExecutionConfigurationGatherer.cs b/src/Aspire.Hosting/ApplicationModel/ArgumentsExecutionConfigurationGatherer.cs
index 4e777f75f7d..016c7bd672b 100644
--- a/src/Aspire.Hosting/ApplicationModel/ArgumentsExecutionConfigurationGatherer.cs
+++ b/src/Aspire.Hosting/ApplicationModel/ArgumentsExecutionConfigurationGatherer.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Immutable;
 using Microsoft.Extensions.Logging;
 
 namespace Aspire.Hosting.ApplicationModel;
@@ -38,13 +39,12 @@ public async ValueTask GatherAsync(IExecutionConfigurationGathererContext contex
 
     /// <summary>
     /// Evaluates the resource's launch tool arguments (the tool-invocation prefix, e.g. <c>run ./cmd/api</c>) and
-    /// inserts them ahead of every other argument.
+    /// records them separately from every other argument.
     /// </summary>
     /// <remarks>
     /// The callback is deliberately evaluated <em>after</em> the ordinary argument callbacks but its result is
-    /// inserted <em>before</em> them. That is what makes the prefix order-independent: no <c>WithArgs</c> callback
-    /// can observe it, mutate it, or clear it, so it does not matter whether the tool invocation was declared before
-    /// or after the calls that add the program's own arguments.
+    /// resolved <em>before</em> them. Keeping the two segments separate makes the prefix order-independent: no
+    /// <c>WithArgs</c> or later configuration callback can observe it, mutate it, or clear it.
     /// </remarks>
     private static async ValueTask GatherLaunchToolArgumentsAsync(IExecutionConfigurationGathererContext context, IResource resource, ILogger resourceLogger, DistributedApplicationExecutionContext executionContext, CancellationToken cancellationToken)
     {
@@ -52,9 +52,9 @@ private static async ValueTask GatherLaunchToolArgumentsAsync(IExecutionConfigur
         // A container invokes the program through the image's ENTRYPOINT instead, so the prefix must not be repeated
         // in its arguments. This matters for executables published as a Dockerfile (Go, Python, JavaScript), where
         // PublishAsDockerFile() reuses the executable's annotations for the generated container resource. Note that
-        // the container's own `WithArgs(c => c.Args.Clear())` cannot undo this, because the prefix is inserted after
-        // all the ordinary argument callbacks have run.
-        if (resource is ContainerResource)
+        // the container's own `WithArgs(c => c.Args.Clear())` cannot undo a launch prefix because it is evaluated
+        // separately, so return before recording that segment.
+        if (resource.IsContainer())
         {
             return;
         }
@@ -78,7 +78,6 @@ private static async ValueTask GatherLaunchToolArgumentsAsync(IExecutionConfigur
             return;
         }
 
-        context.Arguments.InsertRange(0, launchToolArgs);
-        context.AddAdditionalData(new LaunchToolArgumentsData(launchToolArgs.Count, launchToolAnnotation.ShowInCommandLine));
+        context.AddAdditionalData(new UnresolvedLaunchToolArgumentsData(launchToolArgs.ToImmutableArray(), launchToolAnnotation.ShowInCommandLine));
     }
 }
diff --git a/src/Aspire.Hosting/ApplicationModel/ExecutionConfigurationGathererContext.cs b/src/Aspire.Hosting/ApplicationModel/ExecutionConfigurationGathererContext.cs
index 67a8b2aaf38..d67f92daf5d 100644
--- a/src/Aspire.Hosting/ApplicationModel/ExecutionConfigurationGathererContext.cs
+++ b/src/Aspire.Hosting/ApplicationModel/ExecutionConfigurationGathererContext.cs
@@ -41,48 +41,26 @@ internal async Task<IExecutionConfigurationResult> ResolveAsync(
         CancellationToken cancellationToken = default)
     {
         HashSet<object> references = new();
-        List<(object Unprocessed, string Value, bool IsSensitive)> resolvedArguments = new(Arguments.Count);
+        var launchToolArgumentsData = AdditionalConfigurationData.OfType<UnresolvedLaunchToolArgumentsData>().FirstOrDefault();
+        var argumentCapacity = Arguments.Count + (launchToolArgumentsData?.Arguments.Length ?? 0);
+        List<(object Unprocessed, string Value, bool IsSensitive)> resolvedArguments = new(argumentCapacity);
         Dictionary<string, (object Unprocessed, string Value)> resolvedEnvironmentVariables = new(EnvironmentVariables.Count);
         List<Exception> exceptions = new();
-        var launchToolArgumentsData = AdditionalConfigurationData.OfType<LaunchToolArgumentsData>().FirstOrDefault();
         var resolvedLaunchToolArgumentCount = 0;
 
-        for (var argumentIndex = 0; argumentIndex < Arguments.Count; argumentIndex++)
+        if (launchToolArgumentsData is not null)
         {
-            var argument = Arguments[argumentIndex];
-
-            try
-            {
-                var resolvedValue = await resource.ResolveValueAsync(executionContext, resourceLogger, argument, null, cancellationToken).ConfigureAwait(false);
-                if (resolvedValue?.Value != null)
-                {
-                    resolvedArguments.Add((argument, resolvedValue.Value, resolvedValue.IsSensitive));
-                    if (launchToolArgumentsData is not null && argumentIndex < launchToolArgumentsData.Count)
-                    {
-                        // Resolution drops null values. Count only launch tool values that survived so a missing
-                        // prefix value cannot make consumers treat the first ordinary argument as part of the prefix.
-                        resolvedLaunchToolArgumentCount++;
-                    }
-
-                    if (argument is IValueProvider or IManifestExpressionProvider)
-                    {
-                        references.Add(argument);
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                resourceLogger.LogError(ex, "Failed to resolve argument for resource '{ResourceName}'. A dependency may have failed to start.", resource.Name);
-                exceptions.Add(ex);
-            }
+            await ResolveArgumentsAsync(launchToolArgumentsData.Arguments, areLaunchToolArguments: true).ConfigureAwait(false);
         }
 
+        await ResolveArgumentsAsync(Arguments, areLaunchToolArguments: false).ConfigureAwait(false);
+
         foreach (var kvp in EnvironmentVariables)
         {
             try
             {
                 var resolvedValue = await resource.ResolveValueAsync(executionContext, resourceLogger, kvp.Value, null, cancellationToken).ConfigureAwait(false);
-                if (resolvedValue?.Value != null)
+                if (resolvedValue?.Value is not null)
                 {
                     resolvedEnvironmentVariables[kvp.Key] = (kvp.Value, resolvedValue.Value);
                     if (kvp.Value is IValueProvider or IManifestExpressionProvider)
@@ -99,15 +77,13 @@ internal async Task<IExecutionConfigurationResult> ResolveAsync(
         }
 
         var resolvedAdditionalConfigurationData = AdditionalConfigurationData;
-        if (launchToolArgumentsData is not null && launchToolArgumentsData.Count != resolvedLaunchToolArgumentCount)
+        if (launchToolArgumentsData is not null)
         {
             resolvedAdditionalConfigurationData = AdditionalConfigurationData
-                .Where(data => data is not LaunchToolArgumentsData)
+                .Where(data => data is not UnresolvedLaunchToolArgumentsData && data is not LaunchToolArgumentsData)
                 .ToHashSet();
 
-            // Only the count is recomputed here; every other facet of the declaration (such as whether the prefix is
-            // shown in the dashboard command line) is unaffected by value resolution and must be carried over.
-            resolvedAdditionalConfigurationData.Add(launchToolArgumentsData with { Count = resolvedLaunchToolArgumentCount });
+            resolvedAdditionalConfigurationData.Add(new LaunchToolArgumentsData(resolvedLaunchToolArgumentCount, launchToolArgumentsData.ShowInCommandLine));
         }
 
         return new ExecutionConfigurationResult
@@ -118,5 +94,36 @@ internal async Task<IExecutionConfigurationResult> ResolveAsync(
             AdditionalConfigurationData = resolvedAdditionalConfigurationData,
             Exception = exceptions.Count == 0 ? null : new AggregateException("One or more errors occurred while resolving resource configuration.", exceptions)
         };
+
+        async Task ResolveArgumentsAsync(IEnumerable<object> arguments, bool areLaunchToolArguments)
+        {
+            foreach (var argument in arguments)
+            {
+                try
+                {
+                    var resolvedValue = await resource.ResolveValueAsync(executionContext, resourceLogger, argument, null, cancellationToken).ConfigureAwait(false);
+                    if (resolvedValue?.Value is not null)
+                    {
+                        resolvedArguments.Add((argument, resolvedValue.Value, resolvedValue.IsSensitive));
+                        if (areLaunchToolArguments)
+                        {
+                            // Resolution drops null values. Count only launch tool values that survived so a missing
+                            // prefix value cannot make consumers treat the first ordinary argument as part of the prefix.
+                            resolvedLaunchToolArgumentCount++;
+                        }
+
+                        if (argument is IValueProvider or IManifestExpressionProvider)
+                        {
+                            references.Add(argument);
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    resourceLogger.LogError(ex, "Failed to resolve argument for resource '{ResourceName}'. A dependency may have failed to start.", resource.Name);
+                    exceptions.Add(ex);
+                }
+            }
+        }
     }
 }
diff --git a/src/Aspire.Hosting/ApplicationModel/LaunchToolArgsCallbackAnnotation.cs b/src/Aspire.Hosting/ApplicationModel/LaunchToolArgsCallbackAnnotation.cs
index 23a06aa43b7..0947196c2a1 100644
--- a/src/Aspire.Hosting/ApplicationModel/LaunchToolArgsCallbackAnnotation.cs
+++ b/src/Aspire.Hosting/ApplicationModel/LaunchToolArgsCallbackAnnotation.cs
@@ -20,7 +20,7 @@ namespace Aspire.Hosting.ApplicationModel;
 /// <list type="number">
 /// <item><description>
 /// They are always placed <em>first</em>, no matter when the annotation was added. The callback is evaluated
-/// against its own empty argument list and the result is inserted ahead of every other argument, so no
+/// against its own empty argument list and the result is resolved ahead of every other argument, so no
 /// <c>WithArgs</c> callback can observe it, mutate it, or clear it, and no registration order is implied.
 /// </description></item>
 /// <item><description>
@@ -114,6 +114,13 @@ private async Task<IList<object>> ExecuteCallbackAsync(CommandLineArgsCallbackCo
     }
 }
 
+/// <summary>
+/// Carries unresolved launch tool arguments separately from the mutable ordinary argument list.
+/// </summary>
+/// <param name="Arguments">The unresolved tool-invocation prefix.</param>
+/// <param name="ShowInCommandLine">Whether the prefix is shown in the dashboard command line.</param>
+internal sealed record UnresolvedLaunchToolArgumentsData(ImmutableArray<object> Arguments, bool ShowInCommandLine) : IExecutionConfigurationData;
+
 /// <summary>
 /// Reports how many of the leading arguments in an execution configuration were produced by a
 /// <see cref="LaunchToolArgsCallbackAnnotation"/>, so that consumers that compose the actual command line
diff --git a/src/Aspire.Hosting/ApplicationModel/ResourceExtensions.cs b/src/Aspire.Hosting/ApplicationModel/ResourceExtensions.cs
index b5031b91af3..5a5f9137de5 100644
--- a/src/Aspire.Hosting/ApplicationModel/ResourceExtensions.cs
+++ b/src/Aspire.Hosting/ApplicationModel/ResourceExtensions.cs
@@ -285,9 +285,48 @@ internal static async ValueTask<List<object>> GatherArgumentValuesAsync(
             }
         }
 
+        var launchToolArgs = await GatherLaunchToolArgumentValuesAsync(
+            resource,
+            executionContext,
+            logger,
+            cacheAnnotationCallbackResult: false,
+            cancellationToken).ConfigureAwait(false);
+        args.InsertRange(0, launchToolArgs);
+
         return args;
     }
 
+    private static async ValueTask<IList<object>> GatherLaunchToolArgumentValuesAsync(
+        IResource resource,
+        DistributedApplicationExecutionContext executionContext,
+        ILogger logger,
+        bool cacheAnnotationCallbackResult,
+        CancellationToken cancellationToken)
+    {
+        // Launch tool arguments run against an isolated list and do not apply to containers, matching
+        // ArgumentsExecutionConfigurationGatherer's composition of the effective command line.
+        if (resource.IsContainer() ||
+            !resource.TryGetLastAnnotation<LaunchToolArgsCallbackAnnotation>(out var annotation))
+        {
+            return [];
+        }
+
+        var context = new CommandLineArgsCallbackContext([], resource, cancellationToken)
+        {
+            Logger = logger,
+            ExecutionContext = executionContext
+        };
+
+        if (cacheAnnotationCallbackResult)
+        {
+            return await annotation.AsCallbackAnnotation().EvaluateOnceAsync(context).ConfigureAwait(false);
+        }
+
+        await annotation.Callback(context).ConfigureAwait(false);
+
+        return context.Args;
+    }
+
     /// <summary>
     /// Processes pre-gathered command-line argument values for the specified resource in the given execution context.
     /// </summary>
@@ -1639,6 +1678,14 @@ private static async Task<List<object>> GatherRawEnvironmentAndArgumentValuesAsy
             }
         }
 
+        var launchToolArgs = await GatherLaunchToolArgumentValuesAsync(
+            resource,
+            executionContext,
+            NullLogger.Instance,
+            options.CacheAnnotationCallbackResults,
+            cancellationToken).ConfigureAwait(false);
+        rawValues.AddRange(launchToolArgs);
+
         return rawValues;
     }
 
diff --git a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
index 3d6459c58a1..f5d158e880d 100644
--- a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
+++ b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
@@ -136,7 +136,7 @@ public async Task CreateObjectAsync(RenderedModelResource<Executable> er, EmptyC
 
         // Argument and launch-configuration callbacks can change on restart. Derive fallback availability from the
         // final execution type and resolved command line every time instead of carrying a preparation-time guess.
-        spec.FallbackExecutionTypes = ShouldOfferProcessFallback(er.ModelResource, spec, omittedLaunchToolArgumentCount)
+        spec.FallbackExecutionTypes = ShouldOfferProcessFallback(er.ModelResource, spec, resolvedLaunchToolArgumentCount, omittedLaunchToolArgumentCount)
             ? [ExecutionType.Process]
             : null;
 
@@ -282,7 +282,7 @@ private bool OmitLaunchToolArguments(RenderedModelResource<Executable> er, Execu
     /// both the IDE form and the process form of the command line: when the tool-invocation prefix is omitted for the
     /// IDE, no fallback can be offered.
     /// </remarks>
-    private bool ShouldOfferProcessFallback(IResource modelResource, ExecutableSpec spec, int omittedLaunchToolArgumentCount)
+    private bool ShouldOfferProcessFallback(IResource modelResource, ExecutableSpec spec, int resolvedLaunchToolArgumentCount, int omittedLaunchToolArgumentCount)
     {
         if (spec.ExecutionType != ExecutionType.IDE || omittedLaunchToolArgumentCount > 0)
         {
@@ -295,7 +295,7 @@ private bool ShouldOfferProcessFallback(IResource modelResource, ExecutableSpec
         }
 
         if (!modelResource.SupportsDebugging(_configuration, out var annotation)
-            || annotation.LaunchConfigurationType is "project")
+            || annotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project)
         {
             return false;
         }
@@ -303,12 +303,12 @@ private bool ShouldOfferProcessFallback(IResource modelResource, ExecutableSpec
         // A project-backed plain executable suppresses its `dotnet run` process scaffold when the active launch
         // configuration performs the tool invocation. Even when that prefix resolves empty, the remaining command
         // line is IDE-only and cannot be reused as a Process fallback.
-        return !HasIncompleteProcessCommand(modelResource, annotation, omittedLaunchToolArgumentCount);
+        return !HasIncompleteProcessCommand(modelResource, annotation, resolvedLaunchToolArgumentCount);
     }
 
-    private static bool HasIncompleteProcessCommand(IResource modelResource, SupportsDebuggingAnnotation annotation, int launchToolArgumentCount)
+    private static bool HasIncompleteProcessCommand(IResource modelResource, SupportsDebuggingAnnotation annotation, int resolvedLaunchToolArgumentCount)
     {
-        return launchToolArgumentCount == 0
+        return resolvedLaunchToolArgumentCount == 0
             && modelResource is not ProjectResource
             && modelResource.HasAnnotationOfType<IProjectMetadata>()
             && modelResource.HasLaunchToolArgsOwnedBy(annotation);
@@ -728,6 +728,8 @@ bool showLaunchToolArgsInCommandLine
             // Some integrations keep an SDK-shaped verb in resource args for model consumers, but the
             // launch override can already represent that verb. Only remove it when the annotation opts in.
             appHostArgList.RemoveAt(0);
+            launchToolArgumentCount = Math.Max(0, launchToolArgumentCount - 1);
+            omittedLaunchToolArgumentCount = Math.Max(0, omittedLaunchToolArgumentCount - 1);
         }
 
         var launchArgs = new List<LaunchArgument>();
diff --git a/tests/Aspire.Hosting.Python.Tests/AddPythonAppTests.cs b/tests/Aspire.Hosting.Python.Tests/AddPythonAppTests.cs
index 48fb04d1718..c7a5dd7b1e0 100644
--- a/tests/Aspire.Hosting.Python.Tests/AddPythonAppTests.cs
+++ b/tests/Aspire.Hosting.Python.Tests/AddPythonAppTests.cs
@@ -1165,11 +1165,10 @@ public async Task WithEntrypoint_ChangesEntrypointTypeAndValue()
         Assert.Equal(EntrypointType.Module, entrypointAnnotation.Type);
         Assert.Equal("uvicorn", entrypointAnnotation.Entrypoint);
 
-        // Verify arguments. The entrypoint occupies its own leading slot, so switching it replaces only the
-        // entrypoint and leaves arguments added before the switch in place.
+        // Arguments for the previous entrypoint are cleared, while arguments added after the switch remain.
         var commandArguments = await ArgumentEvaluator.GetArgumentListAsync(resource, TestServiceProvider.Instance);
 
-        Assert.Equal(["-m", "uvicorn", "arg1", "arg2", "main:app", "--reload"], commandArguments);
+        Assert.Equal(["-m", "uvicorn", "main:app", "--reload"], commandArguments);
     }
 
     [Fact]
diff --git a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
index b0b89d448be..19fdc857a91 100644
--- a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
+++ b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
@@ -5558,6 +5558,55 @@ public async Task ProjectExecutable_WithLaunchArgsOverride_AndLeadingResourceArg
             arg => Assert.Equal("net10.0-ios", arg));
     }
 
+    [Fact]
+    public async Task ProjectExecutable_WithLaunchArgsOverride_AndLeadingLaunchToolArgumentToRemove_DisplaysOrdinaryArguments()
+    {
+        var builder = DistributedApplication.CreateBuilder(new DistributedApplicationOptions
+        {
+            AssemblyName = typeof(DistributedApplicationTests).Assembly.FullName
+        });
+
+        var projectBuilder = builder.AddProject<Projects.ServiceA>("ServiceA")
+            .WithArgs("-f", "net10.0-ios")
+            .WithLaunchToolArgs(static ctx => ctx.Args.Add("run"), showInCommandLine: false);
+#pragma warning disable ASPIREPROJECTS001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
+        projectBuilder.Resource.Annotations.Add(new ProjectLaunchArgsOverrideAnnotation(["build", "/t:Run"], leadingResourceArgumentToRemove: "run"));
+#pragma warning restore ASPIREPROJECTS001
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetesService, "ServiceA");
+
+        Assert.Equal(ExecutionType.Process, exe.Spec.ExecutionType);
+        Assert.Collection(
+            exe.Spec.Args!,
+            arg => Assert.Equal("build", arg),
+            arg => Assert.Equal("/t:Run", arg),
+            arg => Assert.EndsWith("ServiceA.csproj", arg, StringComparison.Ordinal),
+            arg => Assert.Equal("--configuration", arg),
+            arg => Assert.Equal(GetTestAssemblyConfiguration(), arg),
+            arg => Assert.Equal("-f", arg),
+            arg => Assert.Equal("net10.0-ios", arg));
+
+        Assert.True(exe.TryGetAnnotationAsObjectList<AppLaunchArgumentAnnotation>(CustomResource.ResourceAppArgsAnnotation, out var displayArgs));
+        Assert.Collection(displayArgs,
+            arg =>
+            {
+                Assert.Equal("-f", arg.Argument);
+                Assert.Equal(5, arg.EffectiveArgumentIndex);
+            },
+            arg =>
+            {
+                Assert.Equal("net10.0-ios", arg.Argument);
+                Assert.Equal(6, arg.EffectiveArgumentIndex);
+            });
+    }
+
     [Fact]
     public async Task ProjectExecutable_WithLaunchArgsOverride_AndPersistentLifetime_RunsOverrideInProcessMode()
     {
@@ -5954,6 +6003,115 @@ public async Task PlainExecutable_ExtensionMode_LaunchToolArgsDebugSupport_Withh
             });
     }
 
+    [Fact]
+    public async Task PlainExecutable_ExtensionMode_OwnedLaunchToolArgsCanBeHiddenFromCommandLine()
+    {
+        // A matching IDE launch configuration both performs the owned tool invocation and can hide that plumbing from
+        // the dashboard, leaving only the ordinary program arguments in both observable argument lists.
+        var builder = DistributedApplication.CreateBuilder();
+
+        var resource = new TestExecutableResource("test-working-directory");
+        builder.AddResource(resource)
+            .WithArgs("app-arg")
+            .WithLaunchToolArgs(
+                static ctx => ctx.Args.Add("run"),
+                ownedByLaunchConfigurationType: "test",
+                showInCommandLine: false)
+            .WithDebugSupport(
+                mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
+                "test");
+
+        var configDict = new Dictionary<string, string?>
+        {
+            [DcpExecutor.DebugSessionPortVar] = "12345",
+            [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["test"] }),
+            [KnownConfigNames.ExtensionEndpoint] = "http://localhost:1234",
+            [KnownConfigNames.DebugSessionRunMode] = "Debug"
+        };
+        var configuration = new ConfigurationBuilder().AddInMemoryCollection(configDict).Build();
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService, configuration: configuration);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetesService, "TestExecutable");
+        Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
+        Assert.Equal(["app-arg"], exe.Spec.Args);
+        Assert.Null(exe.Spec.FallbackExecutionTypes);
+
+        Assert.True(exe.TryGetAnnotationAsObjectList<AppLaunchArgumentAnnotation>(CustomResource.ResourceAppArgsAnnotation, out var displayArgs));
+        var displayArg = Assert.Single(displayArgs);
+        Assert.Equal("app-arg", displayArg.Argument);
+        Assert.Equal(0, displayArg.EffectiveArgumentIndex);
+    }
+
+    [Fact]
+    public async Task PlainExecutable_ExtensionMode_CertificateCallbackCannotShiftLaunchToolPrefixBoundary()
+    {
+        // Certificate callbacks run after launch tool arguments are gathered and can mutate ordinary arguments.
+        // Keep the prefix in a separate segment so inserting at the front cannot change which arguments the IDE owns.
+        var builder = DistributedApplication.CreateBuilder();
+        using var certificate = CreateTestCertificate();
+        var certificateAuthorities = builder.AddCertificateAuthorityCollection("certificates")
+            .WithCertificate(certificate);
+
+        var resource = new TestExecutableResource("test-working-directory");
+        builder.AddResource(resource)
+            .WithArgs("app-arg")
+            .WithLaunchToolArgs(static ctx => ctx.Args.Add("run"), ownedByLaunchConfigurationType: "test")
+            .WithDebugSupport(
+                mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
+                "test")
+            .WithCertificateAuthorityCollection(certificateAuthorities)
+            .WithCertificateTrustConfiguration(static ctx =>
+            {
+                ctx.Arguments.Insert(0, "certificate-arg");
+                return Task.CompletedTask;
+            });
+
+        var configDict = new Dictionary<string, string?>
+        {
+            [DcpExecutor.DebugSessionPortVar] = "12345",
+            [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["test"] }),
+            [KnownConfigNames.ExtensionEndpoint] = "http://localhost:1234",
+            [KnownConfigNames.DebugSessionRunMode] = "Debug"
+        };
+        var configuration = new ConfigurationBuilder().AddInMemoryCollection(configDict).Build();
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService, configuration: configuration);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetesService, "TestExecutable");
+        Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
+        Assert.Equal(["certificate-arg", "app-arg"], exe.Spec.Args);
+        Assert.Null(exe.Spec.FallbackExecutionTypes);
+
+        Assert.True(exe.TryGetAnnotationAsObjectList<AppLaunchArgumentAnnotation>(CustomResource.ResourceAppArgsAnnotation, out var displayArgs));
+        Assert.Collection(displayArgs,
+            arg =>
+            {
+                Assert.Equal("run", arg.Argument);
+                Assert.Null(arg.EffectiveArgumentIndex);
+            },
+            arg =>
+            {
+                Assert.Equal("certificate-arg", arg.Argument);
+                Assert.Equal(0, arg.EffectiveArgumentIndex);
+            },
+            arg =>
+            {
+                Assert.Equal("app-arg", arg.Argument);
+                Assert.Equal(1, arg.EffectiveArgumentIndex);
+            });
+    }
+
     [Fact]
     public async Task PlainExecutable_ExtensionMode_EmptyLaunchToolArgs_OffersProcessFallback()
     {
diff --git a/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs b/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs
index 0bd545a9944..3e964e463b5 100644
--- a/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs
+++ b/tests/Aspire.Hosting.Tests/ExecutableResourceBuilderExtensionTests.cs
@@ -9,6 +9,7 @@
 using Aspire.Hosting.Dcp.Model;
 using Aspire.Hosting.Tests.Utils;
 using Aspire.Hosting.Utils;
+using Microsoft.Extensions.Logging.Abstractions;
 
 namespace Aspire.Hosting.Tests;
 
@@ -183,6 +184,30 @@ public async Task WithLaunchToolArgsLeadTheCommandLine()
             arg => Assert.Equal("base-arg", arg));
     }
 
+    [Fact]
+    public async Task ProcessArgumentValuesAsyncIncludesLaunchToolArgsForExecutables()
+    {
+        using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
+
+        var executable = builder.AddExecutable("myexe", "command", "workingdirectory")
+            .WithArgs("base-arg")
+            .WithLaunchToolArgs(context => context.Args.Add("launch-tool-arg"));
+        var args = new List<string>();
+
+#pragma warning disable CS0618 // Type or member is obsolete
+        await executable.Resource.ProcessArgumentValuesAsync(
+            new DistributedApplicationExecutionContext(DistributedApplicationOperation.Run),
+            (_, value, exception, _) =>
+            {
+                Assert.Null(exception);
+                args.Add(Assert.IsType<string>(value));
+            },
+            NullLogger.Instance);
+#pragma warning restore CS0618 // Type or member is obsolete
+
+        Assert.Equal(["launch-tool-arg", "base-arg"], args);
+    }
+
     [Theory]
     [InlineData(true)]
     [InlineData(false)]
@@ -227,7 +252,7 @@ public async Task WithLaunchToolArgsAreOrderIndependent(bool launchToolArgsFirst
     [Fact]
     public async Task WithLaunchToolArgsSurviveAnArgsCallbackThatClearsTheList()
     {
-        // No WithArgs callback can observe or clear the tool-invocation prefix: it is evaluated separately and inserted
+        // No WithArgs callback can observe or clear the tool-invocation prefix: it is evaluated separately and resolved
         // ahead of the arguments those callbacks produce.
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
 
@@ -344,5 +369,19 @@ public async Task WithLaunchToolArgsAreNotCarriedIntoAPublishedContainer()
         var args = await ArgumentEvaluator.GetArgumentListAsync(container);
 
         Assert.Empty(args);
+
+        var processedArgs = new List<string>();
+#pragma warning disable CS0618 // Type or member is obsolete
+        await container.ProcessArgumentValuesAsync(
+            new DistributedApplicationExecutionContext(DistributedApplicationOperation.Publish),
+            (_, value, exception, _) =>
+            {
+                Assert.Null(exception);
+                processedArgs.Add(Assert.IsType<string>(value));
+            },
+            NullLogger.Instance);
+#pragma warning restore CS0618 // Type or member is obsolete
+
+        Assert.Empty(processedArgs);
     }
 }
diff --git a/tests/Aspire.Hosting.Tests/ResourceDependencyTests.cs b/tests/Aspire.Hosting.Tests/ResourceDependencyTests.cs
index d9d52c319eb..a1eb2b32c2d 100644
--- a/tests/Aspire.Hosting.Tests/ResourceDependencyTests.cs
+++ b/tests/Aspire.Hosting.Tests/ResourceDependencyTests.cs
@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+#pragma warning disable ASPIREEXTENSION001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
+
 using Aspire.Hosting.Tests.Utils;
 using Aspire.Hosting.Utils;
 
@@ -209,6 +211,65 @@ public async Task ParameterInArgsIsIncluded()
         Assert.Contains(param.Resource, dependencies);
     }
 
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task ParameterInLaunchToolArgsIsIncluded(bool cacheAnnotationCallbackResults)
+    {
+        using var builder = TestDistributedApplicationBuilder.Create();
+
+        var param = builder.AddParameter("config");
+        var executable = builder.AddExecutable("app", "myapp", ".")
+            .WithLaunchToolArgs(context => context.Args.Add(param));
+
+        var executionContext = new DistributedApplicationExecutionContext(DistributedApplicationOperation.Run);
+        var dependencies = await executable.Resource.GetResourceDependenciesAsync(
+            executionContext,
+            new ResourceDependencyDiscoveryOptions
+            {
+                DiscoveryMode = ResourceDependencyDiscoveryMode.DirectOnly,
+                CacheAnnotationCallbackResults = cacheAnnotationCallbackResults
+            });
+
+        Assert.Collection(dependencies, dependency => Assert.Same(param.Resource, dependency));
+    }
+
+    [Fact]
+    public async Task OnlyLastLaunchToolArgsAnnotationContributesDependencies()
+    {
+        using var builder = TestDistributedApplicationBuilder.Create();
+
+        var replaced = builder.AddParameter("replaced");
+        var active = builder.AddParameter("active");
+        var executable = builder.AddExecutable("app", "myapp", ".")
+            .WithLaunchToolArgs(context => context.Args.Add(replaced))
+            .WithLaunchToolArgs(context => context.Args.Add(active));
+
+        var executionContext = new DistributedApplicationExecutionContext(DistributedApplicationOperation.Run);
+        var dependencies = await executable.Resource.GetResourceDependenciesAsync(
+            executionContext,
+            ResourceDependencyDiscoveryMode.DirectOnly);
+
+        Assert.Collection(dependencies, dependency => Assert.Same(active.Resource, dependency));
+    }
+
+    [Fact]
+    public async Task LaunchToolArgsOnContainerDoNotContributeDependencies()
+    {
+        using var builder = TestDistributedApplicationBuilder.Create();
+
+        var param = builder.AddParameter("config");
+        var container = builder.AddContainer("container", "alpine")
+            .WithLaunchToolArgs(context => context.Args.Add(param));
+
+        var executionContext = new DistributedApplicationExecutionContext(DistributedApplicationOperation.Run);
+        var dependencies = await container.Resource.GetResourceDependenciesAsync(
+            executionContext,
+            ResourceDependencyDiscoveryMode.DirectOnly);
+
+        Assert.Empty(dependencies);
+    }
+
     [Fact]
     public async Task ReferenceExpressionWithMultipleResourcesIncludesAll()
     {

From c9b2493a694465cc5d08af6114e21ae6f5be6f38 Mon Sep 17 00:00:00 2001
From: Karol Zadora-Przylecki <karolz@microsoft.com>
Date: Fri, 7 Aug 2026 12:04:27 -0700
Subject: [PATCH 05/13] Fix Delve argument composition mangled by rebase

The rebase onto main left the deleted "Normal run mode" block spliced into
the Delve branch of AddGoApp's argument callback. That injected `run` and
`-race` into the `dlv` command line, made `--only-same-user` conditional on
both AcceptMultiClient being false and build tags being present, and left a
braceless `if` that failed the build with IDE0011.

Restore the two independent flag checks.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
---
 src/Aspire.Hosting.Go/GoHostingExtensions.cs | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/src/Aspire.Hosting.Go/GoHostingExtensions.cs b/src/Aspire.Hosting.Go/GoHostingExtensions.cs
index d42c8b9d6e9..641169831e5 100644
--- a/src/Aspire.Hosting.Go/GoHostingExtensions.cs
+++ b/src/Aspire.Hosting.Go/GoHostingExtensions.cs
@@ -123,18 +123,8 @@ public static IResourceBuilder<GoAppResource> AddGoApp(
                 {
                     ctx.Args.Add("--accept-multiclient");
                 }
-                else
                 if (delveAnnotation.OnlySameUser.HasValue)
                 {
-                    // Normal run mode: go run [-race] [-tags=...] [-ldflags=...] [-gcflags=...] <pkg> [args]
-                    ctx.Args.Add("run");
-
-                    if (ctx.Resource.TryGetLastAnnotation<GoRaceDetectorAnnotation>(out _))
-                    {
-                        ctx.Args.Add("-race");
-                    }
-
-                    if (ctx.Resource.TryGetLastAnnotation<GoBuildTagsAnnotation>(out var tagsAnnotation))
                     ctx.Args.Add($"--only-same-user={delveAnnotation.OnlySameUser.Value.ToString().ToLowerInvariant()}");
                 }
                 if (delveAnnotation.Log)

From c71c2995195cf85d32a9ed896bc416e862347c02 Mon Sep 17 00:00:00 2001
From: Karol Zadora-Przylecki <karolz@microsoft.com>
Date: Fri, 7 Aug 2026 15:40:18 -0700
Subject: [PATCH 06/13] Fix .NET tool launch argument composition

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 6fa86160-e335-404c-8144-ef2bad83e72c
---
 src/Aspire.Hosting/Dcp/ExecutableCreator.cs   | 11 ++--
 .../Dcp/DcpExecutorTests.cs                   | 57 +++++++++++++++++++
 2 files changed, 64 insertions(+), 4 deletions(-)

diff --git a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
index f5d158e880d..eeca0f860eb 100644
--- a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
+++ b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
@@ -734,6 +734,7 @@ bool showLaunchToolArgsInCommandLine
 
         var launchArgs = new List<LaunchArgument>();
         var nextExecutableArgumentIndex = executableArgumentStartIndex;
+        var firstVisibleAppHostArgumentIndex = 0;
 
         LaunchArgument CreateLaunchArgument(string value, bool isSensitive, bool executable, bool display)
         {
@@ -765,12 +766,12 @@ LaunchArgument CreateLaunchArgument(string value, bool isSensitive, bool executa
         }
         else if (er.ModelResource is DotnetToolResource)
         {
+            // Dotnet tools compose args as `tool exec <package> ... -- <app args>`. Keep hiding the invocation
+            // through `--`, but let the shared loop below apply launch-tool omission and visibility.
             var argSeparator = appHostArgList.Select((a, i) => (index: i, value: a.Value))
                 .FirstOrDefault(x => x.value == DotnetToolResourceExtensions.ArgumentSeparator);
 
-            var args = appHostArgList.Select((a, i) => (arg: a, display: i > argSeparator.index));
-            launchArgs.AddRange(args.Select(x => CreateLaunchArgument(x.arg.Value, x.arg.IsSensitive, executable: true, x.display)));
-            return launchArgs;
+            firstVisibleAppHostArgumentIndex = argSeparator.index + 1;
         }
 
         // In the situation where args are combined (process execution) the app host args are added after the launch
@@ -790,7 +791,9 @@ LaunchArgument CreateLaunchArgument(string value, bool isSensitive, bool executa
                 a.Value,
                 a.IsSensitive,
                 executable: i >= omittedLaunchToolArgumentCount,
-                display: showLaunchToolArgsInCommandLine || !isLaunchToolArg);
+                display: isLaunchToolArg
+                    ? showLaunchToolArgsInCommandLine
+                    : i >= firstVisibleAppHostArgumentIndex);
         }));
 
         return launchArgs;
diff --git a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
index 19fdc857a91..aad4f2e282e 100644
--- a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
+++ b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
@@ -266,6 +266,63 @@ public async Task CreateExecutable_ToolHasCommandLineArgs_AnnotationsAdded(param
         AssertEffectiveArgumentIndexesMatchSpecArgs(argAnnotations, exe.Spec.Args);
     }
 
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task DotnetToolResource_ExtensionMode_OwnedLaunchToolArgsAreWithheldAndRespectCommandLineVisibility(bool showInCommandLine)
+    {
+        var builder = DistributedApplication.CreateBuilder();
+
+#pragma warning disable ASPIREDOTNETTOOL // DotnetToolResource is experimental.
+        var resource = new DotnetToolResource("tool", "package");
+#pragma warning restore ASPIREDOTNETTOOL
+        builder.AddResource(resource)
+            .WithArgs("app-arg")
+            .WithLaunchToolArgs(
+                static context =>
+                {
+                    context.Args.Add("tool");
+                    context.Args.Add("exec");
+                    context.Args.Add("package");
+                    context.Args.Add("--yes");
+                    context.Args.Add("--");
+                },
+                ownedByLaunchConfigurationType: "test",
+                showInCommandLine: showInCommandLine)
+            .WithDebugSupport(
+                mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
+                "test");
+
+        var configDict = new Dictionary<string, string?>
+        {
+            [DcpExecutor.DebugSessionPortVar] = "12345",
+            [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["test"] }),
+            [KnownConfigNames.ExtensionEndpoint] = "http://localhost:1234",
+            [KnownConfigNames.DebugSessionRunMode] = "Debug"
+        };
+        var configuration = new ConfigurationBuilder().AddInMemoryCollection(configDict).Build();
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService, configuration: configuration);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetesService, "tool");
+        Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
+        Assert.Equal(["app-arg"], exe.Spec.Args);
+        Assert.Null(exe.Spec.FallbackExecutionTypes);
+
+        Assert.True(exe.TryGetAnnotationAsObjectList<AppLaunchArgumentAnnotation>(CustomResource.ResourceAppArgsAnnotation, out var displayArgs));
+        string[] launchToolArgs = ["tool", "exec", "package", "--yes", "--"];
+        string[] expectedDisplayArgs = showInCommandLine ? [.. launchToolArgs, "app-arg"] : ["app-arg"];
+        Assert.Equal(expectedDisplayArgs, displayArgs.Select(a => a.Argument));
+        Assert.All(displayArgs.Take(displayArgs.Count - 1), argument => Assert.Null(argument.EffectiveArgumentIndex));
+        Assert.Equal(0, displayArgs[^1].EffectiveArgumentIndex);
+        AssertEffectiveArgumentIndexesMatchSpecArgs(displayArgs, exe.Spec.Args);
+    }
+
     [Fact]
     public async Task CreateExecutable_ProjectArgsResolvedInSnapshot_UsesEffectiveArgsFromCreatorIndexes()
     {

From cc0928913a8b03fabef1016a3cc99afb44ec904a Mon Sep 17 00:00:00 2001
From: Karol Zadora-Przylecki <karolz@microsoft.com>
Date: Fri, 7 Aug 2026 16:24:11 -0700
Subject: [PATCH 07/13] Fix custom dotnet launch tool composition

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: ef8eab83-a8fa-4d46-a635-edc057cd6f78
---
 .../DotnetProjectHostingExtensions.cs         | 54 +++++++------
 .../DotnetProjectResourceTests.cs             | 78 +++++++++++++++++++
 2 files changed, 110 insertions(+), 22 deletions(-)

diff --git a/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs b/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
index 6151a5fa8a0..3ce41ad84ff 100644
--- a/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
+++ b/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
@@ -127,16 +127,14 @@ public static IResourceBuilder<DotnetProjectResource> AddDotnetProject(this IDis
                               .WithIconName("CodeCsRectangle")
                               .WithProjectDefaults(options);
 
-        // Build the `dotnet run` command line for a non-debug launch of a DotnetProjectResource:
+        // Declare the default `dotnet run` invocation separately from the program arguments so a later
+        // WithLaunchToolArgs call replaces it instead of being prepended to it:
         //   dotnet run --project <proj> [--no-build] [--configuration <cfg>] --no-launch-profile OR
         //   dotnet run --file <app.cs> --no-cache [--no-build] [--configuration <cfg>] --no-launch-profile
-        resource.WithArgs(ctx =>
+        resource.WithLaunchToolArgs(ctx =>
         {
-            // The active launch configuration supplies the project launch when it is "project" or performs a custom
-            // tool invocation. In those cases adding `dotnet run` would duplicate the tool invocation instead of
-            // contributing the process command.
             if (ctx.Resource.SupportsDebugging(builder.Configuration, out var debugAnnotation)
-                && (debugAnnotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project || ctx.Resource.HasLaunchToolArgsOwnedBy(debugAnnotation)))
+                && debugAnnotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project)
             {
                 return;
             }
@@ -168,26 +166,38 @@ public static IResourceBuilder<DotnetProjectResource> AddDotnetProject(this IDis
             // and must take priority. WithProjectDefaults materializes the profile's environment manually.
             ctx.Args.Add("--no-launch-profile");
 
-            // The launch profile's command line args are still applied here (run mode), after a `--`
-            // separator so they're passed to the app, matching the ProjectResource launch behavior.
-            if (builder.ExecutionContext.IsRunMode && !options.ExcludeLaunchProfile)
+            if (GetLaunchProfileArguments(ctx.Resource).Count > 0)
+            {
+                ctx.Args.Add("--");
+            }
+        }, ownedByLaunchConfigurationType: KnownLaunchConfigurationTypes.Project);
+
+        // Launch-profile command-line arguments belong to the program, not the replaceable tool invocation.
+        // Keeping them in the ordinary segment preserves them when a caller supplies a custom launch tool.
+        resource.WithArgs(ctx =>
+        {
+            foreach (var arg in GetLaunchProfileArguments(ctx.Resource))
             {
-                var launchProfile = ctx.Resource.GetEffectiveLaunchProfile()?.LaunchProfile;
-                if (launchProfile is not null && !string.IsNullOrWhiteSpace(launchProfile.CommandLineArgs))
-                {
-                    var launchProfileArgs = CommandLineArgsParser.Parse(launchProfile.CommandLineArgs);
-                    if (launchProfileArgs.Count > 0)
-                    {
-                        ctx.Args.Add("--");
-                        foreach (var arg in launchProfileArgs)
-                        {
-                            ctx.Args.Add(arg);
-                        }
-                    }
-                }
+                ctx.Args.Add(arg);
             }
         });
 
+        List<string> GetLaunchProfileArguments(IResource resource)
+        {
+            if (!builder.ExecutionContext.IsRunMode
+                || options.ExcludeLaunchProfile
+                || (resource.SupportsDebugging(builder.Configuration, out var debugAnnotation)
+                    && (debugAnnotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project || resource.HasLaunchToolArgsOwnedBy(debugAnnotation))))
+            {
+                return [];
+            }
+
+            var launchProfile = resource.GetEffectiveLaunchProfile()?.LaunchProfile;
+            return launchProfile is not null && !string.IsNullOrWhiteSpace(launchProfile.CommandLineArgs)
+                ? CommandLineArgsParser.Parse(launchProfile.CommandLineArgs)
+                : [];
+        }
+
         resource.OnBeforeResourceStarted((r, e, ct) =>
         {
             var projectPath = projectMetadata.ProjectPath;
diff --git a/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs b/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
index 89206e6ec89..95fe70ada3d 100644
--- a/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
+++ b/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
@@ -246,6 +246,75 @@ await File.WriteAllTextAsync(Path.Combine(propertiesDir.FullName, "launchSetting
         Assert.Equal("http", launchConfig.LaunchProfile);
     }
 
+    [Fact]
+    public async Task AddDotnetProject_CustomLaunchToolArgs_ReplaceDotnetRunScaffoldingInRunMode()
+    {
+        using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
+
+        var projectPath = Path.Combine(builder.AppHostDirectory, "MyService", "MyService.csproj");
+        var app = builder.AddDotnetProject("svc", projectPath, o => o.ExcludeLaunchProfile = true)
+                         .WithArgs("--config", "prod.yaml")
+                         .WithLaunchToolArgs(AddCustomLaunchToolArgs, ownedByLaunchConfigurationType: "custom")
+                         .WithDebugSupport(_ => new ExecutableLaunchConfiguration("custom"), "custom");
+
+        using var application = builder.Build();
+        var args = await ArgumentEvaluator.GetArgumentListAsync(app.Resource, application.Services);
+
+        Assert.Equal(["tool", "exec", "package", "--yes", "--", "--config", "prod.yaml"], args);
+    }
+
+    [Fact]
+    public async Task AddDotnetProject_CustomLaunchToolArgs_ReplaceDotnetRunScaffoldingInPublishMode()
+    {
+        using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Publish);
+
+        var projectPath = Path.Combine(builder.AppHostDirectory, "MyService", "MyService.csproj");
+        var app = builder.AddDotnetProject("svc", projectPath, o => o.ExcludeLaunchProfile = true)
+                         .WithArgs("--config", "prod.yaml")
+                         .WithLaunchToolArgs(AddCustomLaunchToolArgs, ownedByLaunchConfigurationType: "custom")
+                         .WithDebugSupport(_ => new ExecutableLaunchConfiguration("custom"), "custom");
+
+        Assert.Empty(app.Resource.Annotations.OfType<SupportsDebuggingAnnotation>());
+
+        var args = await ArgumentEvaluator.GetArgumentListAsync(app.Resource);
+
+        Assert.Equal(["tool", "exec", "package", "--yes", "--", "--config", "prod.yaml"], args);
+    }
+
+    [Fact]
+    public async Task AddDotnetProject_CustomLaunchToolArgs_PreserveLaunchProfileArguments()
+    {
+        using var workspace = TemporaryWorkspace.Create(outputHelper);
+        var projectDir = Directory.CreateDirectory(Path.Combine(workspace.Path, "MyService"));
+        var projectPath = Path.Combine(projectDir.FullName, "MyService.csproj");
+        await File.WriteAllTextAsync(projectPath, "<Project />");
+
+        var propertiesDir = Directory.CreateDirectory(Path.Combine(projectDir.FullName, "Properties"));
+        await File.WriteAllTextAsync(Path.Combine(propertiesDir.FullName, "launchSettings.json"), """
+            {
+              "profiles": {
+                "http": {
+                  "commandName": "Project",
+                  "commandLineArgs": "--profile-arg \"profile value\""
+                }
+              }
+            }
+            """);
+
+        using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
+        var app = builder.AddDotnetProject("svc", projectPath)
+                         .WithArgs("--config", "prod.yaml")
+                         .WithLaunchToolArgs(AddCustomLaunchToolArgs, ownedByLaunchConfigurationType: "custom")
+                         .WithDebugSupport(_ => new ExecutableLaunchConfiguration("custom"), "custom");
+
+        using var application = builder.Build();
+        var args = await ArgumentEvaluator.GetArgumentListAsync(app.Resource, application.Services);
+
+        Assert.Equal(
+            ["tool", "exec", "package", "--yes", "--", "--profile-arg", "profile value", "--config", "prod.yaml"],
+            args);
+    }
+
     [Fact]
     public async Task AddDotnetProject_InDebugSession_OmitsDotnetRunScaffolding()
     {
@@ -470,4 +539,13 @@ public async Task AddDotnetProject_FileBasedApp_InDebugSession_PersistentLifetim
         Assert.Contains("--no-launch-profile", args);
         Assert.Equal("--flag", args[^1]);
     }
+
+    private static void AddCustomLaunchToolArgs(CommandLineArgsCallbackContext context)
+    {
+        context.Args.Add("tool");
+        context.Args.Add("exec");
+        context.Args.Add("package");
+        context.Args.Add("--yes");
+        context.Args.Add("--");
+    }
 }

From 2a219c2de832fd9da078ea2b44b8a920f1e783ce Mon Sep 17 00:00:00 2001
From: Karol Zadora-Przylecki <karolz@microsoft.com>
Date: Fri, 7 Aug 2026 16:44:55 -0700
Subject: [PATCH 08/13] Fix ProjectResource process fallback

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 54ccd32a-c50e-4b43-ac74-8439fa2ed56d
---
 src/Aspire.Hosting/Dcp/ExecutableCreator.cs   | 17 ++--
 .../Dcp/DcpExecutorTests.cs                   | 97 +++++++++++++++++++
 2 files changed, 105 insertions(+), 9 deletions(-)

diff --git a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
index eeca0f860eb..fd1cecab9c3 100644
--- a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
+++ b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
@@ -289,27 +289,26 @@ private bool ShouldOfferProcessFallback(IResource modelResource, ExecutableSpec
             return false;
         }
 
-        if (modelResource is ProjectResource)
+        if (!modelResource.SupportsDebugging(_configuration, out var annotation))
         {
-            return true;
+            return modelResource is ProjectResource;
         }
 
-        if (!modelResource.SupportsDebugging(_configuration, out var annotation)
-            || annotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project)
+        // Project-backed resources suppress their process scaffold when the active launch configuration owns the
+        // tool invocation. If that prefix resolves empty, the remaining command line is IDE-only and cannot be used
+        // as a Process fallback.
+        if (HasIncompleteProcessCommand(modelResource, annotation, resolvedLaunchToolArgumentCount))
         {
             return false;
         }
 
-        // A project-backed plain executable suppresses its `dotnet run` process scaffold when the active launch
-        // configuration performs the tool invocation. Even when that prefix resolves empty, the remaining command
-        // line is IDE-only and cannot be reused as a Process fallback.
-        return !HasIncompleteProcessCommand(modelResource, annotation, resolvedLaunchToolArgumentCount);
+        return modelResource is ProjectResource
+            || annotation.LaunchConfigurationType is not KnownLaunchConfigurationTypes.Project;
     }
 
     private static bool HasIncompleteProcessCommand(IResource modelResource, SupportsDebuggingAnnotation annotation, int resolvedLaunchToolArgumentCount)
     {
         return resolvedLaunchToolArgumentCount == 0
-            && modelResource is not ProjectResource
             && modelResource.HasAnnotationOfType<IProjectMetadata>()
             && modelResource.HasLaunchToolArgsOwnedBy(annotation);
     }
diff --git a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
index aad4f2e282e..c831707daba 100644
--- a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
+++ b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
@@ -3772,6 +3772,103 @@ public async Task ProjectResource_WithLaunchToolArgsDebugSupport_DoesNotOfferPro
         Assert.Null(exe.Spec.FallbackExecutionTypes);
     }
 
+    [Fact]
+    public async Task ProjectResource_EmptyOwnedLaunchToolArgs_DoesNotOfferBrokenProcessFallback()
+    {
+        // An owned launch-tool declaration suppresses the process scaffold even when its callback resolves empty.
+        // The remaining `dotnet <app-args>` command is only meaningful to the IDE and cannot be used as a fallback.
+        var builder = DistributedApplication.CreateBuilder();
+        var projectBuilder = builder.AddProject<TestProject>("proj", launchProfileName: null);
+
+        var defaultAnnotation = projectBuilder.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().FirstOrDefault();
+        if (defaultAnnotation is not null)
+        {
+            projectBuilder.Resource.Annotations.Remove(defaultAnnotation);
+        }
+
+        projectBuilder
+            .WithArgs("app-arg")
+            .WithLaunchToolArgs(static _ => { }, ownedByLaunchConfigurationType: "test")
+            .WithDebugSupport(
+                mode => new ExecutableLaunchConfiguration("test") { Mode = mode },
+                "test");
+
+        using var app = builder.Build();
+        var model = app.Services.GetRequiredService<DistributedApplicationModel>();
+
+        var kubernetes = new TestKubernetesService();
+        var configuration = new ConfigurationBuilder()
+            .AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                [DcpExecutor.DebugSessionPortVar] = "12345",
+                [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["test"] })
+            })
+            .Build();
+
+        var executor = CreateAppExecutor(model, configuration: configuration, kubernetesService: kubernetes);
+
+        await executor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetes, "proj");
+        Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
+        Assert.Equal(["app-arg"], exe.Spec.Args);
+        Assert.Null(exe.Spec.FallbackExecutionTypes);
+    }
+
+    [Fact]
+    public async Task ProjectResource_EmptyOwnedLaunchToolArgs_LaunchConfigurationFailureDoesNotRunBrokenProcessCommand()
+    {
+        var builder = DistributedApplication.CreateBuilder();
+        var projectBuilder = builder.AddProject<TestProject>("proj", launchProfileName: null);
+
+        var defaultAnnotation = projectBuilder.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().FirstOrDefault();
+        if (defaultAnnotation is not null)
+        {
+            projectBuilder.Resource.Annotations.Remove(defaultAnnotation);
+        }
+
+        projectBuilder
+            .WithArgs("app-arg")
+            .WithLaunchToolArgs(static _ => { }, ownedByLaunchConfigurationType: "test")
+            .WithDebugSupport(ThrowingLaunchConfiguration, "test");
+
+        using var app = builder.Build();
+        var model = app.Services.GetRequiredService<DistributedApplicationModel>();
+
+        var kubernetes = new TestKubernetesService();
+        var failedResources = new List<IResource>();
+        var events = new DcpExecutorEvents();
+        events.Subscribe<OnResourceFailedToStartContext>(context =>
+        {
+            failedResources.Add(context.Resource);
+            return Task.CompletedTask;
+        });
+
+        var configuration = new ConfigurationBuilder()
+            .AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                [DcpExecutor.DebugSessionPortVar] = "12345",
+                [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["test"] })
+            })
+            .Build();
+
+        var executor = CreateAppExecutor(
+            model,
+            configuration: configuration,
+            kubernetesService: kubernetes,
+            events: events);
+
+        await executor.RunApplicationAsync();
+
+        Assert.Empty(GetCreatedExecutablesForResource(kubernetes, "proj"));
+        Assert.Same(projectBuilder.Resource, Assert.Single(failedResources));
+
+        static ExecutableLaunchConfiguration ThrowingLaunchConfiguration(string mode)
+        {
+            throw new InvalidOperationException("Launch configuration failed.");
+        }
+    }
+
     [Fact]
     public async Task ProjectResource_WithoutLaunchToolArgs_OffersProcessFallback_InDebugSession()
     {

From dc4229e9e45451492da19ad875c94d209b0807fc Mon Sep 17 00:00:00 2001
From: Karol Zadora-Przylecki <karolz@microsoft.com>
Date: Mon, 10 Aug 2026 11:21:00 -0700
Subject: [PATCH 09/13] Address Adam's findings

---
 .../DotnetProjectHostingExtensions.cs         |  3 +-
 src/Aspire.Hosting/Dcp/ExecutableCreator.cs   |  4 ++
 .../DotnetProjectResourceTests.cs             | 16 +++++-
 .../Dcp/DcpExecutorTests.cs                   | 50 +++++++++++++++++++
 4 files changed, 70 insertions(+), 3 deletions(-)

diff --git a/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs b/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
index 3ce41ad84ff..96f85bfabdc 100644
--- a/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
+++ b/src/Aspire.Hosting.Dotnet/DotnetProjectHostingExtensions.cs
@@ -184,10 +184,11 @@ public static IResourceBuilder<DotnetProjectResource> AddDotnetProject(this IDis
 
         List<string> GetLaunchProfileArguments(IResource resource)
         {
+            // Project launch configurations carry the selected launch profile, so the IDE applies its command-line arguments.
             if (!builder.ExecutionContext.IsRunMode
                 || options.ExcludeLaunchProfile
                 || (resource.SupportsDebugging(builder.Configuration, out var debugAnnotation)
-                    && (debugAnnotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project || resource.HasLaunchToolArgsOwnedBy(debugAnnotation))))
+                    && debugAnnotation.LaunchConfigurationType is KnownLaunchConfigurationTypes.Project))
             {
                 return [];
             }
diff --git a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
index fd1cecab9c3..e66d4b6f1a1 100644
--- a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
+++ b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
@@ -239,6 +239,10 @@ private async Task ApplyLaunchConfigurationAsync(RenderedModelResource<Executabl
             exe.Annotate(Executable.LaunchConfigurationsAnnotation, string.Empty);
             await supportsDebuggingAnnotation.LaunchConfigurationAnnotator(exe, mode, cancellationToken).ConfigureAwait(false);
         }
+        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            throw;
+        }
         catch (Exception ex)
         {
             if (HasIncompleteProcessCommand(er.ModelResource, supportsDebuggingAnnotation, resolvedLaunchToolArgumentCount))
diff --git a/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs b/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
index 95fe70ada3d..82500f1fde8 100644
--- a/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
+++ b/tests/Aspire.Hosting.Dotnet.Tests/DotnetProjectResourceTests.cs
@@ -281,8 +281,10 @@ public async Task AddDotnetProject_CustomLaunchToolArgs_ReplaceDotnetRunScaffold
         Assert.Equal(["tool", "exec", "package", "--yes", "--", "--config", "prod.yaml"], args);
     }
 
-    [Fact]
-    public async Task AddDotnetProject_CustomLaunchToolArgs_PreserveLaunchProfileArguments()
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public async Task AddDotnetProject_CustomLaunchToolArgs_PreserveLaunchProfileArguments(bool inDebugSession)
     {
         using var workspace = TemporaryWorkspace.Create(outputHelper);
         var projectDir = Directory.CreateDirectory(Path.Combine(workspace.Path, "MyService"));
@@ -302,6 +304,16 @@ await File.WriteAllTextAsync(Path.Combine(propertiesDir.FullName, "launchSetting
             """);
 
         using var builder = TestDistributedApplicationBuilder.Create(DistributedApplicationOperation.Run);
+        if (inDebugSession)
+        {
+            builder.Configuration["DEBUG_SESSION_PORT"] = "5678";
+            builder.Configuration["DEBUG_SESSION_INFO"] = JsonSerializer.Serialize(new RunSessionInfo
+            {
+                ProtocolsSupported = ["test"],
+                SupportedLaunchConfigurations = ["custom"]
+            });
+        }
+
         var app = builder.AddDotnetProject("svc", projectPath)
                          .WithArgs("--config", "prod.yaml")
                          .WithLaunchToolArgs(AddCustomLaunchToolArgs, ownedByLaunchConfigurationType: "custom")
diff --git a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
index c831707daba..6172941cee8 100644
--- a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
+++ b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
@@ -6434,6 +6434,56 @@ static Task<ExecutableLaunchConfiguration> ThrowingLaunchConfiguration(string mo
         }
     }
 
+    [Fact]
+    public async Task PlainExecutable_ExtensionMode_RestartLaunchConfigCancellationIsPropagated()
+    {
+        var builder = DistributedApplication.CreateBuilder();
+        var callbackCount = 0;
+        using var restartCancellation = new CancellationTokenSource();
+
+        var resource = new TestExecutableResource("test-working-directory");
+        builder.AddResource(resource)
+            .WithArgs("app-arg")
+            .WithDebugSupport(
+                (mode, cancellationToken) =>
+                {
+                    if (Interlocked.Increment(ref callbackCount) == 2)
+                    {
+                        restartCancellation.Cancel();
+                        cancellationToken.ThrowIfCancellationRequested();
+                    }
+
+                    return Task.FromResult(new ExecutableLaunchConfiguration("test") { Mode = mode });
+                },
+                "test");
+
+        var configDict = new Dictionary<string, string?>
+        {
+            [DcpExecutor.DebugSessionPortVar] = "12345",
+            [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["test"] }),
+            [KnownConfigNames.ExtensionEndpoint] = "http://localhost:1234"
+        };
+        var configuration = new ConfigurationBuilder().AddInMemoryCollection(configDict).Build();
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService, configuration: configuration);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe = Assert.Single(GetCreatedExecutablesForResource(kubernetesService, "TestExecutable"));
+        var reference = appExecutor.GetResource(exe.Metadata.Name);
+
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(
+            () => appExecutor.StartResourceAsync(reference, restartCancellation.Token));
+
+        Assert.Equal(2, callbackCount);
+        Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
+        Assert.Single(GetCreatedExecutablesForResource(kubernetesService, "TestExecutable"));
+        Assert.Equal([exe.Metadata.Name], kubernetesService.DeletedResources);
+    }
+
     [Fact]
     public async Task PlainExecutable_ExtensionMode_NullLaunchToolArgument_DoesNotOmitApplicationArgument()
     {

From a237f649ff47be49d2a20842ffc29d142a6c81ca Mon Sep 17 00:00:00 2001
From: Karol Zadora-Przylecki <karolz@microsoft.com>
Date: Mon, 10 Aug 2026 11:55:50 -0700
Subject: [PATCH 10/13] Improve tool args processing

---
 src/Aspire.Hosting/Dcp/ExecutableCreator.cs        | 10 ++++++----
 tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs | 13 +++++--------
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
index e66d4b6f1a1..82fae39a1cc 100644
--- a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
+++ b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
@@ -770,11 +770,13 @@ LaunchArgument CreateLaunchArgument(string value, bool isSensitive, bool executa
         else if (er.ModelResource is DotnetToolResource)
         {
             // Dotnet tools compose args as `tool exec <package> ... -- <app args>`. Keep hiding the invocation
-            // through `--`, but let the shared loop below apply launch-tool omission and visibility.
-            var argSeparator = appHostArgList.Select((a, i) => (index: i, value: a.Value))
-                .FirstOrDefault(x => x.value == DotnetToolResourceExtensions.ArgumentSeparator);
+            // through `--`, but let the shared loop below apply launch-tool omission and visibility. A launch-tool
+            // prefix can have its own separator, so search only the ordinary argument segment for this boundary.
+            var argSeparatorIndex = appHostArgList.FindIndex(
+                launchToolArgumentCount,
+                static a => a.Value == DotnetToolResourceExtensions.ArgumentSeparator);
 
-            firstVisibleAppHostArgumentIndex = argSeparator.index + 1;
+            firstVisibleAppHostArgumentIndex = argSeparatorIndex + 1;
         }
 
         // In the situation where args are combined (process execution) the app host args are added after the launch
diff --git a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
index 6172941cee8..b245da8634e 100644
--- a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
+++ b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
@@ -273,10 +273,7 @@ public async Task DotnetToolResource_ExtensionMode_OwnedLaunchToolArgsAreWithhel
     {
         var builder = DistributedApplication.CreateBuilder();
 
-#pragma warning disable ASPIREDOTNETTOOL // DotnetToolResource is experimental.
-        var resource = new DotnetToolResource("tool", "package");
-#pragma warning restore ASPIREDOTNETTOOL
-        builder.AddResource(resource)
+        builder.AddDotnetTool("tool", "package")
             .WithArgs("app-arg")
             .WithLaunchToolArgs(
                 static context =>
@@ -311,15 +308,15 @@ public async Task DotnetToolResource_ExtensionMode_OwnedLaunchToolArgsAreWithhel
 
         var exe = GetCreatedExecutableForResource(kubernetesService, "tool");
         Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
-        Assert.Equal(["app-arg"], exe.Spec.Args);
+        string[] dotnetToolExecArgs = ["tool", "exec", "package", "--yes", "--"];
+        Assert.Equal([.. dotnetToolExecArgs, "app-arg"], exe.Spec.Args);
         Assert.Null(exe.Spec.FallbackExecutionTypes);
 
         Assert.True(exe.TryGetAnnotationAsObjectList<AppLaunchArgumentAnnotation>(CustomResource.ResourceAppArgsAnnotation, out var displayArgs));
-        string[] launchToolArgs = ["tool", "exec", "package", "--yes", "--"];
-        string[] expectedDisplayArgs = showInCommandLine ? [.. launchToolArgs, "app-arg"] : ["app-arg"];
+        string[] expectedDisplayArgs = showInCommandLine ? [.. dotnetToolExecArgs, "app-arg"] : ["app-arg"];
         Assert.Equal(expectedDisplayArgs, displayArgs.Select(a => a.Argument));
         Assert.All(displayArgs.Take(displayArgs.Count - 1), argument => Assert.Null(argument.EffectiveArgumentIndex));
-        Assert.Equal(0, displayArgs[^1].EffectiveArgumentIndex);
+        Assert.Equal(dotnetToolExecArgs.Length, displayArgs[^1].EffectiveArgumentIndex);
         AssertEffectiveArgumentIndexesMatchSpecArgs(displayArgs, exe.Spec.Args);
     }
 

From e673149c6713939f55f6b515789a7b545db6b7bc Mon Sep 17 00:00:00 2001
From: Karol Zadora-Przylecki <karolz@microsoft.com>
Date: Mon, 10 Aug 2026 13:06:29 -0700
Subject: [PATCH 11/13] Fix launch profile arg handling in process mode

---
 src/Aspire.Hosting/Dcp/ExecutableCreator.cs   | 61 +++++++++++++------
 .../Dcp/DcpExecutorTests.cs                   | 53 ++++++++++++++++
 2 files changed, 96 insertions(+), 18 deletions(-)

diff --git a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
index 82fae39a1cc..76bc368245e 100644
--- a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
+++ b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
@@ -439,10 +439,10 @@ private async Task PrepareProjectExecutablesAsync(CancellationToken cancellation
                 {
                     exe.Spec.ExecutionType = ExecutionType.Process;
 
-                    // Some ProjectResource subtypes, such as MAUI platform resources, intentionally
-                    // provide their own executable command and SDK-shaped app host args. Do not prefix
-                    // those args with Aspire's default `dotnet run --project ...` wrapper.
-                    if (executableAnnotation is null)
+                    // Some ProjectResource subtypes provide their own executable command, and WithLaunchToolArgs
+                    // replaces the implicit project invocation even when its callback resolves empty. Do not prefix
+                    // either shape with Aspire's default `dotnet run --project ...` wrapper.
+                    if (executableAnnotation is null && !HasLaunchToolArgsDeclaration(project))
                     {
                         var projectLaunchConfiguration = new ProjectLaunchConfiguration
                         {
@@ -721,6 +721,7 @@ bool showLaunchToolArgsInCommandLine
         // Follows behavior in the IDE execution spec when in IDE execution mode:
         // https://github.com/microsoft/aspire/blob/main/docs/specs/IDE-execution.md#project-launch-configuration-type-project
         var appHostArgList = appHostArgs.ToList();
+        var hasLaunchToolArgsDeclaration = HasLaunchToolArgsDeclaration(er.ModelResource);
 #pragma warning disable ASPIREPROJECTS001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
         var hasProjectLaunchArgsOverride = er.ModelResource.TryGetLastAnnotation<ProjectLaunchArgsOverrideAnnotation>(out var projectLaunchArgsOverride);
 #pragma warning restore ASPIREPROJECTS001
@@ -738,6 +739,8 @@ bool showLaunchToolArgsInCommandLine
         var launchArgs = new List<LaunchArgument>();
         var nextExecutableArgumentIndex = executableArgumentStartIndex;
         var firstVisibleAppHostArgumentIndex = 0;
+        List<string>? projectLaunchProfileArgs = null;
+        var includeProfileArgsInSpec = false;
 
         LaunchArgument CreateLaunchArgument(string value, bool isSensitive, bool executable, bool display)
         {
@@ -755,16 +758,15 @@ LaunchArgument CreateLaunchArgument(string value, bool isSensitive, bool executa
             {
                 // When the .NET project is launched from an IDE the launch profile args are automatically added.
                 // We still want to display the args in the dashboard so only add them to the custom arg annotations.
-                var executableArg = spec.ExecutionType != ExecutionType.IDE;
+                includeProfileArgsInSpec = spec.ExecutionType != ExecutionType.IDE;
 
-                var launchProfileArgs = GetLaunchProfileArgs(project.GetEffectiveLaunchProfile()?.LaunchProfile);
-                if (launchProfileArgs.Count > 0 && appHostArgList.Count > 0)
+                projectLaunchProfileArgs = GetLaunchProfileArgs(project.GetEffectiveLaunchProfile()?.LaunchProfile);
+                if (projectLaunchProfileArgs.Count > 0 && appHostArgList.Count > 0 && !hasLaunchToolArgsDeclaration)
                 {
-                    // If there are app host args, add a double-dash to separate them from the launch args.
-                    launchProfileArgs.Insert(0, "--");
+                    // The implicit `dotnet run` scaffold needs a double-dash before application arguments. A custom
+                    // launch-tool declaration owns its complete invocation, including any separator its tool requires.
+                    projectLaunchProfileArgs.Insert(0, "--");
                 }
-
-                launchArgs.AddRange(launchProfileArgs.Select(a => CreateLaunchArgument(a, isSensitive: false, executableArg, display: true)));
             }
         }
         else if (er.ModelResource is DotnetToolResource)
@@ -779,9 +781,15 @@ LaunchArgument CreateLaunchArgument(string value, bool isSensitive, bool executa
             firstVisibleAppHostArgumentIndex = argSeparatorIndex + 1;
         }
 
-        // In the situation where args are combined (process execution) the app host args are added after the launch
-        // profile args. Launch tool arguments (the tool-invocation prefix such as `run ./cmd/api`) are always the
-        // leading app host args, and the two decisions about them are independent:
+        // Project launch-profile arguments are application arguments. When a custom launch-tool declaration replaces
+        // the implicit `dotnet run` scaffold, keep its prefix first and insert profile arguments before ordinary
+        // app-host arguments. Without such a declaration, preserve the existing profile-before-app-host ordering.
+        var projectLaunchProfileArgumentInsertIndex = hasLaunchToolArgsDeclaration
+            ? Math.Min(launchToolArgumentCount, appHostArgList.Count)
+            : 0;
+
+        // Launch tool arguments (the tool-invocation prefix such as `run ./cmd/api`) are the leading app-host args,
+        // and the two decisions about them are independent:
         //
         // - Executable: withheld only when the active IDE launch configuration performs the tool invocation itself,
         //   because passing it on would run it twice.
@@ -789,17 +797,29 @@ LaunchArgument CreateLaunchArgument(string value, bool isSensitive, bool executa
         //   still shown, because it is absent from the process's effective args and hiding it here too would leave
         //   the dashboard showing a bare `go` plus the program arguments — the same treatment project launch-profile
         //   args get above.
-        launchArgs.AddRange(appHostArgList.Select((a, i) =>
+        for (var i = 0; i <= appHostArgList.Count; i++)
         {
+            if (i == projectLaunchProfileArgumentInsertIndex && projectLaunchProfileArgs is not null)
+            {
+                launchArgs.AddRange(projectLaunchProfileArgs.Select(
+                    a => CreateLaunchArgument(a, isSensitive: false, includeProfileArgsInSpec, display: true)));
+            }
+
+            if (i == appHostArgList.Count)
+            {
+                break;
+            }
+
+            var a = appHostArgList[i];
             var isLaunchToolArg = i < launchToolArgumentCount;
-            return CreateLaunchArgument(
+            launchArgs.Add(CreateLaunchArgument(
                 a.Value,
                 a.IsSensitive,
                 executable: i >= omittedLaunchToolArgumentCount,
                 display: isLaunchToolArg
                     ? showLaunchToolArgsInCommandLine
-                    : i >= firstVisibleAppHostArgumentIndex);
-        }));
+                    : i >= firstVisibleAppHostArgumentIndex));
+        }
 
         return launchArgs;
     }
@@ -895,6 +915,11 @@ private static bool HasProjectLaunchArgsOverride(IResource resource)
 #pragma warning restore ASPIREPROJECTS001
     }
 
+    private static bool HasLaunchToolArgsDeclaration(IResource resource)
+    {
+        return resource.TryGetLastAnnotation<LaunchToolArgsCallbackAnnotation>(out _);
+    }
+
     private static void ReindexExecutableLaunchArgs(List<LaunchArgument> launchArgs, int executableArgumentStartIndex)
     {
         var nextExecutableArgumentIndex = executableArgumentStartIndex;
diff --git a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
index b245da8634e..6af95388613 100644
--- a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
+++ b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
@@ -3725,6 +3725,59 @@ public async Task PersistentPlainExecutable_ExtensionMode_RunsInProcess()
         Assert.Null(exe.Spec.FallbackExecutionTypes);
     }
 
+    [Fact]
+    public async Task ProjectResource_WithLaunchToolArgs_ReplacesDotnetRunScaffolding_InProcessMode()
+    {
+        var builder = DistributedApplication.CreateBuilder();
+        builder.AddProject<TestProjectWithLaunchProfileCommandLineArgs>("proj", launchProfileName: "http")
+            .WithLaunchToolArgs(ctx =>
+            {
+                ctx.Args.Add("tool");
+                ctx.Args.Add("exec");
+                ctx.Args.Add("package");
+                ctx.Args.Add("--");
+            })
+            .WithArgs("app-arg");
+
+        using var app = builder.Build();
+        var model = app.Services.GetRequiredService<DistributedApplicationModel>();
+
+        var kubernetes = new TestKubernetesService();
+        var executor = CreateAppExecutor(model, kubernetesService: kubernetes);
+
+        await executor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetes, "proj");
+        var expectedArgs = new[] { "tool", "exec", "package", "--", "--profile-arg", "profile value", "app-arg" };
+
+        Assert.Equal(ExecutionType.Process, exe.Spec.ExecutionType);
+        Assert.Equal(expectedArgs, exe.Spec.Args);
+        Assert.True(exe.TryGetAnnotationAsObjectList<AppLaunchArgumentAnnotation>(CustomResource.ResourceAppArgsAnnotation, out var argAnnotations));
+        Assert.Equal(expectedArgs, argAnnotations.Select(a => a.Argument));
+        AssertEffectiveArgumentIndexesMatchSpecArgs(argAnnotations, exe.Spec.Args);
+    }
+
+    [Fact]
+    public async Task ProjectResource_EmptyLaunchToolArgs_ReplacesDotnetRunScaffolding_InProcessMode()
+    {
+        var builder = DistributedApplication.CreateBuilder();
+        builder.AddProject<TestProject>("proj", launchProfileName: null)
+            .WithArgs("app-arg")
+            .WithLaunchToolArgs(static _ => { });
+
+        using var app = builder.Build();
+        var model = app.Services.GetRequiredService<DistributedApplicationModel>();
+
+        var kubernetes = new TestKubernetesService();
+        var executor = CreateAppExecutor(model, kubernetesService: kubernetes);
+
+        await executor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetes, "proj");
+        Assert.Equal(ExecutionType.Process, exe.Spec.ExecutionType);
+        Assert.Equal(["app-arg"], exe.Spec.Args);
+    }
+
     [Fact]
     public async Task ProjectResource_WithLaunchToolArgsDebugSupport_DoesNotOfferProcessFallback_InDebugSession()
     {

From 711688802efadf25411b6f199fa1b198e9ab36c4 Mon Sep 17 00:00:00 2001
From: Karol Zadora-Przylecki <karolz@microsoft.com>
Date: Mon, 10 Aug 2026 20:26:23 -0700
Subject: [PATCH 12/13] Address issues from code review

---
 .../ProjectLaunchArgsOverrideAnnotation.cs    |   4 +
 src/Aspire.Hosting/Dcp/ExecutableCreator.cs   | 282 +++++++++++-------
 .../Dcp/DcpExecutorTests.cs                   | 245 +++++++++++++--
 3 files changed, 401 insertions(+), 130 deletions(-)

diff --git a/src/Aspire.Hosting/ApplicationModel/ProjectLaunchArgsOverrideAnnotation.cs b/src/Aspire.Hosting/ApplicationModel/ProjectLaunchArgsOverrideAnnotation.cs
index db4b9d6e3f2..33614b88099 100644
--- a/src/Aspire.Hosting/ApplicationModel/ProjectLaunchArgsOverrideAnnotation.cs
+++ b/src/Aspire.Hosting/ApplicationModel/ProjectLaunchArgsOverrideAnnotation.cs
@@ -19,6 +19,10 @@ namespace Aspire.Hosting.ApplicationModel;
 /// <c>build</c> that accept the project path as a positional argument. The <c>--no-launch-profile</c>
 /// flag is omitted when this annotation is present.
 /// </para>
+/// <para>
+/// A non-empty launch-tool argument callback replaces this base command. If the callback resolves no
+/// arguments, this override remains the Process command.
+/// </para>
 /// </remarks>
 /// <example>
 /// Override DCP's default launch to use <c>dotnet build /t:Run</c>:
diff --git a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
index 76bc368245e..a70fa69b1d9 100644
--- a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
+++ b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
@@ -105,7 +105,9 @@ public async Task CreateObjectAsync(RenderedModelResource<Executable> er, EmptyC
         // process-launched one does.
         var launchToolArgumentsData = configuration.AdditionalConfigurationData.OfType<LaunchToolArgumentsData>().FirstOrDefault();
         var resolvedLaunchToolArgumentCount = launchToolArgumentsData?.Count ?? 0;
-        await ApplyLaunchConfigurationAsync(er, exe, resolvedLaunchToolArgumentCount, cancellationToken).ConfigureAwait(false);
+        var hasPreparedProjectArguments = spec.Args is { Count: > 0 };
+        await ApplyLaunchConfigurationAsync(er, exe, resolvedLaunchToolArgumentCount, hasPreparedProjectArguments, cancellationToken).ConfigureAwait(false);
+        ApplyResolvedProjectArguments(er, exe, resolvedLaunchToolArgumentCount);
 
         var omittedLaunchToolArgumentCount = OmitLaunchToolArguments(er, spec)
             ? resolvedLaunchToolArgumentCount
@@ -120,7 +122,7 @@ public async Task CreateObjectAsync(RenderedModelResource<Executable> er, EmptyC
             resolvedLaunchToolArgumentCount,
             omittedLaunchToolArgumentCount,
             launchToolArgumentsData?.ShowInCommandLine ?? true);
-        if (!HasProjectLaunchArgsOverride(er.ModelResource))
+        if (resolvedLaunchToolArgumentCount > 0 || !HasProjectLaunchArgsOverride(er.ModelResource))
         {
             AddDotnetRunArgsForExecutableAnnotatedProject(er, launchArgs, executableArgumentStartIndex);
         }
@@ -136,7 +138,7 @@ public async Task CreateObjectAsync(RenderedModelResource<Executable> er, EmptyC
 
         // Argument and launch-configuration callbacks can change on restart. Derive fallback availability from the
         // final execution type and resolved command line every time instead of carrying a preparation-time guess.
-        spec.FallbackExecutionTypes = ShouldOfferProcessFallback(er.ModelResource, spec, resolvedLaunchToolArgumentCount, omittedLaunchToolArgumentCount)
+        spec.FallbackExecutionTypes = ShouldOfferProcessFallback(er.ModelResource, spec, resolvedLaunchToolArgumentCount, omittedLaunchToolArgumentCount, hasPreparedProjectArguments)
             ? [ExecutionType.Process]
             : null;
 
@@ -197,7 +199,12 @@ public async Task CreateObjectAsync(RenderedModelResource<Executable> er, EmptyC
     /// executables, so their "project" launch configuration is applied here for IDE/F5 parity with <c>AddProject</c>.
     /// All other types (plain executables and project subtypes like azure-functions) are also handled here.
     /// </remarks>
-    private async Task ApplyLaunchConfigurationAsync(RenderedModelResource<Executable> er, Executable exe, int resolvedLaunchToolArgumentCount, CancellationToken cancellationToken)
+    private async Task ApplyLaunchConfigurationAsync(
+        RenderedModelResource<Executable> er,
+        Executable exe,
+        int resolvedLaunchToolArgumentCount,
+        bool hasPreparedProjectArguments,
+        CancellationToken cancellationToken)
     {
         if (er.ModelResource.HasAnnotationOfType<ForceProcessExecutionAnnotation>()
             || HasProjectLaunchArgsOverride(er.ModelResource)
@@ -245,7 +252,7 @@ private async Task ApplyLaunchConfigurationAsync(RenderedModelResource<Executabl
         }
         catch (Exception ex)
         {
-            if (HasIncompleteProcessCommand(er.ModelResource, supportsDebuggingAnnotation, resolvedLaunchToolArgumentCount))
+            if (HasIncompleteProcessCommand(er.ModelResource, supportsDebuggingAnnotation, resolvedLaunchToolArgumentCount, hasPreparedProjectArguments))
             {
                 // This project-backed executable suppressed its process scaffold because the custom launch
                 // configuration performs the tool invocation. With no resolved prefix to replace it, Process
@@ -286,7 +293,12 @@ private bool OmitLaunchToolArguments(RenderedModelResource<Executable> er, Execu
     /// both the IDE form and the process form of the command line: when the tool-invocation prefix is omitted for the
     /// IDE, no fallback can be offered.
     /// </remarks>
-    private bool ShouldOfferProcessFallback(IResource modelResource, ExecutableSpec spec, int resolvedLaunchToolArgumentCount, int omittedLaunchToolArgumentCount)
+    private bool ShouldOfferProcessFallback(
+        IResource modelResource,
+        ExecutableSpec spec,
+        int resolvedLaunchToolArgumentCount,
+        int omittedLaunchToolArgumentCount,
+        bool hasPreparedProjectArguments)
     {
         if (spec.ExecutionType != ExecutionType.IDE || omittedLaunchToolArgumentCount > 0)
         {
@@ -301,7 +313,7 @@ private bool ShouldOfferProcessFallback(IResource modelResource, ExecutableSpec
         // Project-backed resources suppress their process scaffold when the active launch configuration owns the
         // tool invocation. If that prefix resolves empty, the remaining command line is IDE-only and cannot be used
         // as a Process fallback.
-        if (HasIncompleteProcessCommand(modelResource, annotation, resolvedLaunchToolArgumentCount))
+        if (HasIncompleteProcessCommand(modelResource, annotation, resolvedLaunchToolArgumentCount, hasPreparedProjectArguments))
         {
             return false;
         }
@@ -310,9 +322,14 @@ private bool ShouldOfferProcessFallback(IResource modelResource, ExecutableSpec
             || annotation.LaunchConfigurationType is not KnownLaunchConfigurationTypes.Project;
     }
 
-    private static bool HasIncompleteProcessCommand(IResource modelResource, SupportsDebuggingAnnotation annotation, int resolvedLaunchToolArgumentCount)
+    private static bool HasIncompleteProcessCommand(
+        IResource modelResource,
+        SupportsDebuggingAnnotation annotation,
+        int resolvedLaunchToolArgumentCount,
+        bool hasPreparedProjectArguments)
     {
         return resolvedLaunchToolArgumentCount == 0
+            && !hasPreparedProjectArguments
             && modelResource.HasAnnotationOfType<IProjectMetadata>()
             && modelResource.HasLaunchToolArgsOwnedBy(annotation);
     }
@@ -397,26 +414,15 @@ private async Task PrepareProjectExecutablesAsync(CancellationToken cancellation
                     // applied later in CreateExecutableAsync() after endpoints are allocated,
                     // unless the IDE didn't send DEBUG_SESSION_INFO (handled by the fallback branch below).
 
-                    // File-based apps (.cs files) are not supported by all IDEs (e.g. Visual Studio
-                    // returns 500 for them). Populate fallback process args so that when the IDE
-                    // rejects the launch request and DCP falls back to ExecutionType.Process, the
-                    // executable starts with the correct `dotnet run --file` arguments.
-                    if (projectMetadata.IsFileBasedApp)
+                    // Keep a candidate Process command so custom IDE launch configurations whose launch-tool
+                    // callback resolves empty have a runnable fallback. This also preserves the existing fallback
+                    // for file-based apps, which some IDEs reject. CreateExecutableAsync removes the candidate
+                    // when the active launch configuration or a non-empty launch-tool prefix replaces it.
+                    if (executableAnnotation is null &&
+                        (projectMetadata.IsFileBasedApp ||
+                         supportsDebuggingAnnotation.LaunchConfigurationType is not KnownLaunchConfigurationTypes.Project))
                     {
-                        projectArgs.Add("run");
-                        projectArgs.Add("--file");
-                        projectArgs.Add(projectMetadata.ProjectPath);
-                        projectArgs.Add("--no-cache");
-                        if (projectMetadata.SuppressBuild)
-                        {
-                            projectArgs.Add("--no-build");
-                        }
-                        projectArgs.Add("--no-launch-profile");
-
-                        if (!string.IsNullOrEmpty(_distributedApplicationOptions.Configuration))
-                        {
-                            projectArgs.AddRange(new[] { "--configuration", _distributedApplicationOptions.Configuration });
-                        }
+                        AddDefaultProjectProcessArgs(projectArgs, projectMetadata);
                     }
                 }
                 else if (!persistent && !forceProcessExecution && ShouldFallBackToIdeExecution(isInDebugSession, supportsDebuggingAnnotation, executableAnnotation))
@@ -434,58 +440,27 @@ private async Task PrepareProjectExecutablesAsync(CancellationToken cancellation
                     exe.Spec.ExecutionType = ExecutionType.IDE;
 
                     await ApplyProjectLaunchConfigurationAsync(exe, project, projectMetadata, supportsDebuggingAnnotation: null, cancellationToken).ConfigureAwait(false);
+
+                    if (executableAnnotation is null && projectMetadata.IsFileBasedApp)
+                    {
+                        AddDefaultProjectProcessArgs(projectArgs, projectMetadata);
+                    }
                 }
                 else
                 {
                     exe.Spec.ExecutionType = ExecutionType.Process;
 
-                    // Some ProjectResource subtypes provide their own executable command, and WithLaunchToolArgs
-                    // replaces the implicit project invocation even when its callback resolves empty. Do not prefix
-                    // either shape with Aspire's default `dotnet run --project ...` wrapper.
-                    if (executableAnnotation is null && !HasLaunchToolArgsDeclaration(project))
+                    // Some ProjectResource subtypes, such as MAUI platform resources, intentionally
+                    // provide their own executable command and SDK-shaped app host args. Do not prefix
+                    // those args with Aspire's default `dotnet run --project ...` wrapper.
+                    if (executableAnnotation is null)
                     {
                         var projectLaunchConfiguration = new ProjectLaunchConfiguration
                         {
                             ProjectPath = projectMetadata.ProjectPath
                         };
 
-                        // `dotnet watch` does not work with file-based apps yet, so we have to use `dotnet run` in that case
-                        if (_configuration.GetBool("DOTNET_WATCH") is not true || projectMetadata.IsFileBasedApp)
-                        {
-                            projectArgs.Add("run");
-                            projectArgs.Add(projectMetadata.IsFileBasedApp ? "--file" : "--project");
-                            projectArgs.Add(projectMetadata.ProjectPath);
-                            if (projectMetadata.IsFileBasedApp)
-                            {
-                                projectArgs.Add("--no-cache");
-                            }
-                            if (projectMetadata.SuppressBuild)
-                            {
-                                projectArgs.Add("--no-build");
-                            }
-                        }
-                        else
-                        {
-                            projectArgs.AddRange([
-                                "watch",
-                                "--non-interactive",
-                                "--no-hot-reload",
-                                "--project",
-                                projectMetadata.ProjectPath
-                            ]);
-                        }
-
-                        if (!string.IsNullOrEmpty(_distributedApplicationOptions.Configuration))
-                        {
-                            projectArgs.AddRange(new[] { "--configuration", _distributedApplicationOptions.Configuration });
-                        }
-
-                        // We pretty much always want to suppress the normal launch profile handling
-                        // because the settings from the profile will override the ambient environment settings, which is not what we want
-                        // (the ambient environment settings for service processes come from the application model
-                        // and should be HIGHER priority than the launch profile settings).
-                        // This means we need to apply the launch profile settings manually inside CreateExecutableAsync().
-                        projectArgs.Add("--no-launch-profile");
+                        AddDefaultProjectProcessArgs(projectArgs, projectMetadata);
 
                         // We want this annotation even if we are not using IDE execution; see ToSnapshot() for details.
                         exe.AnnotateAsObjectList(Executable.LaunchConfigurationsAnnotation, projectLaunchConfiguration);
@@ -506,6 +481,68 @@ private async Task PrepareProjectExecutablesAsync(CancellationToken cancellation
         }
     }
 
+    private static void ApplyResolvedProjectArguments(RenderedModelResource<Executable> er, Executable exe, int resolvedLaunchToolArgumentCount)
+    {
+        if (er.ModelResource is not ProjectResource ||
+            !er.ModelResource.TryGetProjectMetadata(out var projectMetadata))
+        {
+            return;
+        }
+
+        var projectLaunchConfigurationOwnsInvocation =
+            exe.Spec.ExecutionType == ExecutionType.IDE &&
+            exe.TryGetAnnotationAsObjectList<ProjectLaunchConfiguration>(Executable.LaunchConfigurationsAnnotation, out var launchConfigurations) &&
+            launchConfigurations.Any(static configuration => configuration.Type is KnownLaunchConfigurationTypes.Project);
+
+        // ResourceProjectArgsAnnotation carries a candidate Process command. Discard it before effective argument
+        // indexes are assigned when a resolved launch-tool prefix replaces it, or when a normal project IDE launch
+        // owns the invocation. File-based apps retain their Process command because IDEs can reject that launch type.
+        if (resolvedLaunchToolArgumentCount > 0 ||
+            (projectLaunchConfigurationOwnsInvocation &&
+             !projectMetadata.IsFileBasedApp))
+        {
+            exe.Spec.Args = null;
+        }
+    }
+
+    private void AddDefaultProjectProcessArgs(List<string> projectArgs, IProjectMetadata projectMetadata)
+    {
+        // `dotnet watch` does not work with file-based apps yet, so use `dotnet run` in that case.
+        if (_configuration.GetBool("DOTNET_WATCH") is not true || projectMetadata.IsFileBasedApp)
+        {
+            projectArgs.Add("run");
+            projectArgs.Add(projectMetadata.IsFileBasedApp ? "--file" : "--project");
+            projectArgs.Add(projectMetadata.ProjectPath);
+            if (projectMetadata.IsFileBasedApp)
+            {
+                projectArgs.Add("--no-cache");
+            }
+            if (projectMetadata.SuppressBuild)
+            {
+                projectArgs.Add("--no-build");
+            }
+        }
+        else
+        {
+            projectArgs.AddRange([
+                "watch",
+                "--non-interactive",
+                "--no-hot-reload",
+                "--project",
+                projectMetadata.ProjectPath
+            ]);
+        }
+
+        if (!string.IsNullOrEmpty(_distributedApplicationOptions.Configuration))
+        {
+            projectArgs.AddRange(["--configuration", _distributedApplicationOptions.Configuration]);
+        }
+
+        // Suppress dotnet's launch-profile handling because the application model materializes those settings
+        // and they must take precedence over the ambient values that `dotnet run` would otherwise apply.
+        projectArgs.Add("--no-launch-profile");
+    }
+
     private void PreparePlainExecutables()
     {
         var modelExecutableResources = _model.GetExecutableResources();
@@ -721,11 +758,12 @@ bool showLaunchToolArgsInCommandLine
         // Follows behavior in the IDE execution spec when in IDE execution mode:
         // https://github.com/microsoft/aspire/blob/main/docs/specs/IDE-execution.md#project-launch-configuration-type-project
         var appHostArgList = appHostArgs.ToList();
-        var hasLaunchToolArgsDeclaration = HasLaunchToolArgsDeclaration(er.ModelResource);
 #pragma warning disable ASPIREPROJECTS001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
         var hasProjectLaunchArgsOverride = er.ModelResource.TryGetLastAnnotation<ProjectLaunchArgsOverrideAnnotation>(out var projectLaunchArgsOverride);
 #pragma warning restore ASPIREPROJECTS001
-        if (projectLaunchArgsOverride?.LeadingResourceArgumentToRemove is { } leadingResourceArgumentToRemove &&
+        var useProjectLaunchArgsOverride = hasProjectLaunchArgsOverride && launchToolArgumentCount == 0;
+        if (useProjectLaunchArgsOverride &&
+            projectLaunchArgsOverride?.LeadingResourceArgumentToRemove is { } leadingResourceArgumentToRemove &&
             appHostArgList.Count > 0 &&
             string.Equals(appHostArgList[0].Value, leadingResourceArgumentToRemove, StringComparison.Ordinal))
         {
@@ -749,19 +787,30 @@ LaunchArgument CreateLaunchArgument(string value, bool isSensitive, bool executa
         }
 
         // If the executable is a project then include any command line args from the launch profile.
-        if (!hasProjectLaunchArgsOverride && er.ModelResource is ProjectResource project)
+        if (!useProjectLaunchArgsOverride && er.ModelResource is ProjectResource project)
         {
+            var projectLaunchConfigurationHandlesLaunchProfile =
+                spec.ExecutionType == ExecutionType.IDE &&
+                er.DcpResource.TryGetAnnotationAsObjectList<ProjectLaunchConfiguration>(Executable.LaunchConfigurationsAnnotation, out var projectLaunchConfigurations) &&
+                projectLaunchConfigurations.Any(static configuration => configuration.Type is KnownLaunchConfigurationTypes.Project);
+            var ordinaryAppHostArgumentCount = Math.Max(0, appHostArgList.Count - launchToolArgumentCount);
+
             // Args in the launch profile is used when:
             // 1. The project is run as an executable. Launch profile args are combined with app host supplied args.
-            // 2. The project is run by the IDE and no app host args are specified.
-            if (spec.ExecutionType == ExecutionType.Process || (spec.ExecutionType == ExecutionType.IDE && appHostArgList.Count == 0))
+            // 2. A custom IDE launch configuration cannot carry launch_profile, so DCP supplies those args.
+            // 3. A project IDE launch has no ordinary app host args, so the profile args are displayed.
+            if (spec.ExecutionType == ExecutionType.Process ||
+                !projectLaunchConfigurationHandlesLaunchProfile ||
+                ordinaryAppHostArgumentCount == 0)
             {
-                // When the .NET project is launched from an IDE the launch profile args are automatically added.
-                // We still want to display the args in the dashboard so only add them to the custom arg annotations.
-                includeProfileArgsInSpec = spec.ExecutionType != ExecutionType.IDE;
+                includeProfileArgsInSpec =
+                    spec.ExecutionType == ExecutionType.Process ||
+                    !projectLaunchConfigurationHandlesLaunchProfile;
 
                 projectLaunchProfileArgs = GetLaunchProfileArgs(project.GetEffectiveLaunchProfile()?.LaunchProfile);
-                if (projectLaunchProfileArgs.Count > 0 && appHostArgList.Count > 0 && !hasLaunchToolArgsDeclaration)
+                if (projectLaunchProfileArgs.Count > 0 &&
+                    ordinaryAppHostArgumentCount > 0 &&
+                    launchToolArgumentCount == 0)
                 {
                     // The implicit `dotnet run` scaffold needs a double-dash before application arguments. A custom
                     // launch-tool declaration owns its complete invocation, including any separator its tool requires.
@@ -769,22 +818,57 @@ LaunchArgument CreateLaunchArgument(string value, bool isSensitive, bool executa
                 }
             }
         }
-        else if (er.ModelResource is DotnetToolResource)
+        else if (er.ModelResource is DotnetToolResource dotnetToolResource)
         {
-            // Dotnet tools compose args as `tool exec <package> ... -- <app args>`. Keep hiding the invocation
-            // through `--`, but let the shared loop below apply launch-tool omission and visibility. A launch-tool
-            // prefix can have its own separator, so search only the ordinary argument segment for this boundary.
-            var argSeparatorIndex = appHostArgList.FindIndex(
-                launchToolArgumentCount,
-                static a => a.Value == DotnetToolResourceExtensions.ArgumentSeparator);
+            // AddDotnetTool contributes `tool exec <package> ... --` through the ordinary argument segment because
+            // its separate EF command executor replays those callbacks directly. A resolved launch-tool prefix
+            // replaces that built-in invocation for DCP execution; otherwise keep hiding it from the dashboard.
+            var toolConfiguration = dotnetToolResource.ToolConfiguration;
+            var builtInInvocationStartIndex = -1;
+            if (toolConfiguration is not null)
+            {
+                for (var i = launchToolArgumentCount; i <= appHostArgList.Count - 5; i++)
+                {
+                    if (appHostArgList[i].Value == "tool" &&
+                        appHostArgList[i + 1].Value == "exec" &&
+                        appHostArgList[i + 2].Value == toolConfiguration.PackageId)
+                    {
+                        builtInInvocationStartIndex = i;
+                        break;
+                    }
+                }
+            }
 
-            firstVisibleAppHostArgumentIndex = argSeparatorIndex + 1;
+            var builtInInvocationEndIndex = -1;
+            if (builtInInvocationStartIndex >= 0)
+            {
+                for (var i = builtInInvocationStartIndex + 4; i < appHostArgList.Count; i++)
+                {
+                    if (appHostArgList[i].Value == DotnetToolResourceExtensions.ArgumentSeparator &&
+                        appHostArgList[i - 1].Value == "--yes")
+                    {
+                        builtInInvocationEndIndex = i;
+                        break;
+                    }
+                }
+            }
+
+            if (launchToolArgumentCount > 0 && builtInInvocationEndIndex >= 0)
+            {
+                appHostArgList.RemoveRange(
+                    builtInInvocationStartIndex,
+                    builtInInvocationEndIndex - builtInInvocationStartIndex + 1);
+            }
+            else if (builtInInvocationEndIndex >= 0)
+            {
+                firstVisibleAppHostArgumentIndex = builtInInvocationEndIndex + 1;
+            }
         }
 
         // Project launch-profile arguments are application arguments. When a custom launch-tool declaration replaces
         // the implicit `dotnet run` scaffold, keep its prefix first and insert profile arguments before ordinary
         // app-host arguments. Without such a declaration, preserve the existing profile-before-app-host ordering.
-        var projectLaunchProfileArgumentInsertIndex = hasLaunchToolArgsDeclaration
+        var projectLaunchProfileArgumentInsertIndex = launchToolArgumentCount > 0
             ? Math.Min(launchToolArgumentCount, appHostArgList.Count)
             : 0;
 
@@ -840,17 +924,18 @@ private void AddDotnetRunArgsForExecutableAnnotatedProject(RenderedModelResource
         }
 
         List<LaunchArgument>? launchProfileArgs = null;
-        if (runIndex > 0 &&
-            launchArgs[0].Executable &&
-            string.Equals(launchArgs[0].Value, "--", StringComparison.Ordinal))
+        var firstExecutableArgumentIndex = launchArgs.FindIndex(static argument => argument.Executable);
+        if (firstExecutableArgumentIndex >= 0 &&
+            runIndex > firstExecutableArgumentIndex &&
+            string.Equals(launchArgs[firstExecutableArgumentIndex].Value, "--", StringComparison.Ordinal))
         {
-            // Process execution passes project launch-profile args before "dotnet run", separated by "--".
-            // IDE execution already owns the launch profile via ProjectLaunchConfiguration, so keep those
-            // values out of the executable argument list while we insert the AppHost configuration flags
-            // immediately after "dotnet run".
-            launchProfileArgs = launchArgs.GetRange(0, runIndex);
-            launchArgs.RemoveRange(0, runIndex);
-            runIndex = 0;
+            // Executable launch-profile args were composed before the caller-provided `dotnet run` command.
+            // Preserve any non-executable launch-tool display prefix, then move the profile segment after
+            // `dotnet run` so the SDK parses it as application arguments.
+            var launchProfileArgumentCount = runIndex - firstExecutableArgumentIndex;
+            launchProfileArgs = launchArgs.GetRange(firstExecutableArgumentIndex, launchProfileArgumentCount);
+            launchArgs.RemoveRange(firstExecutableArgumentIndex, launchProfileArgumentCount);
+            runIndex -= launchProfileArgumentCount;
         }
 
         var argsToInsert = new List<string>();
@@ -915,11 +1000,6 @@ private static bool HasProjectLaunchArgsOverride(IResource resource)
 #pragma warning restore ASPIREPROJECTS001
     }
 
-    private static bool HasLaunchToolArgsDeclaration(IResource resource)
-    {
-        return resource.TryGetLastAnnotation<LaunchToolArgsCallbackAnnotation>(out _);
-    }
-
     private static void ReindexExecutableLaunchArgs(List<LaunchArgument> launchArgs, int executableArgumentStartIndex)
     {
         var nextExecutableArgumentIndex = executableArgumentStartIndex;
diff --git a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
index 6af95388613..0b1aa3c16ec 100644
--- a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
+++ b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
@@ -308,15 +308,54 @@ public async Task DotnetToolResource_ExtensionMode_OwnedLaunchToolArgsAreWithhel
 
         var exe = GetCreatedExecutableForResource(kubernetesService, "tool");
         Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
-        string[] dotnetToolExecArgs = ["tool", "exec", "package", "--yes", "--"];
-        Assert.Equal([.. dotnetToolExecArgs, "app-arg"], exe.Spec.Args);
+        Assert.Equal(["app-arg"], exe.Spec.Args);
         Assert.Null(exe.Spec.FallbackExecutionTypes);
 
         Assert.True(exe.TryGetAnnotationAsObjectList<AppLaunchArgumentAnnotation>(CustomResource.ResourceAppArgsAnnotation, out var displayArgs));
+        string[] dotnetToolExecArgs = ["tool", "exec", "package", "--yes", "--"];
         string[] expectedDisplayArgs = showInCommandLine ? [.. dotnetToolExecArgs, "app-arg"] : ["app-arg"];
         Assert.Equal(expectedDisplayArgs, displayArgs.Select(a => a.Argument));
         Assert.All(displayArgs.Take(displayArgs.Count - 1), argument => Assert.Null(argument.EffectiveArgumentIndex));
-        Assert.Equal(dotnetToolExecArgs.Length, displayArgs[^1].EffectiveArgumentIndex);
+        Assert.Equal(0, displayArgs[^1].EffectiveArgumentIndex);
+        AssertEffectiveArgumentIndexesMatchSpecArgs(displayArgs, exe.Spec.Args);
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task DotnetToolResource_ProcessMode_LaunchToolArgsReplaceBuiltInInvocation(bool showInCommandLine)
+    {
+        var builder = DistributedApplication.CreateBuilder();
+
+        builder.AddDotnetTool("tool", "package")
+            .WithArgs("app-arg")
+            .WithArgs(static context => context.Args.Insert(0, "prepended-arg"))
+            .WithLaunchToolArgs(
+                static context =>
+                {
+                    context.Args.Add("custom");
+                    context.Args.Add("exec");
+                    context.Args.Add("--");
+                },
+                showInCommandLine: showInCommandLine);
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetesService, "tool");
+        Assert.Equal(ExecutionType.Process, exe.Spec.ExecutionType);
+        Assert.Equal(["custom", "exec", "--", "prepended-arg", "app-arg"], exe.Spec.Args);
+
+        Assert.True(exe.TryGetAnnotationAsObjectList<AppLaunchArgumentAnnotation>(CustomResource.ResourceAppArgsAnnotation, out var displayArgs));
+        string[] expectedDisplayArgs = showInCommandLine
+            ? new[] { "custom", "exec", "--", "prepended-arg", "app-arg" }
+            : ["prepended-arg", "app-arg"];
+        Assert.Equal(expectedDisplayArgs, displayArgs.Select(a => a.Argument));
+        Assert.Equal(4, displayArgs[^1].EffectiveArgumentIndex);
         AssertEffectiveArgumentIndexesMatchSpecArgs(displayArgs, exe.Spec.Args);
     }
 
@@ -3758,7 +3797,7 @@ public async Task ProjectResource_WithLaunchToolArgs_ReplacesDotnetRunScaffoldin
     }
 
     [Fact]
-    public async Task ProjectResource_EmptyLaunchToolArgs_ReplacesDotnetRunScaffolding_InProcessMode()
+    public async Task ProjectResource_EmptyLaunchToolArgs_KeepsDotnetRunScaffolding_InProcessMode()
     {
         var builder = DistributedApplication.CreateBuilder();
         builder.AddProject<TestProject>("proj", launchProfileName: null)
@@ -3775,7 +3814,7 @@ public async Task ProjectResource_EmptyLaunchToolArgs_ReplacesDotnetRunScaffoldi
 
         var exe = GetCreatedExecutableForResource(kubernetes, "proj");
         Assert.Equal(ExecutionType.Process, exe.Spec.ExecutionType);
-        Assert.Equal(["app-arg"], exe.Spec.Args);
+        AssertDefaultProjectProcessArgs(exe.Spec.Args, "app-arg");
     }
 
     [Fact]
@@ -3823,10 +3862,8 @@ public async Task ProjectResource_WithLaunchToolArgsDebugSupport_DoesNotOfferPro
     }
 
     [Fact]
-    public async Task ProjectResource_EmptyOwnedLaunchToolArgs_DoesNotOfferBrokenProcessFallback()
+    public async Task ProjectResource_EmptyOwnedLaunchToolArgs_KeepsRunnableProcessFallback()
     {
-        // An owned launch-tool declaration suppresses the process scaffold even when its callback resolves empty.
-        // The remaining `dotnet <app-args>` command is only meaningful to the IDE and cannot be used as a fallback.
         var builder = DistributedApplication.CreateBuilder();
         var projectBuilder = builder.AddProject<TestProject>("proj", launchProfileName: null);
 
@@ -3861,12 +3898,12 @@ public async Task ProjectResource_EmptyOwnedLaunchToolArgs_DoesNotOfferBrokenPro
 
         var exe = GetCreatedExecutableForResource(kubernetes, "proj");
         Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
-        Assert.Equal(["app-arg"], exe.Spec.Args);
-        Assert.Null(exe.Spec.FallbackExecutionTypes);
+        AssertDefaultProjectProcessArgs(exe.Spec.Args, "app-arg");
+        Assert.Equal(ExecutionType.Process, Assert.Single(exe.Spec.FallbackExecutionTypes!));
     }
 
     [Fact]
-    public async Task ProjectResource_EmptyOwnedLaunchToolArgs_LaunchConfigurationFailureDoesNotRunBrokenProcessCommand()
+    public async Task ProjectResource_EmptyOwnedLaunchToolArgs_LaunchConfigurationFailureFallsBackToProcess()
     {
         var builder = DistributedApplication.CreateBuilder();
         var projectBuilder = builder.AddProject<TestProject>("proj", launchProfileName: null);
@@ -3886,14 +3923,6 @@ public async Task ProjectResource_EmptyOwnedLaunchToolArgs_LaunchConfigurationFa
         var model = app.Services.GetRequiredService<DistributedApplicationModel>();
 
         var kubernetes = new TestKubernetesService();
-        var failedResources = new List<IResource>();
-        var events = new DcpExecutorEvents();
-        events.Subscribe<OnResourceFailedToStartContext>(context =>
-        {
-            failedResources.Add(context.Resource);
-            return Task.CompletedTask;
-        });
-
         var configuration = new ConfigurationBuilder()
             .AddInMemoryCollection(new Dictionary<string, string?>
             {
@@ -3905,13 +3934,14 @@ public async Task ProjectResource_EmptyOwnedLaunchToolArgs_LaunchConfigurationFa
         var executor = CreateAppExecutor(
             model,
             configuration: configuration,
-            kubernetesService: kubernetes,
-            events: events);
+            kubernetesService: kubernetes);
 
         await executor.RunApplicationAsync();
 
-        Assert.Empty(GetCreatedExecutablesForResource(kubernetes, "proj"));
-        Assert.Same(projectBuilder.Resource, Assert.Single(failedResources));
+        var exe = GetCreatedExecutableForResource(kubernetes, "proj");
+        Assert.Equal(ExecutionType.Process, exe.Spec.ExecutionType);
+        AssertDefaultProjectProcessArgs(exe.Spec.Args, "app-arg");
+        Assert.Null(exe.Spec.FallbackExecutionTypes);
 
         static ExecutableLaunchConfiguration ThrowingLaunchConfiguration(string mode)
         {
@@ -5164,6 +5194,118 @@ public async Task MauiProjectWithExecutableAnnotationAndSupportedLaunchConfigura
         Assert.Equal("-e", launchConfig.MsBuildProperties!["AdbTarget"]);
     }
 
+    [Fact]
+    public async Task ProjectResource_CustomIdeLaunch_OwnedLaunchToolArgsPreserveLaunchProfileArgs()
+    {
+        var builder = DistributedApplication.CreateBuilder();
+        var projectBuilder = builder.AddProject<TestProjectWithLaunchProfileCommandLineArgs>("proj", launchProfileName: "http");
+        var defaultAnnotation = projectBuilder.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().FirstOrDefault();
+        if (defaultAnnotation is not null)
+        {
+            projectBuilder.Resource.Annotations.Remove(defaultAnnotation);
+        }
+
+        projectBuilder
+            .WithArgs("app-arg")
+            .WithLaunchToolArgs(
+                static context =>
+                {
+                    context.Args.Add("tool");
+                    context.Args.Add("--");
+                },
+                ownedByLaunchConfigurationType: "custom")
+            .WithDebugSupport(
+                mode => new ExecutableLaunchConfiguration("custom") { Mode = mode },
+                "custom");
+
+        var configuration = new ConfigurationBuilder()
+            .AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                [DcpExecutor.DebugSessionPortVar] = "12345",
+                [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["test"], SupportedLaunchConfigurations = ["custom"] })
+            })
+            .Build();
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService, configuration: configuration);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetesService, "proj");
+        Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
+        Assert.Equal(["--profile-arg", "profile value", "app-arg"], exe.Spec.Args);
+        Assert.Null(exe.Spec.FallbackExecutionTypes);
+
+        Assert.True(exe.TryGetAnnotationAsObjectList<AppLaunchArgumentAnnotation>(CustomResource.ResourceAppArgsAnnotation, out var displayArgs));
+        Assert.Equal(["tool", "--", "--profile-arg", "profile value", "app-arg"], displayArgs.Select(a => a.Argument));
+        Assert.All(displayArgs.Take(2), argument => Assert.Null(argument.EffectiveArgumentIndex));
+        AssertEffectiveArgumentIndexesMatchSpecArgs(displayArgs, exe.Spec.Args);
+    }
+
+    [Fact]
+    public async Task ProjectResource_CustomIdeLaunch_ExecutableAnnotatedProjectPreservesLaunchProfileArgs()
+    {
+        var builder = DistributedApplication.CreateBuilder();
+        var projectBuilder = builder.AddProject<TestProjectWithLaunchProfileCommandLineArgs>("proj", launchProfileName: "http");
+        var defaultAnnotation = projectBuilder.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().FirstOrDefault();
+        if (defaultAnnotation is not null)
+        {
+            projectBuilder.Resource.Annotations.Remove(defaultAnnotation);
+        }
+
+        projectBuilder
+            .WithAnnotation(new ExecutableAnnotation
+            {
+                Command = "dotnet",
+                WorkingDirectory = "/tmp/mauiapp"
+            })
+            .WithDebugSupport(
+                mode => new TestMauiLaunchConfiguration
+                {
+                    Mode = mode,
+                    ProjectPath = "/tmp/mauiapp/MauiApp.csproj",
+                    TargetFramework = "net10.0-ios",
+                    Platform = "ios",
+                    TargetKind = "simulator"
+                },
+                "maui")
+            .WithArgs("run", "-f", "net10.0-ios");
+
+        var configuration = new ConfigurationBuilder()
+            .AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                [DcpExecutor.DebugSessionPortVar] = "12345",
+                [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo { ProtocolsSupported = ["coreclr"], SupportedLaunchConfigurations = ["maui"] })
+            })
+            .Build();
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService, configuration: configuration);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetesService, "proj");
+        Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
+        var expectedArgs = new List<string> { "run" };
+        if (GetTestAssemblyConfiguration() is { } configurationName)
+        {
+            expectedArgs.AddRange(["--configuration", configurationName]);
+        }
+        expectedArgs.AddRange(["--no-launch-profile", "-f", "net10.0-ios", "--", "--profile-arg", "profile value"]);
+        Assert.Equal(expectedArgs, exe.Spec.Args);
+        Assert.Equal(ExecutionType.Process, Assert.Single(exe.Spec.FallbackExecutionTypes!));
+
+        Assert.True(exe.TryGetAnnotationAsObjectList<AppLaunchArgumentAnnotation>(CustomResource.ResourceAppArgsAnnotation, out var displayArgs));
+        Assert.Equal(
+            ["run", "-f", "net10.0-ios", "--", "--profile-arg", "profile value"],
+            displayArgs.Select(a => a.Argument));
+        AssertEffectiveArgumentIndexesMatchSpecArgs(displayArgs, exe.Spec.Args);
+    }
+
     [Fact]
     public async Task ProjectWithNonProjectAnnotationAndExecutableAnnotation_LaunchProfileArgsStayAfterDotnetRunArgs()
     {
@@ -5763,7 +5905,7 @@ public async Task ProjectExecutable_WithLaunchArgsOverride_AndLeadingResourceArg
     }
 
     [Fact]
-    public async Task ProjectExecutable_WithLaunchArgsOverride_AndLeadingLaunchToolArgumentToRemove_DisplaysOrdinaryArguments()
+    public async Task ProjectExecutable_WithLaunchArgsOverride_EmptyLaunchToolArgsKeepOverride()
     {
         var builder = DistributedApplication.CreateBuilder(new DistributedApplicationOptions
         {
@@ -5771,8 +5913,8 @@ public async Task ProjectExecutable_WithLaunchArgsOverride_AndLeadingLaunchToolA
         });
 
         var projectBuilder = builder.AddProject<Projects.ServiceA>("ServiceA")
-            .WithArgs("-f", "net10.0-ios")
-            .WithLaunchToolArgs(static ctx => ctx.Args.Add("run"), showInCommandLine: false);
+            .WithArgs("run", "-f", "net10.0-ios")
+            .WithLaunchToolArgs(static _ => { });
 #pragma warning disable ASPIREPROJECTS001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
         projectBuilder.Resource.Annotations.Add(new ProjectLaunchArgsOverrideAnnotation(["build", "/t:Run"], leadingResourceArgumentToRemove: "run"));
 #pragma warning restore ASPIREPROJECTS001
@@ -5785,7 +5927,6 @@ public async Task ProjectExecutable_WithLaunchArgsOverride_AndLeadingLaunchToolA
         await appExecutor.RunApplicationAsync();
 
         var exe = GetCreatedExecutableForResource(kubernetesService, "ServiceA");
-
         Assert.Equal(ExecutionType.Process, exe.Spec.ExecutionType);
         Assert.Collection(
             exe.Spec.Args!,
@@ -5796,19 +5937,52 @@ public async Task ProjectExecutable_WithLaunchArgsOverride_AndLeadingLaunchToolA
             arg => Assert.Equal(GetTestAssemblyConfiguration(), arg),
             arg => Assert.Equal("-f", arg),
             arg => Assert.Equal("net10.0-ios", arg));
+    }
+
+    [Fact]
+    public async Task ProjectExecutable_WithLaunchArgsOverride_NonEmptyLaunchToolArgsReplaceOverride()
+    {
+        var builder = DistributedApplication.CreateBuilder(new DistributedApplicationOptions
+        {
+            AssemblyName = typeof(DistributedApplicationTests).Assembly.FullName
+        });
+
+        var projectBuilder = builder.AddProject<Projects.ServiceA>("ServiceA", launchProfileName: null)
+            .WithArgs("-f", "net10.0-ios")
+            .WithLaunchToolArgs(static ctx => ctx.Args.Add("run"), showInCommandLine: false);
+#pragma warning disable ASPIREPROJECTS001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
+        projectBuilder.Resource.Annotations.Add(new ProjectLaunchArgsOverrideAnnotation(["build", "/t:Run"], leadingResourceArgumentToRemove: "run"));
+#pragma warning restore ASPIREPROJECTS001
+
+        var kubernetesService = new TestKubernetesService();
+        using var app = builder.Build();
+        var distributedAppModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+        var appExecutor = CreateAppExecutor(distributedAppModel, kubernetesService: kubernetesService);
+
+        await appExecutor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetesService, "ServiceA");
+
+        Assert.Equal(ExecutionType.Process, exe.Spec.ExecutionType);
+        Assert.Collection(
+            exe.Spec.Args!,
+            arg => Assert.Equal("run", arg),
+            arg => Assert.Equal("-f", arg),
+            arg => Assert.Equal("net10.0-ios", arg));
 
         Assert.True(exe.TryGetAnnotationAsObjectList<AppLaunchArgumentAnnotation>(CustomResource.ResourceAppArgsAnnotation, out var displayArgs));
         Assert.Collection(displayArgs,
             arg =>
             {
                 Assert.Equal("-f", arg.Argument);
-                Assert.Equal(5, arg.EffectiveArgumentIndex);
+                Assert.Equal(1, arg.EffectiveArgumentIndex);
             },
             arg =>
             {
                 Assert.Equal("net10.0-ios", arg.Argument);
-                Assert.Equal(6, arg.EffectiveArgumentIndex);
+                Assert.Equal(2, arg.EffectiveArgumentIndex);
             });
+        AssertEffectiveArgumentIndexesMatchSpecArgs(displayArgs, exe.Spec.Args);
     }
 
     [Fact]
@@ -7659,6 +7833,19 @@ private static void HasKnownProjectCommandAnnotations(IResource resource)
             a => Assert.Equal(KnownResourceCommands.RebuildCommand, a.Name));
     }
 
+    private static void AssertDefaultProjectProcessArgs(IReadOnlyList<string>? actualArgs, params string[] appArgs)
+    {
+        var expectedArgs = new List<string> { "run", "--project", "TestProject" };
+        if (GetTestAssemblyConfiguration() is { } configuration)
+        {
+            expectedArgs.AddRange(["--configuration", configuration]);
+        }
+        expectedArgs.Add("--no-launch-profile");
+        expectedArgs.AddRange(appArgs);
+
+        Assert.Equal(expectedArgs, actualArgs);
+    }
+
     private static string? GetTestAssemblyConfiguration() =>
         (Attribute.GetCustomAttribute(typeof(DcpExecutorTests).Assembly, typeof(System.Reflection.AssemblyConfigurationAttribute)) as System.Reflection.AssemblyConfigurationAttribute)?.Configuration;
 

From 6f422aa4ae0d129ad663ee3f377a512fe5e26a65 Mon Sep 17 00:00:00 2001
From: Karol Zadora-Przylecki <karolz@microsoft.com>
Date: Mon, 10 Aug 2026 21:25:11 -0700
Subject: [PATCH 13/13] Additional consistency and correctness fixes

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: c2832706-3a43-42eb-a327-d853af5ea638
---
 .../EFResourceBuilderExtensions.cs            | 46 ++++++++-------
 .../ApplicationModel/ResourceExtensions.cs    |  8 +--
 src/Aspire.Hosting/Aspire.Hosting.csproj      |  1 +
 src/Aspire.Hosting/Dcp/ExecutableCreator.cs   | 56 +------------------
 .../DotnetToolResourceExtensions.cs           |  4 +-
 .../AddDotnetToolTests.cs                     | 39 +++++++++++++
 .../EFCoreOperationExecutorTests.cs           | 35 ++++++++++++
 .../Dcp/DcpExecutorTests.cs                   | 43 ++++++++++++++
 8 files changed, 149 insertions(+), 83 deletions(-)

diff --git a/src/Aspire.Hosting.EntityFrameworkCore/EFResourceBuilderExtensions.cs b/src/Aspire.Hosting.EntityFrameworkCore/EFResourceBuilderExtensions.cs
index fc125197c99..c6c3d38a8dd 100644
--- a/src/Aspire.Hosting.EntityFrameworkCore/EFResourceBuilderExtensions.cs
+++ b/src/Aspire.Hosting.EntityFrameworkCore/EFResourceBuilderExtensions.cs
@@ -453,31 +453,14 @@ await notificationService.PublishUpdateAsync(toolResource, s => s with
                 CreateNoWindow = true
             };
 
-            // Build command-line arguments by directly invoking each annotation's Callback.
-            // We intentionally bypass ExecutionConfigurationBuilder.WithArgumentsConfig() here
-            // because it uses EvaluateOnceAsync which caches callback results. When the tool
-            // resource is reused across sequential EF commands (e.g., script then bundle),
-            // the cached BuildToolExecArguments callback does not re-populate the shared
-            // callbackContext.Args list, so later annotations (the per-command EF args) run
-            // against an empty list.
-            if (toolResource.TryGetAnnotationsOfType<CommandLineArgsCallbackAnnotation>(out var cmdLineAnnotations))
+            var toolArguments = await GatherToolArgumentsAsync(
+                toolResource,
+                executionContext,
+                context.Logger,
+                context.CancellationToken).ConfigureAwait(false);
+            foreach (var argument in toolArguments)
             {
-                IList<object> args = [];
-                var callbackContext = new CommandLineArgsCallbackContext(args, toolResource, context.CancellationToken)
-                {
-                    Logger = context.Logger,
-                    ExecutionContext = executionContext
-                };
-
-                foreach (var ann in cmdLineAnnotations)
-                {
-                    await ann.Callback(callbackContext).ConfigureAwait(false);
-                }
-
-                foreach (var arg in callbackContext.Args)
-                {
-                    startInfo.ArgumentList.Add(arg.ToString()!);
-                }
+                startInfo.ArgumentList.Add(argument.ToString()!);
             }
 
             foreach (var kvp in GetToolEnvironmentVariables(executionConfiguration, executionContext.IsPublishMode))
@@ -608,6 +591,21 @@ await notificationService.PublishUpdateAsync(toolResource, s => s with
         }
     }
 
+    /// <summary>
+    /// Composes the EF tool arguments without cached callback results so sequential commands remain independent.
+    /// </summary>
+    internal static ValueTask<List<object>> GatherToolArgumentsAsync(
+        DotnetToolResource toolResource,
+        DistributedApplicationExecutionContext executionContext,
+        ILogger logger,
+        CancellationToken cancellationToken)
+    {
+        return toolResource.GatherArgumentValuesWithoutCachingAsync(
+            executionContext,
+            logger,
+            cancellationToken);
+    }
+
     // Selects the environment variables to apply to the EF tool process. In publish mode connection
     // string references resolve to manifest placeholder expressions (e.g. "{postgres.connectionString}")
     // rather than real values because the target resources aren't provisioned yet. Passing such a
diff --git a/src/Aspire.Hosting/ApplicationModel/ResourceExtensions.cs b/src/Aspire.Hosting/ApplicationModel/ResourceExtensions.cs
index 5a5f9137de5..04e9efcad0c 100644
--- a/src/Aspire.Hosting/ApplicationModel/ResourceExtensions.cs
+++ b/src/Aspire.Hosting/ApplicationModel/ResourceExtensions.cs
@@ -255,16 +255,14 @@ public static async ValueTask<string[]> GetArgumentValuesAsync(this IResourceWit
     }
 
     /// <summary>
-    /// Gather argument values, but do not resolve them. Used to allow multiple callbacks to constructively contribute to
-    /// the argument list before resolving.
+    /// Gathers argument values without resolving them or using cached callback results.
     /// </summary>
     /// <param name="resource">The resource to retrieve argument values for.</param>
     /// <param name="executionContext">The execution context used during the retrieval of argument values.</param>
     /// <param name="logger">The logger used for logging information or errors during the retrieval of argument values.</param>
     /// <param name="cancellationToken">A token for cancelling the operation, if needed.</param>
     /// <returns>A list of unprocessed argument values.</returns>
-    [Obsolete("Use ExecutionConfigurationBuilder instead.")]
-    internal static async ValueTask<List<object>> GatherArgumentValuesAsync(
+    internal static async ValueTask<List<object>> GatherArgumentValuesWithoutCachingAsync(
         this IResource resource,
         DistributedApplicationExecutionContext executionContext,
         ILogger logger,
@@ -386,7 +384,7 @@ public static async ValueTask ProcessArgumentValuesAsync(
         ILogger logger,
         CancellationToken cancellationToken = default)
     {
-        var args = await GatherArgumentValuesAsync(resource, executionContext, logger, cancellationToken).ConfigureAwait(false);
+        var args = await GatherArgumentValuesWithoutCachingAsync(resource, executionContext, logger, cancellationToken).ConfigureAwait(false);
 
         await ProcessGatheredArgumentValuesAsync(resource, executionContext, args, processValue, logger, cancellationToken).ConfigureAwait(false);
     }
diff --git a/src/Aspire.Hosting/Aspire.Hosting.csproj b/src/Aspire.Hosting/Aspire.Hosting.csproj
index 6f674b02705..29bca26150c 100644
--- a/src/Aspire.Hosting/Aspire.Hosting.csproj
+++ b/src/Aspire.Hosting/Aspire.Hosting.csproj
@@ -140,6 +140,7 @@
     <InternalsVisibleTo Include="Aspire.Hosting.Testing.Tests" />
     <InternalsVisibleTo Include="Aspire.Hosting.Containers.Tests" />
     <InternalsVisibleTo Include="Aspire.Hosting.DotnetTool.Tests" />
+    <InternalsVisibleTo Include="Aspire.Hosting.EntityFrameworkCore" />
     <InternalsVisibleTo Include="Aspire.TestUtilities" />
     <InternalsVisibleTo Include="Aspire.Cli.Tests" />
     <InternalsVisibleTo Include="Aspire.Hosting.Kubernetes" />
diff --git a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
index a70fa69b1d9..2b02caacb3c 100644
--- a/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
+++ b/src/Aspire.Hosting/Dcp/ExecutableCreator.cs
@@ -3,7 +3,6 @@
 
 #pragma warning disable ASPIREEXTENSION001
 #pragma warning disable ASPIRECERTIFICATES001
-#pragma warning disable ASPIREDOTNETTOOL
 
 using System.Diagnostics;
 using System.Globalization;
@@ -420,7 +419,8 @@ private async Task PrepareProjectExecutablesAsync(CancellationToken cancellation
                     // when the active launch configuration or a non-empty launch-tool prefix replaces it.
                     if (executableAnnotation is null &&
                         (projectMetadata.IsFileBasedApp ||
-                         supportsDebuggingAnnotation.LaunchConfigurationType is not KnownLaunchConfigurationTypes.Project))
+                         (supportsDebuggingAnnotation.LaunchConfigurationType is not KnownLaunchConfigurationTypes.Project &&
+                          project.HasLaunchToolArgsOwnedBy(supportsDebuggingAnnotation))))
                     {
                         AddDefaultProjectProcessArgs(projectArgs, projectMetadata);
                     }
@@ -776,7 +776,6 @@ bool showLaunchToolArgsInCommandLine
 
         var launchArgs = new List<LaunchArgument>();
         var nextExecutableArgumentIndex = executableArgumentStartIndex;
-        var firstVisibleAppHostArgumentIndex = 0;
         List<string>? projectLaunchProfileArgs = null;
         var includeProfileArgsInSpec = false;
 
@@ -818,53 +817,6 @@ LaunchArgument CreateLaunchArgument(string value, bool isSensitive, bool executa
                 }
             }
         }
-        else if (er.ModelResource is DotnetToolResource dotnetToolResource)
-        {
-            // AddDotnetTool contributes `tool exec <package> ... --` through the ordinary argument segment because
-            // its separate EF command executor replays those callbacks directly. A resolved launch-tool prefix
-            // replaces that built-in invocation for DCP execution; otherwise keep hiding it from the dashboard.
-            var toolConfiguration = dotnetToolResource.ToolConfiguration;
-            var builtInInvocationStartIndex = -1;
-            if (toolConfiguration is not null)
-            {
-                for (var i = launchToolArgumentCount; i <= appHostArgList.Count - 5; i++)
-                {
-                    if (appHostArgList[i].Value == "tool" &&
-                        appHostArgList[i + 1].Value == "exec" &&
-                        appHostArgList[i + 2].Value == toolConfiguration.PackageId)
-                    {
-                        builtInInvocationStartIndex = i;
-                        break;
-                    }
-                }
-            }
-
-            var builtInInvocationEndIndex = -1;
-            if (builtInInvocationStartIndex >= 0)
-            {
-                for (var i = builtInInvocationStartIndex + 4; i < appHostArgList.Count; i++)
-                {
-                    if (appHostArgList[i].Value == DotnetToolResourceExtensions.ArgumentSeparator &&
-                        appHostArgList[i - 1].Value == "--yes")
-                    {
-                        builtInInvocationEndIndex = i;
-                        break;
-                    }
-                }
-            }
-
-            if (launchToolArgumentCount > 0 && builtInInvocationEndIndex >= 0)
-            {
-                appHostArgList.RemoveRange(
-                    builtInInvocationStartIndex,
-                    builtInInvocationEndIndex - builtInInvocationStartIndex + 1);
-            }
-            else if (builtInInvocationEndIndex >= 0)
-            {
-                firstVisibleAppHostArgumentIndex = builtInInvocationEndIndex + 1;
-            }
-        }
-
         // Project launch-profile arguments are application arguments. When a custom launch-tool declaration replaces
         // the implicit `dotnet run` scaffold, keep its prefix first and insert profile arguments before ordinary
         // app-host arguments. Without such a declaration, preserve the existing profile-before-app-host ordering.
@@ -900,9 +852,7 @@ LaunchArgument CreateLaunchArgument(string value, bool isSensitive, bool executa
                 a.Value,
                 a.IsSensitive,
                 executable: i >= omittedLaunchToolArgumentCount,
-                display: isLaunchToolArg
-                    ? showLaunchToolArgsInCommandLine
-                    : i >= firstVisibleAppHostArgumentIndex));
+                display: showLaunchToolArgsInCommandLine || !isLaunchToolArg));
         }
 
         return launchArgs;
diff --git a/src/Aspire.Hosting/DotnetToolResourceExtensions.cs b/src/Aspire.Hosting/DotnetToolResourceExtensions.cs
index 6aaefdbccd2..ac6b7b12295 100644
--- a/src/Aspire.Hosting/DotnetToolResourceExtensions.cs
+++ b/src/Aspire.Hosting/DotnetToolResourceExtensions.cs
@@ -42,6 +42,7 @@ public static IResourceBuilder<DotnetToolResource> AddDotnetTool(this IDistribut
     public static IResourceBuilder<T> AddDotnetTool<T>(this IDistributedApplicationBuilder builder, T resource)
         where T : DotnetToolResource
     {
+#pragma warning disable ASPIREEXTENSION001 // WithLaunchToolArgs is experimental.
         return builder.AddResource(resource)
             .WithInitialState(new CustomResourceSnapshot
             {
@@ -50,9 +51,10 @@ public static IResourceBuilder<T> AddDotnetTool<T>(this IDistributedApplicationB
             })
             .WithIconName("Toolbox")
             .WithCommand("dotnet")
-            .WithArgs(BuildToolExecArguments)
+            .WithLaunchToolArgs(BuildToolExecArguments, showInCommandLine: false)
             .WithRequiredCommand("dotnet", context => ValidateDotnetSdkVersionAsync(context, resource.WorkingDirectory))
             .OnBeforeResourceStarted(BeforeResourceStarted);
+#pragma warning restore ASPIREEXTENSION001
 
         void BuildToolExecArguments(CommandLineArgsCallbackContext x)
         {
diff --git a/tests/Aspire.Hosting.DotnetTool.Tests/AddDotnetToolTests.cs b/tests/Aspire.Hosting.DotnetTool.Tests/AddDotnetToolTests.cs
index 56bdfc4ffb2..fd093c14b57 100644
--- a/tests/Aspire.Hosting.DotnetTool.Tests/AddDotnetToolTests.cs
+++ b/tests/Aspire.Hosting.DotnetTool.Tests/AddDotnetToolTests.cs
@@ -378,6 +378,45 @@ public async Task AddDotnetToolGeneratesCorrectManifest()
         Assert.Equal(expectedManifest, manifest.ToString());
     }
 
+    [Fact]
+    public async Task CustomLaunchToolArgsReplaceBuiltInInvocationInArgumentsAndManifest()
+    {
+        var builder = DistributedApplication.CreateBuilder();
+#pragma warning disable ASPIREEXTENSION001 // WithLaunchToolArgs is experimental.
+        var tool = builder.AddDotnetTool("ef-tool", "dotnet-ef")
+            .WithArgs("app-arg")
+            .WithLaunchToolArgs(static context =>
+            {
+                context.Args.Add("custom");
+                context.Args.Add("exec");
+                context.Args.Add("--");
+            });
+#pragma warning restore ASPIREEXTENSION001
+
+        using var app = builder.Build();
+
+        var args = await ArgumentEvaluator.GetArgumentListAsync(tool.Resource).DefaultTimeout();
+        Assert.Equal(new[] { "custom", "exec", "--", "app-arg" }, args);
+
+        var manifest = await ManifestUtils.GetManifest(tool.Resource).DefaultTimeout();
+        var expectedManifest =
+        """
+        {
+          "type": "executable.v0",
+          "workingDirectory": ".",
+          "command": "dotnet",
+          "args": [
+            "custom",
+            "exec",
+            "--",
+            "app-arg"
+          ]
+        }
+        """;
+
+        Assert.Equal(expectedManifest, manifest.ToString());
+    }
+
     [Fact]
     public void AddDotnetTool_IncludesRequiredCommandAnnotation()
     {
diff --git a/tests/Aspire.Hosting.EntityFrameworkCore.Tests/EFCoreOperationExecutorTests.cs b/tests/Aspire.Hosting.EntityFrameworkCore.Tests/EFCoreOperationExecutorTests.cs
index 9ec743d3a71..44f9f02b994 100644
--- a/tests/Aspire.Hosting.EntityFrameworkCore.Tests/EFCoreOperationExecutorTests.cs
+++ b/tests/Aspire.Hosting.EntityFrameworkCore.Tests/EFCoreOperationExecutorTests.cs
@@ -178,6 +178,41 @@ public async Task UpdateDatabaseAsync_ReturnsFailureWhenStartCommandIsCanceled()
         Assert.Equal("dotnet-ef command was canceled.", result.ErrorMessage);
     }
 
+    [Fact]
+    public async Task GatherToolArgumentsAsync_ReplaysLaunchAndOrdinaryCallbacksForSequentialCommands()
+    {
+        var builder = DistributedApplication.CreateBuilder();
+        var tool = builder.AddDotnetTool("ef-tool", "dotnet-ef")
+            .WithArgs("persistent");
+        using var app = builder.Build();
+        var executionContext = new DistributedApplicationExecutionContext(DistributedApplicationOperation.Run);
+
+        var firstCommand = new CommandLineArgsCallbackAnnotation(args => args.Add("first"));
+        tool.Resource.Annotations.Add(firstCommand);
+
+        var firstArguments = await EFResourceBuilderExtensions.GatherToolArgumentsAsync(
+            tool.Resource,
+            executionContext,
+            NullLogger.Instance,
+            CancellationToken.None);
+
+        tool.Resource.Annotations.Remove(firstCommand);
+        tool.Resource.Annotations.Add(new CommandLineArgsCallbackAnnotation(args => args.Add("second")));
+
+        var secondArguments = await EFResourceBuilderExtensions.GatherToolArgumentsAsync(
+            tool.Resource,
+            executionContext,
+            NullLogger.Instance,
+            CancellationToken.None);
+
+        Assert.Equal(
+            new[] { "tool", "exec", "dotnet-ef", "--yes", "--", "persistent", "first" },
+            firstArguments.Cast<string>());
+        Assert.Equal(
+            new[] { "tool", "exec", "dotnet-ef", "--yes", "--", "persistent", "second" },
+            secondArguments.Cast<string>());
+    }
+
     private static DotnetToolResource CreateToolResource(Func<ExecuteCommandContext, Task<ExecuteCommandResult>> executeCommand)
     {
         var toolResource = new DotnetToolResource("ef-tool", "dotnet-ef");
diff --git a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
index 0b1aa3c16ec..72648b52c4f 100644
--- a/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
+++ b/tests/Aspire.Hosting.Tests/Dcp/DcpExecutorTests.cs
@@ -3902,6 +3902,49 @@ public async Task ProjectResource_EmptyOwnedLaunchToolArgs_KeepsRunnableProcessF
         Assert.Equal(ExecutionType.Process, Assert.Single(exe.Spec.FallbackExecutionTypes!));
     }
 
+    [Fact]
+    public async Task ProjectResource_CustomLaunchConfigurationWithoutLaunchToolArgs_DoesNotKeepProcessScaffolding()
+    {
+        var builder = DistributedApplication.CreateBuilder();
+        var projectBuilder = builder.AddProject<TestProject>("proj", launchProfileName: null);
+
+        var defaultAnnotation = projectBuilder.Resource.Annotations.OfType<SupportsDebuggingAnnotation>().FirstOrDefault();
+        if (defaultAnnotation is not null)
+        {
+            projectBuilder.Resource.Annotations.Remove(defaultAnnotation);
+        }
+
+        projectBuilder
+            .WithArgs("app-arg")
+            .WithDebugSupport(
+                mode => new ExecutableLaunchConfiguration("azure-functions") { Mode = mode },
+                "azure-functions");
+
+        using var app = builder.Build();
+        var model = app.Services.GetRequiredService<DistributedApplicationModel>();
+
+        var kubernetes = new TestKubernetesService();
+        var configuration = new ConfigurationBuilder()
+            .AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                [DcpExecutor.DebugSessionPortVar] = "12345",
+                [KnownConfigNames.DebugSessionInfo] = JsonSerializer.Serialize(new RunSessionInfo
+                {
+                    ProtocolsSupported = ["coreclr"],
+                    SupportedLaunchConfigurations = ["azure-functions"]
+                })
+            })
+            .Build();
+
+        var executor = CreateAppExecutor(model, configuration: configuration, kubernetesService: kubernetes);
+
+        await executor.RunApplicationAsync();
+
+        var exe = GetCreatedExecutableForResource(kubernetes, "proj");
+        Assert.Equal(ExecutionType.IDE, exe.Spec.ExecutionType);
+        Assert.Equal(["app-arg"], exe.Spec.Args);
+    }
+
     [Fact]
     public async Task ProjectResource_EmptyOwnedLaunchToolArgs_LaunchConfigurationFailureFallsBackToProcess()
     {