@@ -43,7 +43,7 @@ They are listed cheapest first, and that ordering is the rule: **write a test at
 
 **1. Unit** — `tests/unit/`. Starts nothing; calls plain functions. Pure logic: parsing a ticket reference, deriving a status, building a command line. Blind to anything touching disk, a process or a window.
 
-**2. Integration** — the files named `*.integration.test.cjs`. Runs the real modules against real Git repositories in a temporary directory. Proves Git does what the code assumes when it switches a branch, applies a patch or updates trunk. Blind to everything above the module boundary.
+**2. Integration** — the files named `*.integration.test.cjs`. Runs the real modules against real Git repositories, or real processes, in a temporary directory. Proves Git does what the code assumes when it switches a branch, applies a patch or updates trunk, and that a process tree behaves the way the kill and let-go paths assume (`kill-tree`, `orphan-pipe`). Blind to everything above the module boundary.
 
 **3. IPC wiring** — one file, `tests/unit/ipc-wiring.test.cjs`. Loads the real `src/main.js` with `electron` replaced by a double, and exercises every handler: what each returns, what it rejects, what error it gives. Blind to the window, and its store is a stand-in rather than the real one.
 
 
@@ -3433,19 +3433,24 @@ function runNpmWithEngineRetry({ runnerPath, args, cwd, onLog, onDone, register,
 		// its cmd.exe was closed by hand (#497) — so npm has exited, the step is
 		// still IN PROGRESS, and the terminal keeps receiving the orphan's output
 		// (#498). Mirror of the Stop escalation (#479) on the natural-exit path:
-		// three seconds after `exit` with no `close`, force the group by pid
-		// (on POSIX the detached group outlives its leader, so the orphan goes;
-		// on Windows `taskkill /T` from a pid that is gone reaches nothing, and
-		// the orphan runs on until it finishes) and destroy the pipes, which is
-		// what makes Node emit `close` with the exit code npm gave. The close
-		// handler then settles as usual, so the engines-retry decision stays in
-		// one place; whatever the orphan writes afterwards goes with the stream.
+		// three seconds after `exit` with no `close`, force the group by pid on
+		// POSIX, where the detached group outlives its leader and the orphan
+		// goes with it, and destroy the pipes, which is what makes Node emit
+		// `close` with the exit code npm gave. The close handler then settles as
+		// usual, so the engines-retry decision stays in one place; whatever the
+		// orphan writes afterwards goes with the stream. Not forced on Windows,
+		// for the reason npm:kill gives: the pid is certainly dead by now, a
+		// `taskkill /T` on it reaches nothing of the orphan (its parent chain
+		// is gone) and could land on a reissued pid; there the orphan runs on
+		// until it finishes, and the terminal line says so.
 		let letGo = null;
 		child.once('exit', (code, signal) => {
 			letGo = setTimeout(() => {
 				if (settled) return;
-				logEvent(logScope, `exited with code ${code}${signal ? ` (signal ${signal})` : ''} but a descendant still holds its output; forcing the tree and letting go`);
-				killTreeByPid(child.pid, 'SIGKILL');
+				const exit = `code ${code}${signal ? ` (signal ${signal})` : ''}`;
+				logEvent(logScope, `exited with ${exit} but a descendant still holds its output; letting go`);
+				onLog('stderr', `\nnpm exited with ${exit}, but something it started is still running and holding its output. Letting go${process.platform === 'win32' ? '; that process runs on until it finishes on its own' : ' and ending it'}.\n`);
+				if (process.platform !== 'win32') killTreeByPid(child.pid, 'SIGKILL');
 				for (const stream of [child.stdout, child.stderr, child.stdin]) {
 					if (stream && typeof stream.destroy === 'function') stream.destroy();
 				}
 
@@ -2157,10 +2157,21 @@ test('a runner that exited but never closed is let go after a grace, with npm\'s
 	assert.deepEqual(child.stdout.destroy.calls, []);
 	t.mock.timers.tick(1);
 
-	assert.deepEqual(killTreeByPid.calls, [[child.pid, 'SIGKILL']], 'the group the runner led is forced by pid');
+	// The forced group signal is POSIX; on Windows the pid is dead and a
+	// taskkill on it could land on a reissued one (the npm:kill rule).
+	assert.deepEqual(
+		killTreeByPid.calls,
+		process.platform === 'win32' ? [] : [[child.pid, 'SIGKILL']],
+		'POSIX forces the group the runner led by pid; Windows must not'
+	);
 	for (const stream of [child.stdout, child.stderr, child.stdin]) {
 		assert.equal(stream.destroy.calls.length, 1, 'the pipe the orphan holds has to be destroyed, or close never comes');
 	}
+	// The contributor is told in the terminal, not only in the log file.
+	assert.ok(
+		event.sent.some((m) => m.channel === 'npm:run-script:log' && m.payload.type === 'stderr' && /still running and holding its output/.test(m.payload.data)),
+		'the let-go said nothing in the terminal'
+	);
 	assert.ok(!event.sent.some((m) => m.channel === 'npm:run-script:done'), 'done is the close handler\'s to send');
 	// Node emits close with the stored exit code once the destroyed pipes shut.
 	child.emit('close', 1, null);
@@ -2210,7 +2221,7 @@ test('an install that exited but never closed is let go the same way', async (t)
 
 	child.emit('exit', 1, null);
 	t.mock.timers.tick(3000);
-	assert.deepEqual(killTreeByPid.calls, [[child.pid, 'SIGKILL']]);
+	assert.deepEqual(killTreeByPid.calls, process.platform === 'win32' ? [] : [[child.pid, 'SIGKILL']]);
 	assert.equal(child.stderr.destroy.calls.length, 1);
 	child.emit('close', 1, null);
 	// The install's done follows a store write.
 
@@ -41,9 +41,14 @@ test('a runner whose orphan holds the pipes exits without closing, and closes on
 		detached: true,
 		stdio: ['pipe', 'pipe', 'pipe']
 	});
-	t.after(() => { try { killTreeByPid(runner.pid, 'SIGKILL'); } catch {} });
-
+	// Straight to the group, never the bare pid: once the body has reaped the
+	// group, the runner's pid may be someone else's.
 	let orphanPid = null;
+	t.after(() => {
+		try { process.kill(-runner.pid, 'SIGKILL'); } catch {}
+		if (orphanPid !== null) { try { process.kill(orphanPid, 'SIGKILL'); } catch {} }
+	});
+
 	runner.stdout.on('data', (data) => { if (orphanPid === null) orphanPid = Number(String(data).trim()); });
 	const exited = new Promise((resolve) => runner.once('exit', resolve));
 	let closed = null;