Thanks all.
Let me fill in more detail.
I have a Cube IDE project which comprises of
- some ex Cube MX (the STM "code generator") code, largely modded to remove bloat; the project was started years ago with this bit
- ST port of FreeRTOS (very few mods were needed)
- ST port of LWIP (lots of mods were needed)
- ST port of MbedTLS (lots of mods were needed)
- ST ETH code (loads of mods again)
- ST USB code (client only - CDC & MSC) (load of mods needed)
- ST port of FatFS (very few mods)
- interface code for SPI serial FLASH
- interface code for a number of serial ports
- a couple of LWIP-interfaced modules written by outside people (no doubt they will recognise this

)
- a ton of code I wrote over the past 2 years of my life; stuff which defines what the product actually is, an API for a ton of stuff, and countless bug fixes to stuff above, revealed in extensive 24/7 testing
The project is in a directory tree:

and since I didn't set up the ST port stuff, I don't know where and how these directories are set up, but I don't need to know. I know how the stuff I've been writing last 2 years works

I am not posting what this thing does

but I can say that in some application contexts there will be outsiders (with C expertise) writing their own modules. They will be given the whole Cube project, with an example file like hello.c. I will absolutely not be supporting ST Cube and creating a project from scratch; that is way beyond the call of duty.
And the idea is that their life will be far easier than if they were coding for some development board (these normally come with example code but usually it is crap for anything beyond trivia) or for some "hobby board" (which tend to be mechanically unsuitable for serious industrial use, as well as production-problematic long-term). For example LWIP and proper code examples will make the development of internet applications a lot easier.
And I don't want to give them all the source code. They can have the ex-ST code (even though the fixes to make it work probably amount to a man-year) because it is basically public-domain, but I don't want to give out the whole lot, especially most of the stuff which I wrote.
These other coders will write applications which run at base+32k (0x00008000) because the bottom 32k is a boot block which has various recovery features, etc. Obviously I won't publish the boot block code, too.
So I am looking for the simplest path to generate this "0x00008000" development kit.
The main difference will be the linker script, obviously. That's easy. No boot block section, start collecting TEXT sections at 0x00008000, etc.
Then I need to delete the .c files for all the stuff I don't want to hand out. But I need to provide the .o files. I also need to provide all the .h files for the entire project and I am hoping that I can use all the existing ones as-is.
So I need to copy the .o files to another directory e.g.
<projectdir>/O_FILES
and add a linker command line option to look in there.
The stuff should be a standalone batch file. Something obvious and self documenting so in 10 years' time it will be obvious what it does.
The batch file can be run as a post build step, so the above .o files are always current.
Out of maybe 1000 .c files there would be only about 30 that would be stripped out.
I am not worried about function names being visible. I just don't want to hand out nicely commented and valuable C source in some cases

Have I overlooked anything?
The "neat" way would be to produce one huge .a library file, but that is just "neat" and achieves nothing, given that Cube itself is about 4000 files! And I would have to do what I think would be a vast amount of work on the .h files. Also I have no idea how one would condense all that code in that directory tree into one library, and keep the .h files right. There are multiple pairs of src and inc directories so e.g. LWIP has one pair, FatFS has another pair, and so on.
So I am looking for the simplest way to be able to remove some .c files and supply just the .o files, and this needs to survive the rm *.* cleanup command which Cube does on the Debug directory at the start of each build of a project which has been cleaned-up.