adhdev 0.8.33 → 0.8.35

package/dist/cli/index.js

@@ -9724,8 +9724,6 @@ ${data.message || ""}`.trim();
         if (blockingModal || this.currentStatus === "waiting_approval") {
           throw new Error(`${this.cliName} is awaiting confirmation before it can accept a prompt`);
         }
-        this.committedMessages.push({ role: "user", content: text, timestamp: Date.now() });
-        this.syncMessageViews();
         this.isWaitingForResponse = true;
         this.responseBuffer = "";
         this.finishRetryCount = 0;
@@ -9757,6 +9755,13 @@ ${data.message || ""}`.trim();
         const submitDelayMs = this.sendDelayMs + Math.min(2e3, Math.max(0, estimatedLines - 1) * 350);
         const maxEchoWaitMs = submitDelayMs + Math.max(1500, Math.min(5e3, estimatedLines * 500));
         const retryDelayMs = Math.max(350, Math.min(1500, Math.max(this.sendDelayMs, submitDelayMs)));
+        let didCommitUserTurn = false;
+        const commitUserTurn = () => {
+          if (didCommitUserTurn) return;
+          didCommitUserTurn = true;
+          this.committedMessages.push({ role: "user", content: text, timestamp: Date.now() });
+          this.syncMessageViews();
+        };
         if (this.settleTimer) {
           clearTimeout(this.settleTimer);
           this.settleTimer = null;
@@ -9769,109 +9774,128 @@ ${data.message || ""}`.trim();
             if (this.isWaitingForResponse) this.finishResponse();
           }, this.timeouts.maxResponse);
         };
-        const submit = () => {
-          if (!this.ptyProcess) return;
-          this.submitPendingUntil = 0;
-          this.recordTrace("submit_write", {
-            mode: "submit_key",
-            sendKey: this.sendKey,
-            screenText: summarizeCliTraceText(this.terminalScreen.getText(), 500)
-          });
-          this.ptyProcess.write(this.sendKey);
-          const retrySubmitIfStuck = (attempt) => {
-            this.submitRetryTimer = null;
-            if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
-            if (this.currentStatus === "waiting_approval") return;
-            if ((this.responseBuffer || "").trim()) return;
+        await new Promise((resolve17) => {
+          let resolved = false;
+          const resolveOnce = () => {
+            if (resolved) return;
+            resolved = true;
+            resolve17();
+          };
+          const submit = () => {
+            if (!this.ptyProcess) {
+              resolveOnce();
+              return;
+            }
+            commitUserTurn();
+            this.submitPendingUntil = 0;
             const screenText = this.terminalScreen.getText();
-            if (!promptLikelyVisible(screenText, normalizedPromptSnippet)) return;
-            if (/Esc to interrupt|Do you want to proceed|This command requires approval|Allow Codex to|Approve and run now|Always approve this session|Running…|Running\.\.\./i.test(screenText)) return;
-            this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
-            LOG.info("CLI", `[${this.cliType}] Retrying submit key for stuck prompt (attempt ${attempt})`);
             this.recordTrace("submit_write", {
-              mode: "submit_retry",
-              attempt,
+              mode: "submit_key",
               sendKey: this.sendKey,
               screenText: summarizeCliTraceText(screenText, 500)
             });
             this.ptyProcess.write(this.sendKey);
-            if (attempt >= 3) {
-              this.submitRetryUsed = true;
-              return;
-            }
-            this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(attempt + 1), retryDelayMs);
+            const retrySubmitIfStuck = (attempt) => {
+              this.submitRetryTimer = null;
+              if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
+              if (this.currentStatus === "waiting_approval") return;
+              if ((this.responseBuffer || "").trim()) return;
+              const screenText2 = this.terminalScreen.getText();
+              if (!promptLikelyVisible(screenText2, normalizedPromptSnippet)) return;
+              if (/Esc to interrupt|Do you want to proceed|This command requires approval|Allow Codex to|Approve and run now|Always approve this session|Running…|Running\.\.\./i.test(screenText2)) return;
+              this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
+              LOG.info("CLI", `[${this.cliType}] Retrying submit key for stuck prompt (attempt ${attempt})`);
+              this.recordTrace("submit_write", {
+                mode: "submit_retry",
+                attempt,
+                sendKey: this.sendKey,
+                screenText: summarizeCliTraceText(screenText2, 500)
+              });
+              this.ptyProcess.write(this.sendKey);
+              if (attempt >= 3) {
+                this.submitRetryUsed = true;
+                return;
+              }
+              this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(attempt + 1), retryDelayMs);
+            };
+            this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(1), retryDelayMs);
+            startResponseTimeout();
+            resolveOnce();
           };
-          this.submitRetryTimer = setTimeout(() => retrySubmitIfStuck(1), retryDelayMs);
-          startResponseTimeout();
-        };
-        if (this.submitStrategy === "immediate") {
-          this.submitPendingUntil = 0;
+          if (this.submitStrategy === "immediate") {
+            commitUserTurn();
+            this.submitPendingUntil = 0;
+            this.recordTrace("submit_write", {
+              mode: "immediate",
+              text: summarizeCliTraceText(text, 500),
+              sendKey: this.sendKey,
+              screenText: summarizeCliTraceText(this.terminalScreen.getText(), 500)
+            });
+            this.ptyProcess.write(text + this.sendKey);
+            this.submitRetryTimer = setTimeout(() => {
+              this.submitRetryTimer = null;
+              if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
+              if (this.currentStatus === "waiting_approval") return;
+              if ((this.responseBuffer || "").trim()) return;
+              const screenText = this.terminalScreen.getText();
+              if (!promptLikelyVisible(screenText, normalizedPromptSnippet)) return;
+              LOG.info("CLI", `[${this.cliType}] Retrying submit key for stuck prompt (attempt 1)`);
+              this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
+              this.recordTrace("submit_write", {
+                mode: "immediate_retry",
+                attempt: 1,
+                sendKey: this.sendKey,
+                screenText: summarizeCliTraceText(screenText, 500)
+              });
+              this.ptyProcess.write(this.sendKey);
+              this.submitRetryUsed = true;
+            }, retryDelayMs);
+            startResponseTimeout();
+            resolveOnce();
+            return;
+          }
+          if (submitDelayMs > 0) {
+            this.submitPendingUntil = Date.now() + submitDelayMs;
+          }
+          this.ptyProcess.write(text);
           this.recordTrace("submit_write", {
-            mode: "immediate",
+            mode: "type_then_submit",
             text: summarizeCliTraceText(text, 500),
             sendKey: this.sendKey,
             screenText: summarizeCliTraceText(this.terminalScreen.getText(), 500)
           });
-          this.ptyProcess.write(text + this.sendKey);
-          this.submitRetryTimer = setTimeout(() => {
-            this.submitRetryTimer = null;
-            if (!this.ptyProcess || !this.isWaitingForResponse || this.submitRetryUsed) return;
-            if (this.currentStatus === "waiting_approval") return;
-            if ((this.responseBuffer || "").trim()) return;
+          const submitStartedAt = Date.now();
+          let lastNormalizedScreen = "";
+          let lastScreenChangeAt = submitStartedAt;
+          const waitForEchoAndSubmit = () => {
+            if (!this.ptyProcess) {
+              resolveOnce();
+              return;
+            }
+            const now = Date.now();
+            const elapsed = now - submitStartedAt;
             const screenText = this.terminalScreen.getText();
-            if (!promptLikelyVisible(screenText, normalizedPromptSnippet)) return;
-            LOG.info("CLI", `[${this.cliType}] Retrying submit key for stuck prompt (attempt 1)`);
-            this.responseSettleIgnoreUntil = Date.now() + this.timeouts.outputSettle + 400;
-            this.recordTrace("submit_write", {
-              mode: "immediate_retry",
-              attempt: 1,
-              sendKey: this.sendKey,
-              screenText: summarizeCliTraceText(screenText, 500)
-            });
-            this.ptyProcess.write(this.sendKey);
-            this.submitRetryUsed = true;
-          }, retryDelayMs);
-          startResponseTimeout();
-          return;
-        }
-        if (submitDelayMs > 0) {
-          this.submitPendingUntil = Date.now() + submitDelayMs;
-        }
-        this.ptyProcess.write(text);
-        this.recordTrace("submit_write", {
-          mode: "type_then_submit",
-          text: summarizeCliTraceText(text, 500),
-          sendKey: this.sendKey,
-          screenText: summarizeCliTraceText(this.terminalScreen.getText(), 500)
-        });
-        const submitStartedAt = Date.now();
-        let lastNormalizedScreen = "";
-        let lastScreenChangeAt = submitStartedAt;
-        const waitForEchoAndSubmit = () => {
-          if (!this.ptyProcess) return;
-          const now = Date.now();
-          const elapsed = now - submitStartedAt;
-          const screenText = this.terminalScreen.getText();
-          const normalizedScreen = normalizePromptText(screenText);
-          if (normalizedScreen !== lastNormalizedScreen) {
-            lastNormalizedScreen = normalizedScreen;
-            lastScreenChangeAt = now;
-          }
-          const echoVisible = !normalizedPromptSnippet || promptLikelyVisible(screenText, normalizedPromptSnippet);
-          if (echoVisible) {
-            const screenSettled = now - lastScreenChangeAt >= 500;
-            if (elapsed >= submitDelayMs && screenSettled) {
+            const normalizedScreen = normalizePromptText(screenText);
+            if (normalizedScreen !== lastNormalizedScreen) {
+              lastNormalizedScreen = normalizedScreen;
+              lastScreenChangeAt = now;
+            }
+            const echoVisible = !normalizedPromptSnippet || promptLikelyVisible(screenText, normalizedPromptSnippet);
+            if (echoVisible) {
+              const screenSettled = now - lastScreenChangeAt >= 500;
+              if (elapsed >= submitDelayMs && screenSettled) {
+                submit();
+                return;
+              }
+            }
+            if (elapsed >= maxEchoWaitMs) {
               submit();
               return;
             }
-          }
-          if (elapsed >= maxEchoWaitMs) {
-            submit();
-            return;
-          }
-          setTimeout(waitForEchoAndSubmit, 50);
-        };
-        waitForEchoAndSubmit();
+            setTimeout(waitForEchoAndSubmit, 50);
+          };
+          waitForEchoAndSubmit();
+        });
       }
       getPartialResponse() {
         if (!this.isWaitingForResponse) return "";
@@ -33216,6 +33240,7 @@ var init_reporter = __esm({
       lastStatusSentAt = 0;
       statusPendingThrottle = false;
       lastP2PStatusHash = "";
+      lastServerStatusHash = "";
       lastStatusSummary = "";
       statusTimer = null;
       p2pTimer = null;
@@ -33226,11 +33251,11 @@ var init_reporter = __esm({
       // ─── Lifecycle ───────────────────────────────────
       startReporting() {
         setTimeout(() => {
-          this.sendUnifiedStatusReport().catch((e) => LOG.warn("Status", `Initial report failed: ${e?.message}`));
+          this.sendUnifiedStatusReport({ forceServer: true, reason: "initial" }).catch((e) => LOG.warn("Status", `Initial report failed: ${e?.message}`));
         }, 2e3);
         const scheduleServerReport = () => {
           this.statusTimer = setTimeout(() => {
-            this.sendUnifiedStatusReport().catch((e) => LOG.warn("Status", `Periodic report failed: ${e?.message}`));
+            this.sendUnifiedStatusReport({ forceServer: true, reason: "periodic" }).catch((e) => LOG.warn("Status", `Periodic report failed: ${e?.message}`));
             scheduleServerReport();
           }, 3e4);
         };
@@ -33377,24 +33402,24 @@ var init_reporter = __esm({
             cdpConnected: session.cdpConnected,
             currentModel: session.currentModel,
             currentPlan: session.currentPlan,
-            currentAutoApprove: session.currentAutoApprove,
-            lastUpdated: session.lastUpdated,
-            unread: session.unread,
-            lastSeenAt: session.lastSeenAt,
-            inboxBucket: session.inboxBucket,
-            surfaceHidden: session.surfaceHidden,
-            controlValues: session.controlValues,
-            providerControls: session.providerControls,
-            acpConfigOptions: session.acpConfigOptions,
-            acpModes: session.acpModes
+            currentAutoApprove: session.currentAutoApprove
           })),
           p2p: payload.p2p,
           timestamp: now,
           detectedIdes: payload.detectedIdes,
           availableProviders: payload.availableProviders
         };
+        const wsHash = this.simpleHash(JSON.stringify({
+          ...wsPayload,
+          timestamp: void 0
+        }));
+        if (!opts?.forceServer && wsHash === this.lastServerStatusHash) {
+          LOG.debug("Server", `skip duplicate status_report${opts?.reason ? ` (${opts.reason})` : ""}`);
+          return;
+        }
+        this.lastServerStatusHash = wsHash;
         serverConn.sendMessage("status_report", wsPayload);
-        LOG.debug("Server", `sent status_report (${JSON.stringify(wsPayload).length} bytes)`);
+        LOG.debug("Server", `sent status_report (${JSON.stringify(wsPayload).length} bytes)${opts?.reason ? ` [${opts.reason}]` : ""}`);
       }
       // ─── P2P ─────────────────────────────────────────
       sendP2PPayload(payload) {
@@ -40990,6 +41015,7 @@ var init_server_connection = __esm({
       reconnectTimer = null;
       pingTimer = null;
       pongTimeout = null;
+      missedPongCount = 0;
       messageHandlers = /* @__PURE__ */ new Map();
       stateChangeCallbacks = [];
       /** Fallback handler for message types without specific on() registration */
@@ -41088,6 +41114,7 @@ var init_server_connection = __esm({
       // --- Private ---
       onOpen() {
         LOG.info("Server", `[ServerConn] WebSocket open, sending auth...`);
+        this.missedPongCount = 0;
         this.setState("authenticating");
         this.send({
           type: "auth",
@@ -41100,12 +41127,15 @@ var init_server_connection = __esm({
       }
       onMessage(text) {
         try {
+          this.clearPongTimeout();
+          this.missedPongCount = 0;
           const message = JSON.parse(text);
           if (message.type === "auth_ok") {
             this.reconnectAttempts = 0;
-            this.userPlan = message.payload.plan || "free";
-            this.iceServers = message.payload.iceServers || null;
-            this.planLimits = message.payload.limits || null;
+            const payload = message.payload;
+            this.userPlan = payload.plan || "free";
+            this.iceServers = payload.iceServers || null;
+            this.planLimits = payload.limits || null;
             if (this.iceServers?.length) {
               const hasTurn = this.iceServers.some((s) => JSON.stringify(s.urls || "").includes("turn"));
               LOG.info("Server", `[ServerConn] ICE servers: ${this.iceServers.length} (TURN: ${hasTurn ? "\u2705" : "\u274C STUN only"})`);
@@ -41199,6 +41229,7 @@ var init_server_connection = __esm({
           this.reconnectTimer = null;
         }
         this.stopHeartbeat();
+        this.missedPongCount = 0;
       }
       // ─── WS Heartbeat (ping/pong) ─────────────────────
       startHeartbeat() {
@@ -41208,9 +41239,14 @@ var init_server_connection = __esm({
           try {
             this.ws.ping();
             this.pongTimeout = setTimeout(() => {
-              LOG.info("Server", "[ServerConn] \u26A0 Pong timeout (15s) \u2014 closing zombie WS");
-              if (this.ws) {
+              this.pongTimeout = null;
+              this.missedPongCount += 1;
+              const misses = this.missedPongCount;
+              if (misses >= 3 && this.ws) {
+                LOG.warn("Server", `[ServerConn] Pong timeout (${misses}x) \u2014 closing stale WS`);
                 this.ws.terminate();
+              } else {
+                LOG.warn("Server", `[ServerConn] Pong timeout (${misses}x) \u2014 keeping WS open and retrying`);
               }
             }, 15e3);
           } catch {
@@ -41222,12 +41258,13 @@ var init_server_connection = __esm({
           clearInterval(this.pingTimer);
           this.pingTimer = null;
         }
-        if (this.pongTimeout) {
-          clearTimeout(this.pongTimeout);
-          this.pongTimeout = null;
-        }
+        this.clearPongTimeout();
       }
       onPong() {
+        this.clearPongTimeout();
+        this.missedPongCount = 0;
+      }
+      clearPongTimeout() {
         if (this.pongTimeout) {
           clearTimeout(this.pongTimeout);
           this.pongTimeout = null;
@@ -41577,8 +41614,14 @@ async function initiateConnection(deps, peerId, sharePermission) {
   }
   const pid = peerId || `legacy_${Date.now()}`;
   const existing = deps.peers.get(pid);
-  if (existing?.state === "connected") return;
-  if (existing?.state === "connecting") disconnectPeer(deps.peers, pid, deps.notifyStateChange);
+  if (existing?.state === "connected") {
+    log(`initiateconnection() ignored for peer ${pid} \u2014 already connected`);
+    return;
+  }
+  if (existing?.state === "connecting") {
+    log(`initiateconnection() ignored for peer ${pid} \u2014 connection already in progress`);
+    return;
+  }
   log(`initiateconnection() for peer ${pid}...`);
   const mod = deps.nodeDatachannel;
   const PeerConnectionCtor = mod.PeerConnection || mod.default?.PeerConnection || mod.default || mod;
@@ -41878,6 +41921,7 @@ var init_daemon_p2p = __esm({
       peers = /* @__PURE__ */ new Map();
       nodeDatachannel = null;
       stateListeners = [];
+      lastNotifiedState = null;
       screenshotSender = new ScreenshotSender();
       // Handler storage — exposed to router via DataChannelHandlers interface
       handlers = {
@@ -42015,6 +42059,8 @@ ${e?.stack || ""}`);
       }
       notifyStateChange = () => {
         const state = this.connectionState;
+        if (state === this.lastNotifiedState) return;
+        this.lastNotifiedState = state;
         this.stateListeners.forEach((fn) => fn(state));
       };
       get connectionManagerDeps() {
@@ -42042,6 +42088,7 @@ ${e?.stack || ""}`);
         for (const peerId of Array.from(this.peers.keys())) {
           this.disconnectPeer(peerId);
         }
+        this.lastNotifiedState = null;
       }
       // ─── Delegated data sending ─────────────────────
       sendStatus(status) {
@@ -49352,7 +49399,7 @@ var init_adhdev_daemon = __esm({
     import_ws3 = require("ws");
     import_chalk2 = __toESM(require("chalk"));
     init_version();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.8.33" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.8.35" });
     AdhdevDaemon = class {
       localHttpServer = null;
       localWss = null;
@@ -49530,10 +49577,10 @@ ${err?.stack || ""}`);
               if (state === "connected") {
                 LOG.info("P2P", "Peer connected \u2192 sending immediate full status report");
                 this.statusReporter?.resetP2PHash();
-                this.statusReporter?.sendUnifiedStatusReport().catch((e) => LOG.warn("P2P", `Immediate status report failed: ${e?.message}`));
+                this.statusReporter?.sendUnifiedStatusReport({ reason: "p2p-connect" }).catch((e) => LOG.warn("P2P", `Immediate status report failed: ${e?.message}`));
                 setTimeout(() => {
                   this.statusReporter?.resetP2PHash();
-                  this.statusReporter?.sendUnifiedStatusReport().catch(() => {
+                  this.statusReporter?.sendUnifiedStatusReport({ reason: "p2p-connect-followup" }).catch(() => {
                   });
                 }, 2e3);
               }
@@ -49572,7 +49619,7 @@ ${err?.stack || ""}`);
           this.serverConn.onStateChange((state) => {
             if (state === "connected") {
               console.log(import_chalk2.default.green("  \u{1F4E1} Connected to ADHDev server"));
-              this.statusReporter?.sendUnifiedStatusReport();
+              this.statusReporter?.sendUnifiedStatusReport({ forceServer: true, reason: "ws-connected" });
             } else if (state === "disconnected") {
               console.log(import_chalk2.default.yellow("  \u26A0 Server disconnected, will reconnect..."));
             }
@@ -51616,6 +51663,51 @@ function registerSetupCommands(program2, providerLoader) {
     console.log(import_chalk4.default.gray("  Auth credentials cleared. IDE and workspace settings preserved."));
     console.log(import_chalk4.default.gray("  Run `adhdev setup` to log in again.\n"));
   });
+  program2.command("uninstall").description("Completely wipe all setting, configuration, stop daemon and uninstall service").option("-f, --force", "Skip confirmation prompt").action(async (options) => {
+    const inquirer2 = await import("inquirer");
+    const fs20 = await import("fs");
+    const path29 = await import("path");
+    const os26 = await import("os");
+    const { spawnSync: spawnSync2 } = await import("child_process");
+    if (!options.force) {
+      const { confirm } = await inquirer2.default.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: "Are you sure you want to completely wipe ADHDev settings, uninstall the daemon service, and remove all downloaded data? This cannot be undone.",
+          default: false
+        }
+      ]);
+      if (!confirm) return;
+    }
+    console.log(import_chalk4.default.bold("\n\u{1F5D1}\uFE0F  Uninstalling ADHDev\n"));
+    try {
+      const { isDaemonRunning: isDaemonRunning2, stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_adhdev_daemon(), adhdev_daemon_exports));
+      if (isDaemonRunning2()) {
+        console.log(import_chalk4.default.gray("  Stopping daemon..."));
+        stopDaemon2();
+        console.log(import_chalk4.default.green("  \u2713 Daemon stopped."));
+      }
+    } catch {
+    }
+    console.log(import_chalk4.default.gray("  Removing OS background service..."));
+    spawnSync2(process.execPath, [process.argv[1], "service", "uninstall"], { stdio: "inherit" });
+    const adhdevDir = path29.join(os26.homedir(), ".adhdev");
+    if (fs20.existsSync(adhdevDir)) {
+      console.log(import_chalk4.default.gray(`  Deleting ${adhdevDir}...`));
+      try {
+        fs20.rmSync(adhdevDir, { recursive: true, force: true });
+        console.log(import_chalk4.default.green("  \u2713 Data wiped."));
+      } catch (e) {
+        console.log(import_chalk4.default.red(`  \u2717 Failed to delete ~/.adhdev: ${e.message}`));
+      }
+    } else {
+      console.log(import_chalk4.default.green("  \u2713 ~/.adhdev not found or already deleted."));
+    }
+    console.log(import_chalk4.default.green("\n\u2713 Uninstall complete."));
+    console.log(import_chalk4.default.whiteBright("  To finish uninstalling the CLI tool, please run:"));
+    console.log(import_chalk4.default.cyan("  npm uninstall -g adhdev\n"));
+  });
 }
 
 // src/cli/daemon-commands.ts
@@ -52158,6 +52250,36 @@ function probeNodeDatachannel(packageRoot) {
     };
   }
 }
+function probeSharpRuntime(packageRoot, nativeSharpPackage) {
+  const resolved = resolveModuleFromPackage("sharp", packageRoot);
+  if (!resolved) {
+    return {
+      label: "sharp",
+      ok: false,
+      detail: "module not found",
+      fatal: false
+    };
+  }
+  try {
+    const sharp = require(resolved);
+    const nativeResolved = resolveModuleFromPackage(nativeSharpPackage, packageRoot);
+    const runtimeVersion = sharp?.versions?.sharp || sharp?.version || "unknown";
+    const nativeDetail = nativeResolved ? `${nativeSharpPackage} resolved` : `${nativeSharpPackage} not separately resolvable`;
+    return {
+      label: "sharp",
+      ok: typeof sharp === "function" || typeof sharp?.default === "function",
+      detail: `${resolved} (runtime=${runtimeVersion}; ${nativeDetail})`,
+      fatal: false
+    };
+  } catch (error48) {
+    return {
+      label: "sharp",
+      ok: false,
+      detail: `${resolved} (${error48?.message || "load failed"})`,
+      fatal: false
+    };
+  }
+}
 function probeConfigAccess() {
   const configDir = path27.join(os24.homedir(), ".adhdev");
   const configPath = path27.join(configDir, "config.json");
@@ -52306,18 +52428,7 @@ function registerDoctorCommands(program2, pkgVersion3) {
         fatal: true
       },
       probeNodeDatachannel(packageRoot),
-      {
-        label: "sharp",
-        ok: Boolean(resolveModuleFromPackage("sharp", packageRoot)),
-        detail: resolveModuleFromPackage("sharp", packageRoot) || "module not found",
-        fatal: false
-      },
-      {
-        label: nativeSharpPackage,
-        ok: Boolean(resolveModuleFromPackage(nativeSharpPackage, packageRoot)),
-        detail: resolveModuleFromPackage(nativeSharpPackage, packageRoot) || "module not found",
-        fatal: false
-      },
+      probeSharpRuntime(packageRoot, nativeSharpPackage),
       ...probeConfigAccess(),
       ...buildBrowseProbeChecks()
     ];
@@ -52332,7 +52443,7 @@ function registerDoctorCommands(program2, pkgVersion3) {
       checks.push({
         label: "Session host IPC",
         ok: probe.reachable,
-        detail: probe.reachable ? `reachable (${probe.runtimeCount} runtime(s), ${probe.endpoint.kind}:${probe.endpoint.path})` : `unreachable (${probe.endpoint.kind}:${probe.endpoint.path})`
+        detail: probe.reachable ? `reachable (${probe.runtimeCount} runtime(s), ${probe.endpoint.kind}:${probe.endpoint.path})` : `${sessionHostPid ? "unreachable (stale PID or lazy host)" : "unreachable (host not running)"} (${probe.endpoint.kind}:${probe.endpoint.path})`
       });
     } catch (e) {
       checks.push({