@@ -148,6 +148,7 @@ macOS and Windows are the primary targets; Linux artifacts are published too. CI
 - Mocking the very thing the test claims to verify.
 - Asserting implementation details — exact log strings, call order of internals — instead of observable behaviour. These break on harmless refactors and survive real bugs.
 - Cleanup that is green while doing nothing. `t.after` hooks run in the order they were registered, so a fixture that reaches outside its own temporary directory (a worktree beside it, a patch file next to it) cannot clean up through a repository an earlier hook already removed; remove it as a directory with `removeRepo`, and use the throwing helper (`gitOk`) for any cleanup that goes through Git, or the only symptom is disk filling up.
+- A stub-map test that an absolute-path `require` walks around. The `ipc-wiring` loader stubs modules by their relative request (`'./hide-child-windows'`); a module reached by `require(path.join(__dirname, …))`, or by a file that main.js copies rather than requires, never hits the map, so a test asserting "this stub was not called" stays green while the real module runs. Assert on `require.cache` as well when the rule is "never loaded", not "never called".
 - A journey locator that changed meaning. `tests/e2e/journeys/*.spec.js` pin user-facing strings with `getByText(…, { exact: true })`; when a PR turns a fixed string into a conditional one (a headline that follows a state), grep the journeys for the old string and check that each assertion still asserts what it meant, rather than passing only because the fixture never reaches the new branch.
 - Passing on only one of the two Node runtimes. CI runs the suite on `.nvmrc`'s Node *and* on Electron's bundled Node because the two are set independently and have drifted; a test (or the code under it) that assumes the newer of the two is broken on the other.
 
 
@@ -22,9 +22,17 @@
 // the patch ran, which is exactly the kind of thing nobody should have to
 // reason about. "Hide the console flashes everywhere, once at startup" is the
 // plausible-looking change that reinstates that bug; the ipc-wiring suite
-// asserts main.js does not make it. Only the four runners — install, script,
-// server, playground-web — take this patch, and only because they load npm's or
-// Playground's CLI in-process.
+// asserts main.js does not make it. The four runners — install, script,
+// server, playground-web — take this patch because they load npm's or
+// Playground's CLI in-process; and since #497 so does every Node process below
+// them, through the win-spawn-patch.js preload, which requires the copy of this
+// file that ensureNodeShimDir() puts beside it. Those descendants are Electron
+// running as Node, consoleless like the runners, and Gutenberg's build scripts
+// spawn cmd.exe from one of them (cross-spawn around the tsc and wp-build .cmd
+// stubs) — without this, each of those was a visible black window.
+//
+// Self-contained (child_process only): the copy in the shim dir has no
+// neighbours from src/ but the patch itself.
 
 const PATCHED = Symbol.for('wp-dev-env.windowsHidePatched');
 
 
@@ -238,6 +238,16 @@ function ensureNodeShimDir() {
                 fs.copyFileSync(path.join(__dirname, 'win-spawn-patch.js'), dest);
                 spawnPatchPath = dest;
             } catch {}
