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

package/dist/index.mjs

@@ -437,10 +437,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "dcf5798b77def59c325d533c744c7d57b4fc8eac" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "dcf5798b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "1.0.18-rc.2" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-21T07:45:31.375Z" : void 0);
+  const commit = readInjected(true ? "96f3f1365be0d875f5089fc7ce7e4e254ca8e08d" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "96f3f136" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "1.0.18-rc.3" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-21T13:00:17.395Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -25780,6 +25780,22 @@ var init_cli_state_engine = __esm({
       // ── Approval ─────────────────────────────────────
       lastApprovalResolvedAt = 0;
       lastResolvedModalMessage = "";
+      /**
+       * Normalized approval-context signature captured at resolve time (see
+       * `computeApprovalContentSignature`) — the screen text with blank-line
+       * padding and any manifest-declared chrome (transcriptPty.chromePatterns,
+       * spinner.patterns) stripped out. Used by applyWaitingApproval's
+       * isStaleResolvedRepaint check to tell "the same already-answered modal,
+       * re-parsed from a screen that has not meaningfully changed" apart from
+       * "a genuinely new approval" — content-based, not time-based, because
+       * ordinary TUI chrome (status bar, context meter, blank-line repaint)
+       * keeps producing fresh PTY bytes on an otherwise-unchanged screen and
+       * defeats any output-timestamp discriminator within a few hundred ms.
+       * Cleared whenever a turn starts or the session tears down (see
+       * onTurnStarted / resetActiveTurnState / onPtyExit) so a next-turn
+       * approval is never compared against stale prior-turn state.
+       */
+      lastApprovalResolvedContentSignature = "";
       /**
        * Monotonic counter bumped every time the FSM *enters* waiting_approval
        * with a freshly captured modal (see `applyWaitingApproval`). It is the
@@ -25899,11 +25915,17 @@ var init_cli_state_engine = __esm({
         this.currentTurnTaskId = typeof turnScope.taskId === "string" && turnScope.taskId.trim() ? turnScope.taskId : null;
         this.currentTurnStartedAt = Date.now();
         this.responseEpoch += 1;
+        this.clearApprovalResolutionMemory();
+        if (this.provider.transcriptAuthority === "provider" && this.currentStatus !== "waiting_approval") {
+          this.setStatus("generating", "turn_started");
+          this.callbacks.onStatusChange();
+        }
       }
       /** Called when PTY exits */
       onPtyExit() {
         this.clearAllTimers();
         this.setStatus("stopped", "pty_exit");
+        this.clearApprovalResolutionMemory();
       }
       /** Called when adapter starts up successfully */
       onSpawnReady() {
@@ -25945,6 +25967,7 @@ var init_cli_state_engine = __esm({
         this.activeModal = null;
         this.lastApprovalResolvedAt = Date.now();
         this.lastResolvedModalMessage = currentModalMessage;
+        this.lastApprovalResolvedContentSignature = this.computeApprovalContentSignature(snap);
         this.lastResolvedEntrySeq = this.approvalEntrySeq;
         this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
         if (this.approvalExitTimeout) {
@@ -26067,6 +26090,7 @@ var init_cli_state_engine = __esm({
         this.pendingScriptStatusSince = 0;
         this.approvalResumeDeferSince = 0;
         this.approvalResumeDeferEpoch = -1;
+        this.clearApprovalResolutionMemory();
       }
       clearIdleFinishCandidate(reason) {
         if (!this.idleFinishCandidate) return;
@@ -26225,7 +26249,15 @@ var init_cli_state_engine = __esm({
         }
         if (!status) return;
         const prevStatus = this.currentStatus;
-        const ctx = { now, modal, status, parsedMessages, lastParsedAssistant, parsedStatus: parsedStatus || null, prevStatus };
+        const ctx = {
+          now,
+          modal,
+          status,
+          parsedMessages,
+          lastParsedAssistant,
+          parsedStatus: parsedStatus || null,
+          prevStatus
+        };
         if (!this.applyPendingScriptStatusDebounce(ctx)) return;
         const recentInteractiveActivity = this.hasRecentInteractiveActivity(snap, now);
         LOG.debug(
@@ -26261,7 +26293,7 @@ var init_cli_state_engine = __esm({
           return;
         }
         if (status === "waiting_approval") {
-          this.applyWaitingApproval(ctx);
+          this.applyWaitingApproval(ctx, snap);
           return;
         }
         if (status === "generating") {
@@ -26321,7 +26353,7 @@ var init_cli_state_engine = __esm({
         }, this.timeouts.generatingIdle);
         this.callbacks.onStatusChange();
       }
-      applyWaitingApproval(ctx) {
+      applyWaitingApproval(ctx, snap) {
         const { modal } = ctx;
         this.clearIdleFinishCandidate("waiting_approval");
         const inCooldown = this.lastApprovalResolvedAt && Date.now() - this.lastApprovalResolvedAt < this.timeouts.approvalCooldown;
@@ -26368,6 +26400,11 @@ var init_cli_state_engine = __esm({
             }
             return;
           }
+          const isStaleResolvedRepaint = !this.activeModal && this.isStaleResolvedApproval(modal, snap);
+          if (isStaleResolvedRepaint) {
+            LOG.debug("CLI", `[${this.provider.type}] ignoring stale re-parsed approval matching the just-resolved modal (approval-context signature unchanged)`);
+            return;
+          }
           this.modalLostAt = 0;
           this.isWaitingForResponse = true;
           this.setStatus("waiting_approval", "script_detect");
@@ -26653,6 +26690,86 @@ var init_cli_state_engine = __esm({
         this.recordTrace("idle_finish_cancelled", { trigger: reason });
       }
       // ─── Helpers ────────────────────────────────────────────────────────────
+      /**
+       * Derive a stable approval-context signature from the current screen,
+       * with blank-line padding and any manifest-declared chrome stripped out.
+       *
+       * Generic by design — no kimi- or provider-specific hardcoding: it reads
+       * whatever `tui.transcriptPty.chromePatterns` and `tui.spinner.patterns`
+       * the ACTIVE provider's own manifest already declares (present on any
+       * declarative-TUI provider; simply absent/empty for scripted providers,
+       * in which case this degrades to blank-line stripping only — never worse
+       * than comparing the raw screen). Those pattern lists exist precisely to
+       * name "known volatile repaint noise" (status bar, context meter, spinner
+       * ticks, banners) — reusing them here means the SAME declared knowledge
+       * that governs transcript-chrome stripping also governs staleness
+       * detection, instead of re-encoding provider knowledge into daemon-core.
+       *
+       * Deliberately NOT a hash of the whole screen/buffer: an ordinary TUI
+       * repaints its footer/status/context-meter chrome continuously even while
+       * genuinely idle, so a raw whole-screen or whole-buffer fingerprint (or a
+       * mere "did any bytes arrive" timestamp) changes on every repaint tick
+       * regardless of whether anything approval-relevant actually happened.
+       * Stripping the declared chrome first yields a signature that only
+       * changes when the surrounding conversation/tool-output content itself
+       * changes — exactly the discriminator applyWaitingApproval's
+       * isStaleResolvedRepaint check needs.
+       */
+      computeApprovalContentSignature(snap) {
+        const screenText = snap.screenText || snap.accumulatedBuffer || "";
+        if (!screenText) return "";
+        const tui = this.provider.tui;
+        const patternSpecs = [
+          ...Array.isArray(tui?.transcriptPty?.chromePatterns) ? tui.transcriptPty.chromePatterns : [],
+          ...Array.isArray(tui?.spinner?.patterns) ? tui.spinner.patterns : []
+        ];
+        const chromeRegexes = [];
+        for (const spec of patternSpecs) {
+          if (spec && typeof spec.regex === "string") {
+            try {
+              chromeRegexes.push(new RegExp(spec.regex, typeof spec.flags === "string" ? spec.flags : ""));
+            } catch {
+            }
+          }
+        }
+        const kept = [];
+        for (const rawLine of screenText.split("\n")) {
+          const line = rawLine.trim();
+          if (!line) continue;
+          if (chromeRegexes.some((re) => re.test(line))) continue;
+          kept.push(line);
+        }
+        return kept.join("\n");
+      }
+      /**
+       * True when `modal` is a stale re-parse of an already-resolved approval:
+       * same message text, and the chrome-stripped approval-context signature
+       * of `snap` is unchanged from the signature captured at resolve time.
+       *
+       * Public and reused verbatim by BOTH the settled-eval capture path
+       * (applyWaitingApproval, below) and any OUTSIDE re-parse the adapter
+       * performs independently of the settle loop — e.g. provider-cli-adapter's
+       * getStatus()/getDebugState() startup-gate modal detection, which reads
+       * `recentOutputBuffer` directly while `startupParseGate` is open and can
+       * re-surface the same already-resolved modal before the gate closes.
+       * Centralizing the discriminator here means there is exactly ONE
+       * definition of "stale" for the whole session — no divergent duplicate
+       * heuristic re-implemented per call site.
+       */
+      isStaleResolvedApproval(modal, snap) {
+        if (!modal) return false;
+        const normalizedMessage = typeof modal.message === "string" ? modal.message.trim() : "";
+        if (!normalizedMessage) return false;
+        return this.lastApprovalResolvedAt > 0 && normalizedMessage === this.lastResolvedModalMessage && this.computeApprovalContentSignature(snap) === this.lastApprovalResolvedContentSignature;
+      }
+      /** Clear all resolve-time approval bookkeeping (message, timestamp, content
+       *  signature) — called at turn/session boundaries so a next-turn or
+       *  next-session approval is never compared against stale prior state. */
+      clearApprovalResolutionMemory() {
+        this.lastApprovalResolvedAt = 0;
+        this.lastResolvedModalMessage = "";
+        this.lastApprovalResolvedContentSignature = "";
+      }
       /**
        * Schedule one more settled evaluation while pinned to `waiting_approval`
        * with no actionable modal. The settled FSM normally only re-runs on new
@@ -27477,8 +27594,8 @@ ${lastSnapshot}`;
             }
           }
         });
-        this.ptyProcess.onExit(({ exitCode }) => {
-          LOG.info("CLI", `[${this.cliType}] Exit code ${exitCode}`);
+        this.ptyProcess.onExit(({ exitCode, signal }) => {
+          LOG.info("CLI", `[${this.cliType}] Exit code ${exitCode === null || exitCode === void 0 ? "unknown" : exitCode}${signal ? ` (signal ${signal})` : ""}`);
           this.flushPendingOutputParse();
           this.ptyProcess = null;
           this.engine.onPtyExit();
@@ -27784,7 +27901,10 @@ ${lastSnapshot}`;
       // ─── Public API (CliAdapter) ───────────────────
       getStatus(options = {}) {
         const allowParse = options.allowParse !== false;
-        const startupModal = allowParse && this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
+        let startupModal = allowParse && this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
+        if (startupModal && this.engine.isStaleResolvedApproval(startupModal, { screenText: this.terminalScreen.getText(), accumulatedBuffer: this.accumulatedBuffer })) {
+          startupModal = null;
+        }
         const startupDetectedStatus = allowParse && this.startupParseGate && !startupModal ? this.runDetectStatus(this.recentOutputBuffer || this.terminalScreen.getText()) : null;
         if (allowParse && this.engine.currentStatus === "generating" && !this.engine.currentTurnScope && !this.engine.activeModal) {
           const now = Date.now();
@@ -27818,7 +27938,7 @@ ${lastSnapshot}`;
           if (liveDetect === "waiting_approval") {
             const liveModal = this.runParseApproval(this.terminalScreen.getText()) || this.runParseApproval(this.recentOutputBuffer);
             const buttonsOk = liveModal && Array.isArray(liveModal.buttons) && liveModal.buttons.some((b) => typeof b === "string" && b.trim());
-            if (liveModal && buttonsOk) {
+            if (liveModal && buttonsOk && !this.engine.isStaleResolvedApproval(liveModal, { screenText: this.terminalScreen.getText(), accumulatedBuffer: this.accumulatedBuffer })) {
               effectiveModal = liveModal;
               if (!this.engine.activeModal) this.engine.activeModal = liveModal;
             }
@@ -28944,7 +29064,10 @@ ${lastSnapshot}`;
       }
       getDebugState() {
         const screenText = sanitizeTerminalText(this.terminalScreen.getText());
-        const startupModal = this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
+        let startupModal = this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
+        if (startupModal && this.engine.isStaleResolvedApproval(startupModal, { screenText: this.terminalScreen.getText(), accumulatedBuffer: this.accumulatedBuffer })) {
+          startupModal = null;
+        }
         const startupDetectedStatus = this.startupParseGate && !startupModal ? this.runDetectStatus(this.recentOutputBuffer || screenText) : null;
         const effectiveReady = this.ready || !!startupModal || startupDetectedStatus === "waiting_approval";
         const parsedDebugState = this.getParsedDebugState();
@@ -42279,20 +42402,202 @@ var notificationHandlers = {
 init_config();
 
 // src/commands/upgrade-helper.ts
-import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 import { spawn as spawn2 } from "child_process";
 import * as fs15 from "fs";
 import * as os13 from "os";
 import * as path21 from "path";
 
 // src/commands/windows-atomic-upgrade.ts
-import { execFileSync as execFileSync3, spawn, spawnSync } from "child_process";
+import { execFileSync as execFileSync4, spawn, spawnSync } from "child_process";
 import * as fs14 from "fs";
 import * as http2 from "http";
 import * as path20 from "path";
+
+// src/commands/process-lifecycle.ts
+import { execFileSync as execFileSync3 } from "child_process";
+function defaultExecFileSync() {
+  return execFileSync3;
+}
+function getWindowsProcessCommandLine(pid, exec7) {
+  const pidFilter = `ProcessId=${pid}`;
+  try {
+    const psOut = exec7("powershell.exe", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-Command",
+      `(Get-CimInstance Win32_Process -Filter "${pidFilter}").CommandLine`
+    ], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+    const text = String(psOut).trim();
+    if (text) return text;
+  } catch {
+  }
+  try {
+    const wmicOut = exec7("wmic", [
+      "process",
+      "where",
+      pidFilter,
+      "get",
+      "CommandLine"
+    ], { encoding: "utf8", timeout: 3e3, stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+    const text = String(wmicOut).trim();
+    if (text) return text;
+  } catch {
+  }
+  return null;
+}
+function getProcessCommandLine(pid, options = {}) {
+  if (!Number.isFinite(pid) || pid <= 0) return null;
+  const exec7 = options.execFileSync ?? defaultExecFileSync();
+  const platform10 = options.platform ?? process.platform;
+  if (platform10 === "win32") {
+    return getWindowsProcessCommandLine(pid, exec7);
+  }
+  try {
+    const text = String(exec7("ps", ["-o", "command=", "-p", String(pid)], {
+      encoding: "utf8",
+      timeout: 3e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    })).trim();
+    return text || null;
+  } catch {
+    return null;
+  }
+}
+function parseNodeScriptPath(commandLine) {
+  if (!commandLine) return null;
+  let rest = commandLine.trim();
+  if (rest.startsWith('"')) {
+    const end = rest.indexOf('"', 1);
+    if (end === -1) return null;
+    rest = rest.slice(end + 1).trim();
+  } else {
+    const idx2 = rest.search(/\s/);
+    if (idx2 === -1) return null;
+    rest = rest.slice(idx2 + 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) {
+  return value.toLowerCase().replace(/\//g, "\\").replace(/\\+$/, "");
+}
+function killProcess(pid, options = {}) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  const exec7 = options.execFileSync ?? defaultExecFileSync();
+  const platform10 = options.platform ?? process.platform;
+  try {
+    if (platform10 === "win32") {
+      exec7("taskkill", ["/PID", String(pid), "/T", "/F"], {
+        stdio: "ignore",
+        windowsHide: true
+      });
+    } else {
+      process.kill(pid, "SIGTERM");
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitForPidExit(pid, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      process.kill(pid, 0);
+      await new Promise((resolve27) => setTimeout(resolve27, 250));
+    } catch {
+      return true;
+    }
+  }
+  return false;
+}
+function listOwnedNodeProcesses(options) {
+  const platform10 = options.platform ?? process.platform;
+  if (platform10 !== "win32") return [];
+  const exec7 = options.execFileSync ?? defaultExecFileSync();
+  const prefixes = options.prefixes.map((p) => normalizeWindowsPath(p));
+  const exclude = new Set((options.excludePids ?? []).filter((n) => Number.isFinite(n) && n > 0));
+  const markers = (options.markers ?? []).map((m) => m.toLowerCase().replace(/\//g, "\\"));
+  let pids = [];
+  try {
+    const out = String(exec7("powershell.exe", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-Command",
+      "Get-Process node -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id | ConvertTo-Json -Compress"
+    ], { encoding: "utf8", timeout: 8e3, stdio: ["ignore", "pipe", "ignore"], windowsHide: true })).trim();
+    if (out) {
+      const parsed = JSON.parse(out);
+      pids = Array.isArray(parsed) ? parsed : [parsed];
+    }
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const pid of pids) {
+    if (!Number.isFinite(pid) || pid <= 0 || exclude.has(pid)) continue;
+    const commandLine = getProcessCommandLine(pid, { platform: platform10, execFileSync: exec7 });
+    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;
+}
+async function stopOwnedProcesses(options) {
+  const waitMs = options.waitMs ?? 15e3;
+  const killed = /* @__PURE__ */ new Set();
+  for (const p of options.processes) {
+    if (killProcess(p.pid, options)) killed.add(p.pid);
+  }
+  const survivors = [];
+  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);
+  }
+  return { stopped: options.processes.length - survivors.length, survivors };
+}
+async function stopOwnedProcessesForPrefixes(options) {
+  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((s2) => s2.pid).join(", ")}`);
+  }
+  return result;
+}
+
+// src/commands/windows-atomic-upgrade.ts
 var POINTER_NAME = ".adhdev-current";
 var STABLE_FILES = [POINTER_NAME, "adhdev.cmd", "adhdev.ps1", "adhdev"];
 var DEFAULT_HEALTH_PORT = 19222;
+var ADHDEV_OWNED_MARKERS = [
+  "session-host-daemon",
+  "node_modules/adhdev",
+  "node_modules/@adhdev/daemon-standalone"
+];
 function normalizeForCompare(value) {
   return path20.resolve(value).replace(/[\\/]+$/, "").toLowerCase();
 }
@@ -42315,7 +42620,7 @@ function resolveWindowsInstallerLayout(options) {
 }
 function nodeMajor(nodeExecutable) {
   try {
-    const version = String(execFileSync3(nodeExecutable, ["-p", "process.versions.node"], {
+    const version = String(execFileSync4(nodeExecutable, ["-p", "process.versions.node"], {
       encoding: "utf8",
       timeout: 5e3,
       windowsHide: true,
@@ -42377,7 +42682,7 @@ exit $LASTEXITCODE\r
   }
 }
 function validateStagedCli(portableNode, cliEntry, targetVersion) {
-  const output = String(execFileSync3(portableNode, [cliEntry, "--version"], {
+  const output = String(execFileSync4(portableNode, [cliEntry, "--version"], {
     encoding: "utf8",
     timeout: 15e3,
     windowsHide: true,
@@ -42491,6 +42796,19 @@ async function performWindowsAtomicUpgrade(options) {
     pinStagedShims(stagedPrefix, portableNode, stagedCliEntry);
     validateStagedCli(portableNode, stagedCliEntry, targetVersion);
     hooks.log(`Validated staged CLI and portable Node 22 shims in ${stagedPrefix}`);
+    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: 15e3,
+      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}`);
@@ -42500,7 +42818,7 @@ async function performWindowsAtomicUpgrade(options) {
       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);
@@ -42518,7 +42836,7 @@ async function performWindowsAtomicUpgrade(options) {
       hooks.log("Failed to restart the previous daemon during rollback");
     }
     try {
-      hooks.cleanup(layout, layout.activePrefix);
+      await hooks.cleanup(layout, layout.activePrefix);
     } catch {
     }
     throw error;
@@ -42530,7 +42848,7 @@ function createDefaultWindowsAtomicHooks(options) {
       const env = { ...options.env, ADHDEV_BOOTSTRAP: "1" };
       const pathKey = Object.keys(env).find((key2) => key2.toLowerCase() === "path") || "Path";
       env[pathKey] = `${path20.dirname(portableNode)};${env[pathKey] || ""}`;
-      execFileSync3(portableNode, [
+      execFileSync4(portableNode, [
         options.npmCliPath,
         "install",
         "-g",
@@ -42600,15 +42918,23 @@ function createDefaultWindowsAtomicHooks(options) {
     },
     stopProcess: (pid) => {
       try {
-        execFileSync3("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+        execFileSync4("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
       } catch {
       }
     },
-    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: 15e3,
+      log: options.log
+    }),
     log: options.log
   };
 }
-function boundedCleanupInactivePrefixes(layout, activePrefix, log) {
+async function cleanupInactivePrefixesWithGuard(options) {
+  const { layout, activePrefix, log } = options;
   let candidates = [];
   try {
     candidates = fs14.readdirSync(layout.installRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("version-")).map((entry) => path20.join(layout.installRoot, entry.name)).filter((entry) => normalizeForCompare(entry) !== normalizeForCompare(activePrefix)).sort().slice(0, 8);
@@ -42616,19 +42942,41 @@ function boundedCleanupInactivePrefixes(layout, activePrefix, log) {
     return;
   }
   if (candidates.length === 0) return;
-  const escaped = candidates.map((candidate) => quotePowerShellLiteral(candidate)).join(",");
-  const script = `$ErrorActionPreference='Stop'; @(${escaped}) | ForEach-Object { if (Test-Path -LiteralPath $_) { Remove-Item -LiteralPath $_ -Recurse -Force } }`;
-  const encoded = Buffer.from(script, "utf16le").toString("base64");
-  const result = spawnSync("powershell.exe", [
-    "-NoLogo",
-    "-NoProfile",
-    "-NonInteractive",
-    "-ExecutionPolicy",
-    "Bypass",
-    "-EncodedCommand",
-    encoded
-  ], { timeout: 5e3, windowsHide: true, stdio: "ignore" });
-  if (result.error || result.status !== 0) log("Bounded inactive-prefix cleanup was incomplete; future updates will retry");
+  for (const candidate of candidates) {
+    const stopResult = await stopOwnedProcessesForPrefixes({
+      prefixes: [candidate],
+      excludePids: options.excludePids,
+      markers: options.markers,
+      waitMs: options.waitMs ?? 15e3,
+      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, log) {
+  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: 5e3, 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) {
+    log?.(`Failed to remove inactive prefix ${target}: ${error?.message || String(error)}`);
+  }
 }
 
 // src/commands/upgrade-helper.ts
@@ -42757,7 +43105,7 @@ function getNpmExecOptions(platform10 = process.platform) {
 }
 function execNpmCommandSync(args, options = {}, surface) {
   const execOptions = surface?.execOptions || getNpmExecOptions();
-  return execFileSync4(
+  return execFileSync5(
     surface?.npmExecutable || "npm",
     [...surface?.npmArgsPrefix || [], ...args],
     {
@@ -42767,74 +43115,10 @@ function execNpmCommandSync(args, options = {}, surface) {
     }
   );
 }
-function killPid(pid) {
-  try {
-    if (process.platform === "win32") {
-      execFileSync4("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
-    } else {
-      process.kill(pid, "SIGTERM");
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getWindowsProcessCommandLine(pid) {
-  const pidFilter = `ProcessId=${pid}`;
-  try {
-    const psOut = execFileSync4("powershell.exe", [
-      "-NoProfile",
-      "-NonInteractive",
-      "-ExecutionPolicy",
-      "Bypass",
-      "-Command",
-      `(Get-CimInstance Win32_Process -Filter "${pidFilter}").CommandLine`
-    ], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim();
-    if (psOut) return psOut;
-  } catch {
-  }
-  try {
-    const wmicOut = execFileSync4("wmic", [
-      "process",
-      "where",
-      pidFilter,
-      "get",
-      "CommandLine"
-    ], { encoding: "utf8", timeout: 3e3, stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim();
-    if (wmicOut) return wmicOut;
-  } catch {
-  }
-  return null;
-}
-function getProcessCommandLine(pid) {
-  if (!Number.isFinite(pid) || pid <= 0) return null;
-  if (process.platform === "win32") return getWindowsProcessCommandLine(pid);
-  try {
-    const text = execFileSync4("ps", ["-o", "command=", "-p", String(pid)], {
-      encoding: "utf8",
-      timeout: 3e3,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-    return text || null;
-  } catch {
-    return null;
-  }
-}
 function isManagedSessionHostPid(pid) {
   const commandLine = getProcessCommandLine(pid);
   return !!commandLine && /session-host-daemon/i.test(commandLine);
 }
-async function waitForPidExit(pid, timeoutMs) {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    try {
-      process.kill(pid, 0);
-      await new Promise((resolve27) => setTimeout(resolve27, 250));
-    } catch {
-      return;
-    }
-  }
-}
 async function stopSessionHostProcesses(appName) {
   const pidFile = path21.join(os13.homedir(), ".adhdev", `${appName}-session-host.pid`);
   let killedPid = null;
@@ -42842,7 +43126,7 @@ async function stopSessionHostProcesses(appName) {
     if (fs15.existsSync(pidFile)) {
       const pid = Number.parseInt(fs15.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 {
@@ -42878,7 +43162,7 @@ function listForeignNativeAddonHolders(packageRoot) {
   ].join("\n");
   let out = "";
   try {
-    out = String(execFileSync4("powershell.exe", [
+    out = String(execFileSync5("powershell.exe", [
       "-NoProfile",
       "-NonInteractive",
       "-ExecutionPolicy",
@@ -42910,7 +43194,7 @@ async function stopForeignNativeAddonHolders(packageRoot, options = {}) {
     appendUpgradeLog(
       `Foreign native-addon holder found: pid ${holder.pid}${holder.commandLine ? ` \u2014 ${holder.commandLine}` : ""}`
     );
-    const killed = killPid(holder.pid);
+    const killed = killProcess(holder.pid);
     if (killed) {
       await waitForPidExit(holder.pid, 15e3);
       appendUpgradeLog(`Terminated foreign native-addon holder pid ${holder.pid}`);
@@ -43043,11 +43327,25 @@ async function runDaemonUpgradeHelper(payload) {
       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}`);
+    const upgradePids = [process.pid, payload.parentPid].filter((n) => Number.isFinite(n) && n > 0);
+    const preStop = await stopOwnedProcessesForPrefixes({
+      prefixes: [windowsInstallerLayout.activePrefix, windowsInstallerLayout.stablePrefix],
+      excludePids: upgradePids,
+      markers: Array.from(ADHDEV_OWNED_MARKERS),
+      waitMs: 15e3,
+      log: appendUpgradeLog
+    });
+    if (preStop.survivors.length > 0) {
+      throw new Error(
+        `Cannot upgrade: owned processes still running under current prefix: ${preStop.survivors.map((s2) => s2.pid).join(", ")}`
+      );
+    }
     await performWindowsAtomicUpgrade({
       layout: windowsInstallerLayout,
       packageName: payload.packageName,
       targetVersion: payload.targetVersion,
       portableNode,
+      excludePids: upgradePids,
       hooks: createDefaultWindowsAtomicHooks({
         packageName: payload.packageName,
         targetVersion: payload.targetVersion,
@@ -43073,7 +43371,7 @@ async function runDaemonUpgradeHelper(payload) {
   let installOutput = "";
   for (let attempt = 1; attempt <= maxInstallAttempts; attempt++) {
     try {
-      installOutput = String(execFileSync4(
+      installOutput = String(execFileSync5(
         installCommand.command,
         installCommand.args,
         {
@@ -43716,7 +44014,7 @@ import * as os22 from "os";
 import * as path30 from "path";
 import * as crypto6 from "crypto";
 import { existsSync as existsSync33, mkdirSync as mkdirSync14, writeFileSync as writeFileSync17 } from "fs";
-import { execFileSync as execFileSync5 } from "child_process";
+import { execFileSync as execFileSync6 } from "child_process";
 import chalk from "chalk";
 init_summary_metadata();
 
@@ -52087,7 +52385,7 @@ function commandExists(command) {
     return existsSync33(expandExecutable(trimmed));
   }
   try {
-    execFileSync5(process.platform === "win32" ? "where" : "which", [trimmed], {
+    execFileSync6(process.platform === "win32" ? "where" : "which", [trimmed], {
       stdio: "ignore",
       ...process.platform === "win32" ? { windowsHide: true } : {}
     });
@@ -57998,15 +58296,15 @@ var ideHandlers = {
   stop_ide: async (ctx, args) => {
     const ideType = args?.ideType;
     if (!ideType) throw new Error("ideType required");
-    const killProcess = args?.killProcess !== false;
-    await ctx.stopIde(ideType, killProcess);
+    const killProcess2 = args?.killProcess !== false;
+    await ctx.stopIde(ideType, killProcess2);
     try {
       const results = await detectIDEs(ctx.deps.providerLoader);
       ctx.deps.detectedIdes.value = results;
       ctx.deps.providerLoader.setIdeDetectionResults(results, true);
     } catch {
     }
-    return { success: true, ideType, stopped: true, processKilled: killProcess };
+    return { success: true, ideType, stopped: true, processKilled: killProcess2 };
   },
   // ─── IDE restart ───
   restart_ide: async (ctx, args) => {
@@ -60279,7 +60577,7 @@ import * as fs32 from "fs";
 import { hostname as osHostname } from "os";
 
 // src/mesh/preview-freshness.ts
-import { execFileSync as execFileSync7 } from "child_process";
+import { execFileSync as execFileSync8 } from "child_process";
 import { existsSync as existsSync42, readFileSync as readFileSync32 } from "fs";
 import { resolve as resolve21 } from "path";
 var PREVIEW_DEPLOY_RECORD = ".adhdev/preview-deploy.json";
@@ -60305,7 +60603,7 @@ function isPreviewPipelineConfigured(repoRoot) {
 }
 function runGit2(repoRoot, args) {
   try {
-    return execFileSync7("git", args, {
+    return execFileSync8("git", args, {
       cwd: repoRoot,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
@@ -61129,7 +61427,7 @@ init_dist();
 init_mesh_events();
 init_mesh_reconcile_identity();
 init_mesh_fast_forward();
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 
 // src/mesh/mesh-refine-batch.ts
 init_resolve_executable();
@@ -61232,7 +61530,7 @@ init_worktree_bootstrap_config();
 init_resolve_executable();
 import { basename as pathBasename, join as pathJoin2, resolve as pathResolve2 } from "path";
 import * as fs34 from "fs";
-import { execFileSync as execFileSync8 } from "child_process";
+import { execFileSync as execFileSync9 } from "child_process";
 var GIT2 = process.platform === "win32" ? resolveWin32Executable("git") : "git";
 var REFINE_VALIDATION_TIMEOUT_MS = 12e4;
 var REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
@@ -61287,18 +61585,18 @@ function resolveRefineryAutoPublishSubmoduleMainCommits(mesh, workspace) {
   return { enabled: false };
 }
 async function computeGitPatchId(cwd, fromRef, toRef, excludePaths = []) {
-  const { execFileSync: execFileSync11 } = await import("child_process");
+  const { execFileSync: execFileSync12 } = await import("child_process");
   const diffArgs = ["diff", "--patch", "--full-index", fromRef, toRef];
   if (excludePaths.length > 0) {
     diffArgs.push("--", ".", ...excludePaths.map((path46) => `:(exclude)${path46}`));
   }
-  const diff = execFileSync11(GIT2, diffArgs, {
+  const diff = execFileSync12(GIT2, diffArgs, {
     cwd,
     encoding: "utf8",
     maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
   });
   if (!diff.trim()) return "";
-  const patchId = execFileSync11(GIT2, ["patch-id", "--stable"], {
+  const patchId = execFileSync12(GIT2, ["patch-id", "--stable"], {
     cwd,
     input: diff,
     encoding: "utf8",
@@ -61309,8 +61607,8 @@ async function computeGitPatchId(cwd, fromRef, toRef, excludePaths = []) {
 async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead) {
   const startedAt = Date.now();
   try {
-    const { execFileSync: execFileSync11 } = await import("child_process");
-    const git = (args) => execFileSync11(GIT2, args, {
+    const { execFileSync: execFileSync12 } = await import("child_process");
+    const git = (args) => execFileSync12(GIT2, args, {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -61411,7 +61709,7 @@ async function classifyPatchEquivalenceFailure(repoRoot, baseHead, branchHead, s
     ...autoPublish !== void 0 ? { autoPublishSubmoduleMainCommits: autoPublish } : {}
   };
   try {
-    const git = (args) => execFileSync8(GIT2, args, {
+    const git = (args) => execFileSync9(GIT2, args, {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
@@ -61536,7 +61834,7 @@ async function classifyPatchEquivalenceFailure(repoRoot, baseHead, branchHead, s
 }
 function execGitOk(cwd, args) {
   try {
-    execFileSync8(GIT2, args, { cwd, encoding: "utf8", maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES, windowsHide: true });
+    execFileSync9(GIT2, args, { cwd, encoding: "utf8", maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES, windowsHide: true });
     return true;
   } catch {
     return false;
@@ -61545,8 +61843,8 @@ function execGitOk(cwd, args) {
 async function checkWorktreeChangesPatchEquivalentInRef(repoRoot, ref, worktreeHead) {
   const startedAt = Date.now();
   try {
-    const { execFileSync: execFileSync11 } = await import("child_process");
-    const git = (gitArgs) => execFileSync11(GIT2, gitArgs, {
+    const { execFileSync: execFileSync12 } = await import("child_process");
+    const git = (gitArgs) => execFileSync12(GIT2, gitArgs, {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -61609,8 +61907,8 @@ ${mergeTreeErr?.stderr || ""}`;
 async function runMeshRefineEffectiveDiffGate(repoRoot, baseHead, branchHead) {
   const startedAt = Date.now();
   try {
-    const { execFileSync: execFileSync11 } = await import("child_process");
-    const git = (args, opts) => execFileSync11(GIT2, args, {
+    const { execFileSync: execFileSync12 } = await import("child_process");
+    const git = (args, opts) => execFileSync12(GIT2, args, {
       cwd: opts?.cwd || repoRoot,
       encoding: "utf8",
       maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -61686,7 +61984,7 @@ function buildPatchEquivalenceSubmoduleConflictHint(repoRoot, baseHead, branchHe
 }
 function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
   try {
-    const output = execFileSync8(GIT2, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+    const output = execFileSync9(GIT2, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -61710,7 +62008,7 @@ function readChangedGitlinkPaths(repoRoot, fromRef, toRef) {
 }
 function readTreeObject(repoRoot, ref, path46) {
   try {
-    const output = execFileSync8(GIT2, ["ls-tree", ref, "--", path46], {
+    const output = execFileSync9(GIT2, ["ls-tree", ref, "--", path46], {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: 1024 * 1024
@@ -61722,7 +62020,7 @@ function readTreeObject(repoRoot, ref, path46) {
   }
 }
 function resolveGitDir(repoRoot) {
-  const out = execFileSync8(GIT2, ["rev-parse", "--absolute-git-dir"], {
+  const out = execFileSync9(GIT2, ["rev-parse", "--absolute-git-dir"], {
     cwd: repoRoot,
     encoding: "utf8",
     maxBuffer: 1024 * 1024
@@ -61734,9 +62032,9 @@ function isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) {
   if (baseCommit === branchCommit) return true;
   try {
     if (!fs34.existsSync(submoduleRepoPath)) return false;
-    execFileSync8(GIT2, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-    execFileSync8(GIT2, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
-    execFileSync8(GIT2, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
+    execFileSync9(GIT2, ["cat-file", "-e", `${baseCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+    execFileSync9(GIT2, ["cat-file", "-e", `${branchCommit}^{commit}`], { cwd: submoduleRepoPath, stdio: "ignore" });
+    execFileSync9(GIT2, ["merge-base", "--is-ancestor", baseCommit, branchCommit], { cwd: submoduleRepoPath, stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -61744,7 +62042,7 @@ function isSubmoduleFastForward(submoduleRepoPath, baseCommit, branchCommit) {
 }
 function readChangedPathKinds(repoRoot, fromRef, toRef) {
   try {
-    const output = execFileSync8(GIT2, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
+    const output = execFileSync9(GIT2, ["diff", "--raw", "--no-abbrev", fromRef, toRef], {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -61796,7 +62094,7 @@ function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
   }
   let mergeBase = "";
   try {
-    mergeBase = execFileSync8(GIT2, ["merge-base", baseHead, branchHead], {
+    mergeBase = execFileSync9(GIT2, ["merge-base", baseHead, branchHead], {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: 1024 * 1024
@@ -61826,7 +62124,7 @@ function evaluateGitlinkTrivialFastForward(repoRoot, baseHead, branchHead) {
 }
 function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderCommit) {
   try {
-    const tree = execFileSync8(GIT2, ["rev-parse", `${commitish}^{tree}`], {
+    const tree = execFileSync9(GIT2, ["rev-parse", `${commitish}^{tree}`], {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: 1024 * 1024
@@ -61837,8 +62135,8 @@ function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderC
     const tmpIndex = pathJoin2(resolveGitDir(repoRoot), `adhdev-refine-eq-${commitish.slice(0, 12)}.index`);
     const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
     try {
-      execFileSync8(GIT2, ["read-tree", tree], { cwd: repoRoot, env, stdio: "ignore" });
-      execFileSync8(GIT2, ["update-index", "--index-info"], {
+      execFileSync9(GIT2, ["read-tree", tree], { cwd: repoRoot, env, stdio: "ignore" });
+      execFileSync9(GIT2, ["update-index", "--index-info"], {
         cwd: repoRoot,
         env,
         input: `${updates}
@@ -61846,7 +62144,7 @@ function buildTreeWithGitlinksEqualized(repoRoot, commitish, paths, placeholderC
         encoding: "utf8",
         stdio: ["pipe", "ignore", "ignore"]
       });
-      const newTree = execFileSync8(GIT2, ["write-tree"], { cwd: repoRoot, env, encoding: "utf8" }).trim();
+      const newTree = execFileSync9(GIT2, ["write-tree"], { cwd: repoRoot, env, encoding: "utf8" }).trim();
       return newTree || void 0;
     } finally {
       try {
@@ -61862,7 +62160,7 @@ function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, g
   try {
     const branchGitlinks = gitlinks.filter((entry) => entry.branchCommit);
     const gitlinkPaths = branchGitlinks.map((entry) => entry.path);
-    const mergeBase = execFileSync8(GIT2, ["merge-base", baseHead, branchHead], {
+    const mergeBase = execFileSync9(GIT2, ["merge-base", baseHead, branchHead], {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: 1024 * 1024
@@ -61875,22 +62173,22 @@ function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, g
       const theirsEqTree = buildTreeWithGitlinksEqualized(repoRoot, branchHead, gitlinkPaths, placeholder);
       if (baseEqTree && oursEqTree && theirsEqTree) {
         try {
-          const baseEqCommit = execFileSync8(GIT2, ["commit-tree", baseEqTree, "-m", "refine-ff-base"], {
+          const baseEqCommit = execFileSync9(GIT2, ["commit-tree", baseEqTree, "-m", "refine-ff-base"], {
             cwd: repoRoot,
             encoding: "utf8",
             maxBuffer: 1024 * 1024
           }).trim();
-          const oursEqCommit = execFileSync8(GIT2, ["commit-tree", oursEqTree, "-p", baseEqCommit, "-m", "refine-ff-ours"], {
+          const oursEqCommit = execFileSync9(GIT2, ["commit-tree", oursEqTree, "-p", baseEqCommit, "-m", "refine-ff-ours"], {
             cwd: repoRoot,
             encoding: "utf8",
             maxBuffer: 1024 * 1024
           }).trim();
-          const theirsEqCommit = execFileSync8(GIT2, ["commit-tree", theirsEqTree, "-p", baseEqCommit, "-m", "refine-ff-theirs"], {
+          const theirsEqCommit = execFileSync9(GIT2, ["commit-tree", theirsEqTree, "-p", baseEqCommit, "-m", "refine-ff-theirs"], {
             cwd: repoRoot,
             encoding: "utf8",
             maxBuffer: 1024 * 1024
           }).trim();
-          const mergeOut = execFileSync8(GIT2, ["merge-tree", "--write-tree", oursEqCommit, theirsEqCommit], {
+          const mergeOut = execFileSync9(GIT2, ["merge-tree", "--write-tree", oursEqCommit, theirsEqCommit], {
             cwd: repoRoot,
             encoding: "utf8",
             maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -61901,7 +62199,7 @@ function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, g
         }
       }
     }
-    const contentTree = mergedContentTree || execFileSync8(GIT2, ["rev-parse", `${baseHead}^{tree}`], {
+    const contentTree = mergedContentTree || execFileSync9(GIT2, ["rev-parse", `${baseHead}^{tree}`], {
       cwd: repoRoot,
       encoding: "utf8",
       maxBuffer: 1024 * 1024
@@ -61912,8 +62210,8 @@ function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, g
     const tmpIndex = pathJoin2(resolveGitDir(repoRoot), `adhdev-refine-ff-${baseHead.slice(0, 12)}-${branchHead.slice(0, 12)}.index`);
     const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
     try {
-      execFileSync8(GIT2, ["read-tree", contentTree], { cwd: repoRoot, env, stdio: "ignore" });
-      execFileSync8(GIT2, ["update-index", "--index-info"], {
+      execFileSync9(GIT2, ["read-tree", contentTree], { cwd: repoRoot, env, stdio: "ignore" });
+      execFileSync9(GIT2, ["update-index", "--index-info"], {
         cwd: repoRoot,
         env,
         input: `${updates}
@@ -61921,7 +62219,7 @@ function synthesizeTrivialFastForwardMergeTree(repoRoot, baseHead, branchHead, g
         encoding: "utf8",
         stdio: ["pipe", "ignore", "ignore"]
       });
-      const newTree = execFileSync8(GIT2, ["write-tree"], { cwd: repoRoot, env, encoding: "utf8" }).trim();
+      const newTree = execFileSync9(GIT2, ["write-tree"], { cwd: repoRoot, env, encoding: "utf8" }).trim();
       return newTree || void 0;
     } finally {
       try {
@@ -62834,10 +63132,10 @@ async function refineSyncBaseStage(self, ctx) {
   }
   const rebaseStarted = Date.now();
   try {
-    execFileSync9("git", ["rebase", baseHead], { cwd: node.workspace, stdio: ["ignore", "pipe", "pipe"] });
+    execFileSync10("git", ["rebase", baseHead], { cwd: node.workspace, stdio: ["ignore", "pipe", "pipe"] });
   } catch (rebaseErr) {
     try {
-      execFileSync9("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
+      execFileSync10("git", ["rebase", "--abort"], { cwd: node.workspace, stdio: "ignore" });
     } catch {
     }
     let submoduleHintPatchEquivalence;
@@ -65719,7 +66017,7 @@ var DaemonCommandRouter = class {
   /**
    * IDE stop: CDP disconnect + InstanceManager cleanup + optionally kill OS process
    */
-  async stopIde(ideType, killProcess = false) {
+  async stopIde(ideType, killProcess2 = false) {
     const cdpKeysToRemove = [];
     for (const key2 of this.deps.cdpManagers.keys()) {
       if (key2 === ideType || key2.startsWith(`${ideType}_`)) {
@@ -65757,7 +66055,7 @@ var DaemonCommandRouter = class {
         LOG.info("StopIDE", `Instance removed: ${instanceKey}`);
       }
     }
-    if (killProcess) {
+    if (killProcess2) {
       const running = await isIdeRunning(ideType);
       if (running) {
         LOG.info("StopIDE", `Killing IDE process: ${ideType}`);
@@ -65772,7 +66070,7 @@ var DaemonCommandRouter = class {
       }
     }
     this.deps.onStatusChange?.();
-    LOG.info("StopIDE", `IDE stopped: ${ideType} (processKill=${killProcess})`);
+    LOG.info("StopIDE", `IDE stopped: ${ideType} (processKill=${killProcess2})`);
   }
 };
 
@@ -72709,8 +73007,10 @@ var SessionHostRuntimeTransport = class {
       return;
     }
     if (event.type === "session_exit") {
+      const exitCode = typeof event.exitCode === "number" ? event.exitCode : null;
+      const signal = typeof event.signal === "number" ? event.signal : null;
       for (const callback of this.exitCallbacks) {
-        callback({ exitCode: event.exitCode ?? 0 });
+        callback({ exitCode, signal });
       }
       void this.closeClient(false);
     }
@@ -73102,7 +73402,7 @@ async function listHostedCliRuntimes(endpoint) {
 }
 
 // src/session-host/managed-host.ts
-import { execFileSync as execFileSync10, spawn as spawn5 } from "child_process";
+import { execFileSync as execFileSync11, spawn as spawn5 } from "child_process";
 import * as fs43 from "fs";
 import * as os31 from "os";
 import * as path45 from "path";
@@ -73110,6 +73410,7 @@ import {
   getDefaultSessionHostEndpoint as getDefaultSessionHostEndpoint2,
   sanitizeSpawnEnv as sanitizeSpawnEnv2
 } from "@adhdev/session-host-core";
+init_logger();
 init_runtime_defaults();
 function createManagedSessionHost(options) {
   const appName = options.appName;
@@ -73133,6 +73434,14 @@ function createManagedSessionHost(options) {
     }
     return __require.resolve("@adhdev/session-host-daemon");
   }
+  function pathsEquivalent(left, right) {
+    return path45.resolve(left).toLowerCase() === path45.resolve(right).toLowerCase();
+  }
+  function getRunningSessionHostScriptPath(pid) {
+    const commandLine = getProcessCommandLine(pid);
+    if (!commandLine || !/session-host-daemon/i.test(commandLine)) return null;
+    return parseNodeScriptPath(commandLine);
+  }
   function getPidFile() {
     return path45.join(os31.homedir(), ".adhdev", `${appName}-session-host.pid`);
   }
@@ -73146,12 +73455,12 @@ function createManagedSessionHost(options) {
       return null;
     }
   }
-  function killPid2(pid) {
+  function killPid(pid) {
     try {
       if (process.platform === "win32") {
         const spawnOpts = { stdio: "ignore" };
         if (options.killWindowsHide) spawnOpts.windowsHide = true;
-        execFileSync10("taskkill", ["/PID", String(pid), "/T", "/F"], spawnOpts);
+        execFileSync11("taskkill", ["/PID", String(pid), "/T", "/F"], spawnOpts);
       } else {
         process.kill(pid, "SIGTERM");
       }
@@ -73191,7 +73500,7 @@ function createManagedSessionHost(options) {
       if (fs43.existsSync(pidFile)) {
         const pid = Number.parseInt(fs43.readFileSync(pidFile, "utf8").trim(), 10);
         if (Number.isFinite(pid) && pid !== process.pid && isManagedPid(pid)) {
-          stopped = killPid2(pid) || stopped;
+          stopped = killPid(pid) || stopped;
         }
       }
     } catch {
@@ -73208,6 +73517,20 @@ function createManagedSessionHost(options) {
   }
   async function ensureReady() {
     options.beforeEnsureReady?.();
+    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 ensureSessionHostReady({
         appName,
@@ -73236,7 +73559,7 @@ function createManagedSessionHost(options) {
     getPid,
     buildEnv,
     resolveEntry,
-    killPid: killPid2,
+    killPid,
     spawnHost,
     stopManagedSessionHostProcess,
     ensureReady,