@adhdev/daemon-core 1.0.18-rc.2 → 1.0.18-rc.3

package/src/commands/process-lifecycle.ts

@@ -0,0 +1,248 @@
+import { execFileSync, type ExecFileSyncOptions } from 'child_process';
+import * as path from 'path';
+
+export interface ProcessLifecycleOptions {
+    platform?: NodeJS.Platform;
+    execFileSync?: typeof import('child_process').execFileSync;
+}
+
+export interface OwnedProcessInfo {
+    pid: number;
+    commandLine: string | null;
+}
+
+function defaultExecFileSync(): typeof import('child_process').execFileSync {
+    return execFileSync;
+}
+
+function getWindowsProcessCommandLine(
+    pid: number,
+    exec: typeof import('child_process').execFileSync,
+): string | null {
+    const pidFilter = `ProcessId=${pid}`;
+
+    try {
+        const psOut = exec('powershell.exe', [
+            '-NoProfile',
+            '-NonInteractive',
+            '-ExecutionPolicy', 'Bypass',
+            '-Command',
+            `(Get-CimInstance Win32_Process -Filter "${pidFilter}").CommandLine`,
+        ], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+        const text = String(psOut).trim();
+        if (text) return text;
+    } catch {
+        // fall through to wmic fallback
+    }
+
+    try {
+        const wmicOut = exec('wmic', [
+            'process', 'where', pidFilter, 'get', 'CommandLine',
+        ], { encoding: 'utf8', timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+        const text = String(wmicOut).trim();
+        if (text) return text;
+    } catch {
+        // noop
+    }
+
+    return null;
+}
+
+export function getProcessCommandLine(
+    pid: number,
+    options: ProcessLifecycleOptions = {},
+): string | null {
+    if (!Number.isFinite(pid) || pid <= 0) return null;
+    const exec = options.execFileSync ?? defaultExecFileSync();
+    const platform = options.platform ?? process.platform;
+
+    if (platform === 'win32') {
+        return getWindowsProcessCommandLine(pid, exec);
+    }
+
+    try {
+        const text = String(exec('ps', ['-o', 'command=', '-p', String(pid)], {
+            encoding: 'utf8',
+            timeout: 3000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        })).trim();
+        return text || null;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Extract the script argument (the token after the node executable) from a
+ * command line. Handles both quoted and unquoted executables/scripts.
+ */
+export function parseNodeScriptPath(commandLine: string | null): string | null {
+    if (!commandLine) return null;
+    let rest = commandLine.trim();
+
+    // Skip the leading executable token.
+    if (rest.startsWith('"')) {
+        const end = rest.indexOf('"', 1);
+        if (end === -1) return null;
+        rest = rest.slice(end + 1).trim();
+    } else {
+        const idx = rest.search(/\s/);
+        if (idx === -1) return null;
+        rest = rest.slice(idx + 1).trim();
+    }
+    if (!rest) return null;
+
+    if (rest.startsWith('"')) {
+        const end = rest.indexOf('"', 1);
+        return end === -1 ? rest.slice(1) : rest.slice(1, end);
+    }
+    const idx = rest.search(/\s/);
+    return idx === -1 ? rest : rest.slice(0, idx);
+}
+
+function normalizeWindowsPath(value: string): string {
+    return value.toLowerCase().replace(/\//g, '\\').replace(/\\+$/, '');
+}
+
+function isCommandLineUnderPrefix(commandLine: string | null, prefix: string): boolean {
+    if (!commandLine) return false;
+    const needle = normalizeWindowsPath(prefix);
+    // Command-line paths may quote Windows separators as either single or
+    // doubled backslashes; collapse doubles before matching.
+    const haystack = commandLine.split('\\\\').join('\\').toLowerCase();
+    return haystack.includes(needle);
+}
+
+export function killProcess(pid: number, options: ProcessLifecycleOptions = {}): boolean {
+    if (!Number.isFinite(pid) || pid <= 0) return false;
+    const exec = options.execFileSync ?? defaultExecFileSync();
+    const platform = options.platform ?? process.platform;
+
+    try {
+        if (platform === 'win32') {
+            exec('taskkill', ['/PID', String(pid), '/T', '/F'], {
+                stdio: 'ignore',
+                windowsHide: true,
+            });
+        } else {
+            process.kill(pid, 'SIGTERM');
+        }
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+export async function waitForPidExit(pid: number, timeoutMs: number): Promise<boolean> {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            process.kill(pid, 0);
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        } catch {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * List Node processes whose command line places them under any of the supplied
+ * prefixes. Windows-only — the versioned-prefix lifecycle this supports does not
+ * exist on POSIX, so the helper is a no-op there.
+ */
+export function listOwnedNodeProcesses(options: {
+    prefixes: readonly string[];
+    excludePids?: readonly number[];
+    markers?: readonly string[];
+} & ProcessLifecycleOptions): OwnedProcessInfo[] {
+    const platform = options.platform ?? process.platform;
+    if (platform !== 'win32') return [];
+
+    const exec = options.execFileSync ?? defaultExecFileSync();
+    const prefixes = options.prefixes.map((p) => normalizeWindowsPath(p));
+    const exclude = new Set((options.excludePids ?? []).filter((n) => Number.isFinite(n) && n > 0));
+    // Command-line paths use Windows separators; normalize marker separators the
+    // same way so a marker like "dist/cli/index.js" matches "dist\cli\index.js".
+    const markers = (options.markers ?? []).map((m) => m.toLowerCase().replace(/\//g, '\\'));
+
+    let pids: number[] = [];
+    try {
+        const out = String(exec('powershell.exe', [
+            '-NoProfile',
+            '-NonInteractive',
+            '-ExecutionPolicy', 'Bypass',
+            '-Command',
+            'Get-Process node -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id | ConvertTo-Json -Compress',
+        ], { encoding: 'utf8', timeout: 8000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true })).trim();
+        if (out) {
+            const parsed = JSON.parse(out);
+            pids = Array.isArray(parsed) ? parsed : [parsed];
+        }
+    } catch {
+        return [];
+    }
+
+    const results: OwnedProcessInfo[] = [];
+    for (const pid of pids) {
+        if (!Number.isFinite(pid) || pid <= 0 || exclude.has(pid)) continue;
+        const commandLine = getProcessCommandLine(pid, { platform, execFileSync: exec });
+        if (!commandLine) continue;
+        const lower = commandLine.toLowerCase();
+        const underPrefix = prefixes.some((prefix) => lower.includes(prefix));
+        if (!underPrefix) continue;
+        if (markers.length > 0 && !markers.some((marker) => lower.includes(marker))) continue;
+        results.push({ pid, commandLine });
+    }
+    return results;
+}
+
+export async function stopOwnedProcesses(options: {
+    processes: readonly OwnedProcessInfo[];
+    waitMs?: number;
+} & ProcessLifecycleOptions): Promise<{ stopped: number; survivors: OwnedProcessInfo[] }> {
+    const waitMs = options.waitMs ?? 15_000;
+    const killed = new Set<number>();
+
+    for (const p of options.processes) {
+        if (killProcess(p.pid, options)) killed.add(p.pid);
+    }
+
+    const survivors: OwnedProcessInfo[] = [];
+    for (const p of options.processes) {
+        if (!killed.has(p.pid)) {
+            survivors.push(p);
+            continue;
+        }
+        const exited = await waitForPidExit(p.pid, waitMs);
+        if (!exited) survivors.push(p);
+    }
+
+    // A process counts as stopped only when it left the process table; a failed
+    // kill or a post-kill timeout both land it in `survivors`.
+    return { stopped: options.processes.length - survivors.length, survivors };
+}
+
+export async function stopOwnedProcessesForPrefixes(options: {
+    prefixes: readonly string[];
+    excludePids?: readonly number[];
+    markers?: readonly string[];
+    waitMs?: number;
+    log?: (message: string) => void;
+} & ProcessLifecycleOptions): Promise<{ stopped: number; survivors: OwnedProcessInfo[] }> {
+    const processes = listOwnedNodeProcesses(options);
+    if (processes.length === 0) return { stopped: 0, survivors: [] };
+
+    options.log?.(`Stopping ${processes.length} owned process(es) under prefixes: ${options.prefixes.join(', ')}`);
+    const result = await stopOwnedProcesses({
+        processes,
+        waitMs: options.waitMs,
+        platform: options.platform,
+        execFileSync: options.execFileSync,
+    });
+
+    if (result.survivors.length > 0) {
+        options.log?.(`Could not stop ${result.survivors.length} owned process(es): ${result.survivors.map((s) => s.pid).join(', ')}`);
+    }
+    return result;
+}

package/src/commands/upgrade-helper.ts

@@ -4,11 +4,18 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import {
+  ADHDEV_OWNED_MARKERS,
   createDefaultWindowsAtomicHooks,
   findPortableNode22,
   performWindowsAtomicUpgrade,
   resolveWindowsInstallerLayout,
 } from './windows-atomic-upgrade.js';
+import {
+  getProcessCommandLine,
+  killProcess,
+  stopOwnedProcessesForPrefixes,
+  waitForPidExit,
+} from './process-lifecycle.js';
 
 const UPGRADE_HELPER_ENV = 'ADHDEV_DAEMON_UPGRADE_HELPER';
 
@@ -235,77 +242,11 @@ export function execNpmCommandSync(
   );
 }
 
-function killPid(pid: number): boolean {
-  try {
-    if (process.platform === 'win32') {
-      execFileSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
-    } else {
-      process.kill(pid, 'SIGTERM');
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function getWindowsProcessCommandLine(pid: number): string | null {
-  const pidFilter = `ProcessId=${pid}`;
-  try {
-    const psOut = execFileSync('powershell.exe', [
-      '-NoProfile',
-      '-NonInteractive',
-      '-ExecutionPolicy', 'Bypass',
-      '-Command',
-      `(Get-CimInstance Win32_Process -Filter "${pidFilter}").CommandLine`,
-    ], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true }).trim();
-    if (psOut) return psOut;
-  } catch {
-    // fall through to wmic fallback
-  }
-
-  try {
-    const wmicOut = execFileSync('wmic', [
-      'process', 'where', pidFilter, 'get', 'CommandLine',
-    ], { encoding: 'utf8', timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true }).trim();
-    if (wmicOut) return wmicOut;
-  } catch {
-    // noop
-  }
-  return null;
-}
-
-function getProcessCommandLine(pid: number): string | null {
-  if (!Number.isFinite(pid) || pid <= 0) return null;
-  if (process.platform === 'win32') return getWindowsProcessCommandLine(pid);
-  try {
-    const text = execFileSync('ps', ['-o', 'command=', '-p', String(pid)], {
-      encoding: 'utf8',
-      timeout: 3000,
-      stdio: ['ignore', 'pipe', 'ignore'],
-    }).trim();
-    return text || null;
-  } catch {
-    return null;
-  }
-}
-
 function isManagedSessionHostPid(pid: number): boolean {
   const commandLine = getProcessCommandLine(pid);
   return !!commandLine && /session-host-daemon/i.test(commandLine);
 }
 
-async function waitForPidExit(pid: number, timeoutMs: number): Promise<void> {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    try {
-      process.kill(pid, 0);
-      await new Promise((resolve) => setTimeout(resolve, 250));
-    } catch {
-      return;
-    }
-  }
-}
-
 export async function stopSessionHostProcesses(appName: string): Promise<void> {
   const pidFile = path.join(os.homedir(), '.adhdev', `${appName}-session-host.pid`);
   let killedPid: number | null = null;
@@ -313,7 +254,7 @@ export async function stopSessionHostProcesses(appName: string): Promise<void> {
     if (fs.existsSync(pidFile)) {
       const pid = Number.parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
       if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid(pid)) {
-        if (killPid(pid)) killedPid = pid;
+        if (killProcess(pid)) killedPid = pid;
       }
     }
   } catch {
@@ -430,7 +371,7 @@ export async function stopForeignNativeAddonHolders(
     appendUpgradeLog(
       `Foreign native-addon holder found: pid ${holder.pid}${holder.commandLine ? ` — ${holder.commandLine}` : ''}`,
     );
-    const killed = killPid(holder.pid);
+    const killed = killProcess(holder.pid);
     if (killed) {
       await waitForPidExit(holder.pid, 15000);
       appendUpgradeLog(`Terminated foreign native-addon holder pid ${holder.pid}`);
@@ -600,11 +541,31 @@ async function runDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): Prom
       throw new Error(`portable Node.js 22 npm CLI is missing: ${npmCliPath}`);
     }
     appendUpgradeLog(`Installer-managed pointer layout detected; active prefix will remain untouched: ${windowsInstallerLayout.activePrefix}`);
+
+    // Terminate any ADHDev-owned process still executing from the current active
+    // prefix or the legacy stable shim tree before activation. The parent daemon
+    // and this helper itself are excluded: the parent is already exiting, and the
+    // helper must survive to complete the upgrade.
+    const upgradePids = [process.pid, payload.parentPid].filter((n): n is number => Number.isFinite(n) && n > 0);
+    const preStop = await stopOwnedProcessesForPrefixes({
+      prefixes: [windowsInstallerLayout.activePrefix, windowsInstallerLayout.stablePrefix],
+      excludePids: upgradePids,
+      markers: Array.from(ADHDEV_OWNED_MARKERS),
+      waitMs: 15_000,
+      log: appendUpgradeLog,
+    });
+    if (preStop.survivors.length > 0) {
+      throw new Error(
+        `Cannot upgrade: owned processes still running under current prefix: ${preStop.survivors.map((s) => s.pid).join(', ')}`
+      );
+    }
+
     await performWindowsAtomicUpgrade({
       layout: windowsInstallerLayout,
       packageName: payload.packageName,
       targetVersion: payload.targetVersion,
       portableNode,
+      excludePids: upgradePids,
       hooks: createDefaultWindowsAtomicHooks({
         packageName: payload.packageName,
         targetVersion: payload.targetVersion,

package/src/commands/windows-atomic-upgrade.ts

@@ -2,11 +2,21 @@ import { execFileSync, spawn, spawnSync, type ChildProcess } from 'child_process
 import * as fs from 'fs';
 import * as http from 'http';
 import * as path from 'path';
+import { stopOwnedProcessesForPrefixes } from './process-lifecycle.js';
 
 const POINTER_NAME = '.adhdev-current';
 const STABLE_FILES = [POINTER_NAME, 'adhdev.cmd', 'adhdev.ps1', 'adhdev'] as const;
 const DEFAULT_HEALTH_PORT = 19222;
 
+// Markers that identify a Node process as ADHDev-owned when its command line
+// also lives under a versioned install prefix. This deliberately excludes
+// arbitrary user scripts that happen to be located under ~/.adhdev.
+export const ADHDEV_OWNED_MARKERS = [
+    'session-host-daemon',
+    'node_modules/adhdev',
+    'node_modules/@adhdev/daemon-standalone',
+] as const;
+
 export interface WindowsInstallerLayout {
   homeDir: string;
   installRoot: string;
@@ -22,7 +32,7 @@ export interface WindowsAtomicUpgradeHooks {
   restartOld: (portableNode: string) => void;
   waitForHealth: (pid: number, targetVersion: string) => Promise<boolean>;
   stopProcess: (pid: number) => void;
-  cleanup: (layout: WindowsInstallerLayout, activePrefix: string) => void;
+  cleanup: (layout: WindowsInstallerLayout, activePrefix: string) => void | Promise<void>;
   log: (message: string) => void;
 }
 
@@ -32,6 +42,8 @@ export interface WindowsAtomicUpgradeOptions {
   targetVersion: string;
   portableNode: string;
   hooks: WindowsAtomicUpgradeHooks;
+  /** PIDs that must never be terminated during prefix sweeps (helper + parent daemon). */
+  excludePids?: number[];
 }
 
 export interface WindowsAtomicUpgradeResult {
@@ -252,6 +264,25 @@ export async function performWindowsAtomicUpgrade(options: WindowsAtomicUpgradeO
     validateStagedCli(portableNode, stagedCliEntry, targetVersion);
     hooks.log(`Validated staged CLI and portable Node 22 shims in ${stagedPrefix}`);
 
+    // Stop every ADHDev-owned process still executing from the current active
+    // prefix or the legacy stable shim tree before moving the pointer. A stale
+    // session-host left running here keeps node-pty's native addon mapped from
+    // the old tree and resolves lazy requires against a deleted prefix after
+    // activation. Survivors block activation so the pointer is never corrupted.
+    const excludedPids = new Set([process.pid, ...(options.excludePids ?? [])].filter((n) => Number.isFinite(n) && n > 0));
+    const preStop = await stopOwnedProcessesForPrefixes({
+      prefixes: [layout.activePrefix, layout.stablePrefix],
+      excludePids: Array.from(excludedPids),
+      markers: Array.from(ADHDEV_OWNED_MARKERS),
+      waitMs: 15_000,
+      log: hooks.log,
+    });
+    if (preStop.survivors.length > 0) {
+      throw new Error(
+        `Cannot activate ${versionName}: ${preStop.survivors.length} owned process(es) still running under the current prefix`
+      );
+    }
+
     activated = true;
     publishStableShimsAndPointer(layout, versionName);
     hooks.log(`Atomically activated ${versionName}`);
@@ -261,7 +292,7 @@ export async function performWindowsAtomicUpgrade(options: WindowsAtomicUpgradeO
       throw new Error('replacement daemon did not pass the health/version gate');
     }
     hooks.log(`Replacement daemon pid ${daemonPid} passed health for ${targetVersion}`);
-    hooks.cleanup(layout, stagedPrefix);
+    await hooks.cleanup(layout, stagedPrefix);
     return { stagedPrefix, stagedCliEntry, daemonPid };
   } catch (error) {
     if (restarted?.pid) hooks.stopProcess(restarted.pid);
@@ -274,7 +305,7 @@ export async function performWindowsAtomicUpgrade(options: WindowsAtomicUpgradeO
       }
     }
     try { hooks.restartOld(portableNode); } catch { hooks.log('Failed to restart the previous daemon during rollback'); }
-    try { hooks.cleanup(layout, layout.activePrefix); } catch { /* failure path must preserve original error */ }
+    try { await hooks.cleanup(layout, layout.activePrefix); } catch { /* failure path must preserve original error */ }
     throw error;
   }
 }
@@ -353,7 +384,14 @@ export function createDefaultWindowsAtomicHooks(options: {
     stopProcess: (pid) => {
       try { execFileSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true }); } catch { /* noop */ }
     },
-    cleanup: (layout, activePrefix) => boundedCleanupInactivePrefixes(layout, activePrefix, options.log),
+    cleanup: async (layout, activePrefix) => cleanupInactivePrefixesWithGuard({
+      layout,
+      activePrefix,
+      excludePids: [process.pid],
+      markers: Array.from(ADHDEV_OWNED_MARKERS),
+      waitMs: 15_000,
+      log: options.log,
+    }),
     log: options.log,
   };
 }
@@ -383,3 +421,57 @@ export function boundedCleanupInactivePrefixes(
   ], { timeout: 5000, windowsHide: true, stdio: 'ignore' });
   if (result.error || result.status !== 0) log('Bounded inactive-prefix cleanup was incomplete; future updates will retry');
 }
+
+export async function cleanupInactivePrefixesWithGuard(options: {
+  layout: WindowsInstallerLayout;
+  activePrefix: string;
+  excludePids?: number[];
+  markers?: readonly string[];
+  waitMs?: number;
+  log?: (message: string) => void;
+}): Promise<void> {
+  const { layout, activePrefix, log } = options;
+  let candidates: string[] = [];
+  try {
+    candidates = fs.readdirSync(layout.installRoot, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && entry.name.startsWith('version-'))
+      .map((entry) => path.join(layout.installRoot, entry.name))
+      .filter((entry) => normalizeForCompare(entry) !== normalizeForCompare(activePrefix))
+      .sort()
+      .slice(0, 8);
+  } catch {
+    return;
+  }
+  if (candidates.length === 0) return;
+
+  for (const candidate of candidates) {
+    const stopResult = await stopOwnedProcessesForPrefixes({
+      prefixes: [candidate],
+      excludePids: options.excludePids,
+      markers: options.markers,
+      waitMs: options.waitMs ?? 15_000,
+      log,
+    });
+    if (stopResult.survivors.length > 0) {
+      log?.(`Skipping cleanup of ${candidate}: ${stopResult.survivors.length} owned process(es) could not be stopped`);
+      continue;
+    }
+    removeInactivePrefix(candidate, log);
+  }
+}
+
+function removeInactivePrefix(target: string, log?: (message: string) => void): void {
+  try {
+    const escaped = quotePowerShellLiteral(target);
+    const script = `if (Test-Path -LiteralPath ${escaped}) { Remove-Item -LiteralPath ${escaped} -Recurse -Force }`;
+    const encoded = Buffer.from(script, 'utf16le').toString('base64');
+    const result = spawnSync('powershell.exe', [
+      '-NoLogo', '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', encoded,
+    ], { timeout: 5000, windowsHide: true, stdio: 'ignore' });
+    if (result.error || result.status !== 0) {
+      log?.(`Failed to remove inactive prefix ${target}: ${result.error?.message || `exit ${result.status}`}`);
+    }
+  } catch (error: any) {
+    log?.(`Failed to remove inactive prefix ${target}: ${error?.message || String(error)}`);
+  }
+}

package/src/session-host/managed-host.ts

@@ -8,6 +8,8 @@ import {
     type SessionHostEndpoint,
     type SessionHostRequestType,
 } from '@adhdev/session-host-core';
+import { getProcessCommandLine, parseNodeScriptPath } from '../commands/process-lifecycle.js';
+import { LOG } from '../logging/logger.js';
 import { ensureSessionHostReady as ensureSharedSessionHostReady } from './runtime-support.js';
 import { DEFAULT_SESSION_HOST_READY_TIMEOUT_MS } from '../runtime-defaults.js';
 
@@ -97,6 +99,16 @@ export function createManagedSessionHost(options: ManagedSessionHostOptions): Ma
         return require.resolve('@adhdev/session-host-daemon');
     }
 
+    function pathsEquivalent(left: string, right: string): boolean {
+        return path.resolve(left).toLowerCase() === path.resolve(right).toLowerCase();
+    }
+
+    function getRunningSessionHostScriptPath(pid: number): string | null {
+        const commandLine = getProcessCommandLine(pid);
+        if (!commandLine || !/session-host-daemon/i.test(commandLine)) return null;
+        return parseNodeScriptPath(commandLine);
+    }
+
     function getPidFile(): string {
         return path.join(os.homedir(), '.adhdev', `${appName}-session-host.pid`);
     }
@@ -178,6 +190,28 @@ export function createManagedSessionHost(options: ManagedSessionHostOptions): Ma
 
     async function ensureReady(): Promise<SessionHostEndpoint> {
         options.beforeEnsureReady?.();
+
+        // Defensive guard: on Windows the daemon may have been restarted from a
+        // new versioned prefix while a session-host from the old prefix is still
+        // running. Because the old host is reachable on the same socket endpoint,
+        // `ensureSharedSessionHostReady` would reuse it and lazy requires would
+        // resolve against the deleted tree. Detect the mismatch and stop the stale
+        // host before it can be reused; a matching or unreadable host is left alone.
+        if (process.platform === 'win32') {
+            const existingPid = getPid();
+            if (existingPid !== null) {
+                const runningPath = getRunningSessionHostScriptPath(existingPid);
+                const currentEntry = resolveEntry();
+                if (runningPath && !pathsEquivalent(runningPath, currentEntry)) {
+                    LOG.warn(
+                        'SessionHost',
+                        `Detected stale host pid ${existingPid} running from ${runningPath}; restarting from ${currentEntry}`,
+                    );
+                    stopManagedSessionHostProcess();
+                }
+            }
+        }
+
         try {
             return await ensureSharedSessionHostReady({
                 appName,