+            // The patch also hides console windows in every descendant Node
+            // (#497), through hide-child-windows.js required from beside it.
+            // Separate try: a missing copy costs the hiding, not the patch.
+            try {
+                fs.copyFileSync(path.join(__dirname, 'hide-child-windows.js'), path.join(nodeShimDir, 'hide-child-windows.js'));
+            } catch (e) {
+                // The preload cannot say so itself (its stdout is the build's), so
+                // this is the one line that explains black windows coming back.
+                logError('shims', `could not copy hide-child-windows.js next to the shims; console windows will show below the runners: ${String(e && e.message ? e.message : e)}`);
+            }
             // Intentionally do NOT create node.exe here, as Electron's exe depends on adjacent DLLs.
             // Using node.exe from a temp dir causes STATUS_DLL_NOT_FOUND (0xC0000135) when spawned by npm.
         } else {
 
@@ -19,9 +19,11 @@
 // It is the one tool the build spawns bare that a host install shadows with an
 // incompatible one.
 //
-// Deliberately self-contained (Node built-ins only): this file is copied into the
-// temp shim dir and required from there, because --require into a path inside
-// app.asar is not reliable under ELECTRON_RUN_AS_NODE.
+// Deliberately self-contained: Node built-ins, plus the one sibling
+// ensureNodeShimDir() copies beside it (hide-child-windows.js, #497) and
+// nothing else. This file is copied into the temp shim dir and required from
+// there, because --require into a path inside app.asar is not reliable under
+// ELECTRON_RUN_AS_NODE, and the shim dir has no other neighbour from src/.
 
 const path = require('path');
 const fs = require('fs');
@@ -192,14 +194,35 @@ function applyPatch(childProcess = require('child_process'), config = {}) {
 	return childProcess;
 }
 
-// Only self-applies when the app explicitly asked for it, so requiring this
-// module from a test never mutates the test process.
-if (process.env.WPTK_SPAWN_PATCH === '1') {
-	applyPatch(require('child_process'), {
-		npmCliPath: process.env.WPTK_NPM_CLI || null,
-		npxCliPath: process.env.WPTK_NPX_CLI || null,
-		nodeCompatPath: process.env.WPTK_NODE_COMPAT_PATH || null
+// What the preload does to the process it was loaded into. Only when the app
+// explicitly asked for it, so requiring this module from a test never mutates
+// the test process, and only on Windows, where both problems live.
+//
+// The second half is #497. Every descendant Node here is Electron running as
+// Node, a GUI-subsystem binary with no console of its own. When one of them
+// spawns cmd.exe without `windowsHide` — cross-spawn wrapping a .cmd stub, as
+// Gutenberg's tools/build-scripts do for `tsc` and `wp-build` — Windows finds
+// no console to inherit and allocates a brand-new visible one: the black
+// windows of #497, and closing one breaks the build. patchChildProcess() from
+// hide-child-windows.js (the copy ensureNodeShimDir() puts beside this file)
+// forces the flag on every child_process entry point of the process, the way
+// the four runners already do for themselves. The runners then get it twice,
+// which the patch's own marker makes a no-op. A missing copy costs the hiding,
+// never the spawn patch, and says nothing: this process's stdout and stderr
+// are the build's output, so a warning here would land in the middle of npm's
+// lines; main.js logs the copy failure where the log is.
+function selfApply({ env = process.env, platform = process.platform, childProcess = require('child_process'), requireHide = () => require(path.join(__dirname, 'hide-child-windows.js')) } = {}) {
+	if (platform !== 'win32' || env.WPTK_SPAWN_PATCH !== '1') return;
+	applyPatch(childProcess, {
+		npmCliPath: env.WPTK_NPM_CLI || null,
+		npxCliPath: env.WPTK_NPX_CLI || null,
+		nodeCompatPath: env.WPTK_NODE_COMPAT_PATH || null
 	});
+	try {
+		requireHide().patchChildProcess(childProcess, platform);
+	} catch {}
 }
 
-module.exports = { resolveSpawnTarget, applyPatch, defaultLookup, PATCH_MARKER };
+selfApply();
+
+module.exports = { resolveSpawnTarget, applyPatch, selfApply, defaultLookup, PATCH_MARKER };
@@ -1835,6 +1835,11 @@ test('main.js does not apply the windowsHide patch when it loads', () => {
 		[],
 		'main.js patched its own child_process with windowsHide — every spawn in the process now carries the flag, including the editor launch (#181)'
 	);
+	// Since #497 the win-spawn-patch preload reaches hideChildWindows on its
+	// own, by absolute path, which the stub map above cannot see. main.js only
+	// copies that file; requiring it would be the second way in.
+	const preloadRequired = Object.keys(require.cache).filter((file) => file.endsWith(`${path.sep}win-spawn-patch.js`));
+	assert.deepEqual(preloadRequired, [], 'main.js required the spawn-patch preload, which applies windowsHide by itself on Windows');
 });
 
 // --- npm:* -> src/npm-runner.js + src/kill-tree.js -----------------------
@@ -1908,6 +1913,15 @@ function assertShimsPreloadCompat(label) {
 		shim.includes(`--require "${compat}"`),
 		`${label}: the node shim starts a child without the preload, so any yargs-based tool it runs misreads its arguments`
 	);
+	// On Windows the spawn patch is preloaded into every descendant Node and
+	// requires the hide-child-windows copy beside it (#497); both have to be
+	// there, since a path inside app.asar is not reliable under
+	// ELECTRON_RUN_AS_NODE.
+	if (process.platform === 'win32') {
+		for (const name of ['win-spawn-patch.js', 'hide-child-windows.js']) {
+			assert.ok(fs.existsSync(path.join(shimDir, name)), `${label}: ${name} was not copied next to the shims`);
+		}
+	}
 }
 
 // The three cross-platform decisions every spawn in main.js makes. No module
 
@@ -4,7 +4,7 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 
-const { resolveSpawnTarget, applyPatch, defaultLookup, PATCH_MARKER } = require('../../src/win-spawn-patch.js');
+const { resolveSpawnTarget, applyPatch, selfApply, defaultLookup, PATCH_MARKER } = require('../../src/win-spawn-patch.js');
 
 // The Windows shim layout ensureNodeShimDir() writes, as the patch sees it.
 const WIN = {
@@ -242,3 +242,65 @@ test('applyPatch is idempotent so a duplicated --require cannot double-wrap', ()
 	fake.spawn('node');
 	assert.equal(depth, 1);
 });
+
+// #497: the preload reaches every descendant Node on Windows, and each of those
+// is Electron running as Node, a GUI-subsystem binary with no console. A
+// cmd.exe it spawns without windowsHide (cross-spawn wrapping a .cmd stub, as
+// Gutenberg's build scripts do for tsc and wp-build) gets a brand-new visible
+// console. So the same preload that fixes `spawn('node')` also hides consoles,
+// through the hide-child-windows copy beside it.
+function fakeChildProcess() {
+	return { spawn: () => 'spawned', spawnSync: () => {}, execFile: () => {}, execFileSync: () => {} };
+}
+
+test('selfApply applies the spawn patch and hides consoles on Windows when the app asked for it', () => {
+	const cp = fakeChildProcess();
+	const hidden = [];
+	selfApply({ env: { WPTK_SPAWN_PATCH: '1' }, platform: 'win32', childProcess: cp, requireHide: () => ({ patchChildProcess: (target, platform) => { hidden.push([target, platform]); return target; } }) });
+
+	assert.equal(cp[PATCH_MARKER], true, 'the spawn patch was not applied');
+	assert.deepEqual(hidden, [[cp, 'win32']], 'patchChildProcess was not applied to the same child_process');
+});
+
+// The default requireHide is the one production runs: the copy in the shim dir
+// resolving its sibling by name. Reproduced with the two files copied into a
+// temp dir, the way ensureNodeShimDir() lays them out, and the real
+// hide-child-windows applied to a fake child_process so the test process is
+// never touched.
+test('selfApply from a shim-dir copy finds hide-child-windows.js beside it', () => {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'wptk-shims-'));
+	try {
+		for (const name of ['win-spawn-patch.js', 'hide-child-windows.js']) {
+			fs.copyFileSync(path.join(__dirname, '../../src', name), path.join(dir, name));
+		}
+		const copy = require(path.join(dir, 'win-spawn-patch.js'));
+		const cp = fakeChildProcess();
+		copy.selfApply({ env: { WPTK_SPAWN_PATCH: '1' }, platform: 'win32', childProcess: cp });
+
+		assert.equal(cp[PATCH_MARKER], true);
+		assert.equal(cp[Symbol.for('wp-dev-env.windowsHidePatched')], true, 'the sibling copy was not found, so consoles would show (#497)');
+	} finally {
+		fs.rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+test('selfApply does nothing without the flag, and nothing off Windows', () => {
+	for (const input of [
+		{ env: {}, platform: 'win32' },
+		{ env: { WPTK_SPAWN_PATCH: '0' }, platform: 'win32' },
+		{ env: { WPTK_SPAWN_PATCH: '1' }, platform: 'darwin' }
+	]) {
+		const cp = fakeChildProcess();
+		let hideAsked = false;
+		selfApply({ ...input, childProcess: cp, requireHide: () => { hideAsked = true; return { patchChildProcess: (target) => target }; } });
+		assert.equal(cp[PATCH_MARKER], undefined, JSON.stringify(input));
+		assert.equal(hideAsked, false, JSON.stringify(input));
+	}
+});
+
+test('selfApply keeps the spawn patch when the hide copy is missing beside it', () => {
+	const cp = fakeChildProcess();
+	selfApply({ env: { WPTK_SPAWN_PATCH: '1' }, platform: 'win32', childProcess: cp, requireHide: () => { throw new Error("Cannot find module './hide-child-windows.js'"); } });
+
+	assert.equal(cp[PATCH_MARKER], true, 'a missing hide copy must not cost the spawn patch');
+});