adhdev 0.9.32 → 0.9.34

package/dist/cli/index.js

@@ -7981,6 +7981,26 @@ function toHistoryPersistedMessages(messages) {
     historyDedupKey: deriveHistoryDedupKey(message)
   }));
 }
+function findLastMessageIndexBySignature(messages, signature) {
+  if (!signature) return -1;
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    if (getChatMessageSignature(messages[index]) === signature) {
+      return index;
+    }
+  }
+  return -1;
+}
+function buildBoundedTailSync(messages, cursor) {
+  const totalMessages = messages.length;
+  const tailMessages = cursor.tailLimit > 0 && totalMessages > cursor.tailLimit ? messages.slice(-cursor.tailLimit) : messages;
+  return {
+    syncMode: "full",
+    replaceFrom: 0,
+    messages: tailMessages,
+    totalMessages,
+    lastMessageSignature: getChatMessageSignature(messages[totalMessages - 1])
+  };
+}
 function computeReadChatSync(messages, cursor) {
   const totalMessages = messages.length;
   const lastMessageSignature = getChatMessageSignature(messages[totalMessages - 1]);
@@ -8012,6 +8032,15 @@ function computeReadChatSync(messages, cursor) {
       lastMessageSignature
     };
   }
+  if (cursor.tailLimit > 0 && knownSignature === lastMessageSignature) {
+    return {
+      syncMode: "noop",
+      replaceFrom: totalMessages,
+      messages: [],
+      totalMessages,
+      lastMessageSignature
+    };
+  }
   if (knownMessageCount < totalMessages) {
     const anchorSignature = getChatMessageSignature(messages[knownMessageCount - 1]);
     if (anchorSignature === knownSignature) {
@@ -8023,6 +8052,19 @@ function computeReadChatSync(messages, cursor) {
         lastMessageSignature
       };
     }
+    if (cursor.tailLimit > 0) {
+      const signatureIndex = findLastMessageIndexBySignature(messages, knownSignature);
+      if (signatureIndex >= 0) {
+        return {
+          syncMode: "append",
+          replaceFrom: knownMessageCount,
+          messages: messages.slice(signatureIndex + 1),
+          totalMessages,
+          lastMessageSignature
+        };
+      }
+      return buildBoundedTailSync(messages, cursor);
+    }
   }
   const replaceFrom = Math.max(0, Math.min(knownMessageCount - 1, totalMessages));
   return {
@@ -12327,13 +12369,14 @@ function sliceFromOffset(text, start) {
 function hydrateCliParsedMessages(parsedMessages, options) {
   const { committedMessages, scope, lastOutputAt } = options;
   const referenceMessages = [...committedMessages];
+  const referenceComparables = referenceMessages.map((message) => normalizeComparableMessageContent(message?.content || ""));
   const usedReferenceIndexes = /* @__PURE__ */ new Set();
   const now = options.now ?? Date.now();
   const findReferenceTimestamp = (role, content, parsedIndex) => {
     const normalizedContent = normalizeComparableMessageContent(content);
     if (!normalizedContent) return void 0;
     const sameIndex = referenceMessages[parsedIndex];
-    if (sameIndex && !usedReferenceIndexes.has(parsedIndex) && sameIndex.role === role && normalizeComparableMessageContent(sameIndex.content) === normalizedContent && typeof sameIndex.timestamp === "number" && Number.isFinite(sameIndex.timestamp)) {
+    if (sameIndex && !usedReferenceIndexes.has(parsedIndex) && sameIndex.role === role && referenceComparables[parsedIndex] === normalizedContent && typeof sameIndex.timestamp === "number" && Number.isFinite(sameIndex.timestamp)) {
       usedReferenceIndexes.add(parsedIndex);
       return sameIndex.timestamp;
     }
@@ -12341,7 +12384,7 @@ function hydrateCliParsedMessages(parsedMessages, options) {
       if (usedReferenceIndexes.has(i)) continue;
       const candidate = referenceMessages[i];
       if (!candidate || candidate.role !== role) continue;
-      const candidateContent = normalizeComparableMessageContent(candidate.content);
+      const candidateContent = referenceComparables[i];
       if (!candidateContent) continue;
       const exactMatch = candidateContent === normalizedContent;
       const fuzzyMatch = candidateContent.includes(normalizedContent) || normalizedContent.includes(candidateContent);
@@ -13433,7 +13476,7 @@ var init_provider_cli_adapter = __esm({
           return;
         }
         if (this.currentTurnScope && !lastParsedAssistant) {
-          LOG.info(
+          LOG.debug(
             "CLI",
             `[${this.cliType}] Settled without assistant: prompt=${JSON.stringify(this.currentTurnScope.prompt).slice(0, 140)} responseBuffer=${JSON.stringify(summarizeCliTraceText(this.responseBuffer, 220)).slice(0, 260)} screen=${JSON.stringify(summarizeCliTraceText(screenText, 220)).slice(0, 260)} providerDir=${this.providerResolutionMeta.providerDir || "-"} scriptDir=${this.providerResolutionMeta.scriptDir || "-"}`
           );
@@ -14249,9 +14292,43 @@ var init_provider_cli_adapter = __esm({
       }
       armResponseTimeout() {
         if (this.responseTimeout) clearTimeout(this.responseTimeout);
+        const timeoutMs = this.timeouts.maxResponse;
+        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+          this.responseTimeout = null;
+          return;
+        }
         this.responseTimeout = setTimeout(() => {
-          if (this.isWaitingForResponse) this.finishResponse();
-        }, this.timeouts.maxResponse);
+          this.responseTimeout = null;
+          if (!this.isWaitingForResponse) return;
+          const detectedStatusBeforeEval = this.runDetectStatus(this.recentOutputBuffer);
+          this.recordTrace("response_timeout_check", {
+            timeoutMs,
+            detectedStatus: detectedStatusBeforeEval,
+            currentStatus: this.currentStatus,
+            isWaitingForResponse: this.isWaitingForResponse,
+            hasActionableApproval: this.hasActionableApproval(),
+            ...buildCliTraceParseSnapshot({
+              accumulatedBuffer: this.accumulatedBuffer,
+              accumulatedRawBuffer: this.accumulatedRawBuffer,
+              responseBuffer: this.responseBuffer,
+              partialResponse: this.responseBuffer,
+              scope: this.currentTurnScope
+            })
+          });
+          this.settledBuffer = this.recentOutputBuffer;
+          this.evaluateSettled();
+          if (this.isWaitingForResponse && !this.hasActionableApproval()) {
+            const detectedStatusAfterEval = this.runDetectStatus(this.recentOutputBuffer);
+            this.recordTrace("response_timeout_kept_open", {
+              timeoutMs,
+              detectedStatusBeforeEval,
+              detectedStatusAfterEval,
+              currentStatus: this.currentStatus,
+              isWaitingForResponse: this.isWaitingForResponse
+            });
+            this.armResponseTimeout();
+          }
+        }, timeoutMs);
       }
       writeSubmitKeyForRetry(mode) {
         void this.writeToPty(this.sendKey).catch((error48) => {
@@ -15142,6 +15219,20 @@ var init_cli_provider_instance = __esm({
       getPresentationMode() {
         return this.presentationMode;
       }
+      getHotChatSessionState() {
+        const adapterStatus = this.adapter.getStatus();
+        const autoApproveActive = adapterStatus.status === "waiting_approval" && this.shouldAutoApprove();
+        const visibleStatus = autoApproveActive ? "generating" : adapterStatus.status;
+        const runtime = this.adapter.getRuntimeMetadata();
+        return {
+          id: this.instanceId,
+          status: visibleStatus,
+          runtimeLifecycle: runtime?.lifecycle ?? null,
+          runtimeSurfaceKind: runtime?.surfaceKind,
+          runtimeRestoredFromStorage: runtime?.restoredFromStorage === true,
+          runtimeRecoveryState: runtime?.recoveryState ?? null
+        };
+      }
       updateSettings(newSettings) {
         this.settings = { ...newSettings };
         this.adapter.updateRuntimeSettings?.(this.settings);
@@ -15297,6 +15388,15 @@ var init_cli_provider_instance = __esm({
               this.completedDebouncePending = { chatTitle, duration: duration3, timestamp: now };
               this.completedDebounceTimer = setTimeout(() => {
                 if (this.completedDebouncePending) {
+                  const latestStatus = this.adapter.getStatus();
+                  const latestAutoApproveActive = latestStatus.status === "waiting_approval" && this.shouldAutoApprove();
+                  const latestVisibleStatus = latestAutoApproveActive ? "generating" : latestStatus.status;
+                  if (latestVisibleStatus !== "idle") {
+                    LOG.info("CLI", `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
+                    this.completedDebouncePending = null;
+                    this.completedDebounceTimer = null;
+                    return;
+                  }
                   LOG.info("CLI", `[${this.type}] completed in ${this.completedDebouncePending.duration}s`);
                   this.pushEvent({ event: "agent:generating_completed", ...this.completedDebouncePending });
                   this.completedDebouncePending = null;
@@ -36425,10 +36525,22 @@ var init_provider_loader = __esm({
       setMachineProviderEnabled(type, enabled) {
         return this.setMachineProviderConfig(type, { enabled });
       }
+      getEffectiveProviderAvailability(type) {
+        const providerType = this.resolveAlias(type);
+        const availability = this.providerAvailability.get(providerType);
+        if (availability) return availability;
+        const machineConfig = this.getMachineProviderConfig(providerType);
+        const lastDetection = machineConfig.lastDetection;
+        if (!lastDetection) return void 0;
+        return {
+          installed: lastDetection.ok === true,
+          detectedPath: typeof lastDetection.path === "string" && lastDetection.path.trim() ? lastDetection.path.trim() : null
+        };
+      }
       getMachineProviderStatus(type) {
         const providerType = this.resolveAlias(type);
         if (!this.isMachineProviderEnabled(providerType)) return "disabled";
-        const availability = this.providerAvailability.get(providerType);
+        const availability = this.getEffectiveProviderAvailability(providerType);
         if (!availability) return "enabled_unchecked";
         return availability.installed ? "detected" : "not_detected";
       }
@@ -36556,7 +36668,7 @@ var init_provider_loader = __esm({
       }
       getAvailableProviderInfos() {
         return this.getAll().map((provider) => {
-          const availability = this.providerAvailability.get(provider.type);
+          const availability = this.getEffectiveProviderAvailability(provider.type);
           const enabled = this.isMachineProviderEnabled(provider.type);
           const machineConfig = this.getMachineProviderConfig(provider.type);
           return {
@@ -38404,6 +38516,51 @@ function killPid(pid) {
     return false;
   }
 }
+function getWindowsProcessCommandLine(pid) {
+  const pidFilter = `ProcessId=${pid}`;
+  try {
+    const psOut = (0, import_child_process8.execFileSync)("powershell.exe", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-Command",
+      `(Get-CimInstance Win32_Process -Filter "${pidFilter}").CommandLine`
+    ], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }).trim();
+    if (psOut) return psOut;
+  } catch {
+  }
+  try {
+    const wmicOut = (0, import_child_process8.execFileSync)("wmic", [
+      "process",
+      "where",
+      pidFilter,
+      "get",
+      "CommandLine"
+    ], { encoding: "utf8", timeout: 3e3, stdio: ["ignore", "pipe", "ignore"] }).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 = (0, import_child_process8.execFileSync)("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) {
@@ -38420,7 +38577,7 @@ function stopSessionHostProcesses(appName) {
   try {
     if (fs8.existsSync(pidFile)) {
       const pid = Number.parseInt(fs8.readFileSync(pidFile, "utf8").trim(), 10);
-      if (Number.isFinite(pid)) {
+      if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid(pid)) {
         killPid(pid);
       }
     }
@@ -38431,18 +38588,6 @@ function stopSessionHostProcesses(appName) {
     } catch {
     }
   }
-  if (process.platform !== "win32") {
-    try {
-      const raw = (0, import_child_process8.execFileSync)("pgrep", ["-f", "session-host-daemon"], { encoding: "utf8" }).trim();
-      for (const line of raw.split("\n")) {
-        const pid = Number.parseInt(line.trim(), 10);
-        if (Number.isFinite(pid)) {
-          killPid(pid);
-        }
-      }
-    } catch {
-    }
-  }
 }
 function removeDaemonPidFile() {
   const pidFile = path17.join(os20.homedir(), ".adhdev", "daemon.pid");
@@ -40784,6 +40929,20 @@ var init_forward = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/providers/provider-instance-manager.ts
+function projectHotChatSessionStatesFromProviderState(state) {
+  const project = (item) => ({
+    id: item.instanceId,
+    status: item.activeChat?.status || item.status,
+    runtimeLifecycle: item.runtime?.lifecycle ?? null,
+    runtimeSurfaceKind: item.runtime?.surfaceKind,
+    runtimeRestoredFromStorage: item.runtime?.restoredFromStorage === true,
+    runtimeRecoveryState: item.runtime?.recoveryState ?? null
+  });
+  if (state.category === "ide") {
+    return [project(state), ...state.extensions.map(project)];
+  }
+  return [project(state)];
+}
 var ProviderInstanceManager;
 var init_provider_instance_manager = __esm({
   "../../oss/packages/daemon-core/src/providers/provider-instance-manager.ts"() {
@@ -40884,6 +41043,27 @@ var init_provider_instance_manager = __esm({
         }
         return states;
       }
+      collectHotChatSessionStates() {
+        const sessions = [];
+        for (const [id, instance] of this.instances) {
+          try {
+            const projected = instance.getHotChatSessionState?.();
+            if (Array.isArray(projected)) {
+              sessions.push(...projected.filter((session) => !!session?.id));
+              continue;
+            }
+            if (projected?.id) {
+              sessions.push(projected);
+              continue;
+            }
+            const state = instance.getState();
+            sessions.push(...projectHotChatSessionStatesFromProviderState(state));
+          } catch (e) {
+            LOG.warn("InstanceMgr", `[InstanceManager] Failed to collect hot chat metadata from ${id}: ${e.message}`);
+          }
+        }
+        return sessions;
+      }
       /**
       * Per-category status collect
       */
@@ -79624,19 +79804,20 @@ var init_screenshot_sender = __esm({
         }
         return sentAny;
       }
-      sendScreenshot(peers, base64Data) {
+      sendScreenshot(peers, base64Data, targetSessionId) {
         const buffer = Buffer.from(base64Data, "base64");
-        return this.sendScreenshotBuffer(peers, buffer);
+        return this.sendScreenshotBuffer(peers, buffer, targetSessionId);
       }
       /** Send screenshot as raw Buffer (no base64 conversion overhead) */
-      sendScreenshotBuffer(peers, buffer) {
+      sendScreenshotBuffer(peers, buffer, targetSessionId) {
         let sentAny = false;
         let debugOnce = !this._ssDebugDone;
         for (const [pid, peer] of peers.entries()) {
           if (debugOnce) {
-            logDebug(`sendScreenshot peer=${pid}: state=${peer.state}, hasCh=${!!peer.dataChannel}, ssActive=${peer.screenshotActive}, chOpen=${peer.dataChannel?.isOpen?.() ?? "N/A"}, bufSize=${buffer.length}`);
+            logDebug(`sendScreenshot peer=${pid}: state=${peer.state}, hasCh=${!!peer.dataChannel}, ssActive=${peer.screenshotActive}, target=${peer.screenshotTargetSessionId || "none"}, chOpen=${peer.dataChannel?.isOpen?.() ?? "N/A"}, bufSize=${buffer.length}`);
           }
           if (peer.state !== "connected" || !peer.dataChannel || !peer.screenshotActive) continue;
+          if (targetSessionId && peer.screenshotTargetSessionId !== targetSessionId) continue;
           try {
             if (!peer.dataChannel.isOpen()) continue;
             const header = Buffer.alloc(4);
@@ -79668,18 +79849,32 @@ async function initiateConnection(deps, peerId, sharePermission) {
     log("Cannot initiate \u2014 node-datachannel not available");
     return;
   }
+  const pid = peerId || `legacy_${Date.now()}`;
+  const existing = deps.peers.get(pid);
+  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;
+  }
   const limits = deps.serverConn.getPlanLimits();
   if (limits && limits.maxP2PConnections !== -1) {
     let connectedCount = 0;
+    let reservedCount = 0;
     for (const peer of deps.peers.values()) {
       if (peer.state === "connected") connectedCount++;
+      if (peer.state === "connected" || peer.state === "connecting") reservedCount++;
     }
-    if (connectedCount >= limits.maxP2PConnections) {
+    if (reservedCount >= limits.maxP2PConnections) {
       let oldestPeer = null;
-      for (const [pid2, peer] of deps.peers) {
-        if (peer.state === "connected") {
-          if (!oldestPeer || peer.connectedAt < oldestPeer.at) {
-            oldestPeer = { id: pid2, at: peer.connectedAt };
+      if (connectedCount >= limits.maxP2PConnections) {
+        for (const [peerKey, peer] of deps.peers) {
+          if (peer.state === "connected") {
+            if (!oldestPeer || peer.connectedAt < oldestPeer.at) {
+              oldestPeer = { id: peerKey, at: peer.connectedAt };
+            }
           }
         }
       }
@@ -79697,19 +79892,12 @@ async function initiateConnection(deps, peerId, sharePermission) {
           }
         }
         disconnectPeer(deps.peers, oldestPeer.id, deps.notifyStateChange);
+      } else {
+        log(`P2P limit reached (${reservedCount}/${limits.maxP2PConnections}) with reserved connecting slot(s). Rejecting peer ${pid.slice(0, 12)}\u2026`);
+        return;
       }
     }
   }
-  const pid = peerId || `legacy_${Date.now()}`;
-  const existing = deps.peers.get(pid);
-  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;
@@ -80068,14 +80256,19 @@ var init_daemon_p2p = __esm({
         }
         return false;
       }
-      /** Get the target session for the currently active screenshot request */
-      get screenshotTargetSessionId() {
+      /** Get all target sessions for active screenshot requests */
+      get screenshotTargetSessionIds() {
+        const targets = /* @__PURE__ */ new Set();
         for (const peer of this.peers.values()) {
           if (peer.screenshotActive && peer.state === "connected" && peer.screenshotTargetSessionId) {
-            return peer.screenshotTargetSessionId;
+            targets.add(peer.screenshotTargetSessionId);
           }
         }
-        return void 0;
+        return Array.from(targets);
+      }
+      /** Get the target session for the currently active screenshot request */
+      get screenshotTargetSessionId() {
+        return this.screenshotTargetSessionIds[0];
       }
       constructor(serverConn) {
         this.serverConn = serverConn;
@@ -80184,6 +80377,14 @@ ${e?.stack || ""}`);
         }
         return false;
       }
+      hasAnyNeedingFirstFrameForTarget(targetSessionId) {
+        for (const peer of this.peers.values()) {
+          if (peer.needsFirstFrame && peer.screenshotActive && peer.state === "connected" && peer.screenshotTargetSessionId === targetSessionId) {
+            return true;
+          }
+        }
+        return false;
+      }
       onStateChange(listener) {
         this.stateListeners.push(listener);
       }
@@ -80247,11 +80448,14 @@ ${e?.stack || ""}`);
         if (targetPeers.size === 0) return false;
         return this.screenshotSender.broadcastSessionOutput(targetPeers, sessionId, data);
       }
-      sendScreenshot(base64Data) {
-        return this.screenshotSender.sendScreenshot(this.peers, base64Data);
+      sendScreenshot(base64Data, targetSessionId) {
+        return this.screenshotSender.sendScreenshot(this.peers, base64Data, targetSessionId);
+      }
+      sendScreenshotBuffer(buffer, targetSessionId) {
+        return this.screenshotSender.sendScreenshotBuffer(this.peers, buffer, targetSessionId);
       }
-      sendScreenshotBuffer(buffer) {
-        return this.screenshotSender.sendScreenshotBuffer(this.peers, buffer);
+      sendScreenshotBufferForTarget(targetSessionId, buffer) {
+        return this.sendScreenshotBuffer(buffer, targetSessionId);
       }
       // ─── Handler registration (unchanged API) ───────
       onFileRequest(handler) {
@@ -86975,6 +87179,7 @@ var init_screenshot_controller = __esm({
       lastSize = 0;
       lastHash = 0;
       staticFrameCount = 0;
+      targetFrameState = /* @__PURE__ */ new Map();
       currentInterval;
       // Quality profiles
       profileDirect;
@@ -87038,14 +87243,13 @@ var init_screenshot_controller = __esm({
       async tick() {
         if (!this.deps.isRunning()) return;
         const active = this.deps.isScreenshotActive();
-        const targetSessionId = this.deps.getScreenshotTargetSessionId();
-        if (active && !targetSessionId) {
+        const targetSessionIds = this.getActiveTargetSessionIds();
+        const isRelay = this.deps.isUsingRelay();
+        const profile = isRelay ? this.profileRelay : this.profileDirect;
+        if (active && targetSessionIds.length === 0) {
           this.timer = setTimeout(() => this.tick(), 500);
           return;
         }
-        const cdp = targetSessionId ? this.deps.getCdp(targetSessionId) : null;
-        const isRelay = this.deps.isUsingRelay();
-        const profile = isRelay ? this.profileRelay : this.profileDirect;
         this.checkBudgetReset();
         if (this.dailyBudgetMs > 0) {
           const now = Date.now();
@@ -87060,49 +87264,84 @@ var init_screenshot_controller = __esm({
           }
         }
         const budgetBlocked = this.budgetExhausted && isRelay;
-        if (!active || !cdp || budgetBlocked) {
+        if (!active || budgetBlocked) {
           this.staticFrameCount = 0;
+          this.targetFrameState.clear();
           this.currentInterval = profile.maxInterval;
           if (!active) this.lastActiveTimestamp = 0;
           this.timer = setTimeout(() => this.tick(), budgetBlocked ? 3e4 : this.currentInterval);
           return;
         }
         this.debugCount++;
-        try {
-          const buf = await cdp.captureScreenshot({ quality: profile.quality });
-          if (buf) {
+        let capturedAny = false;
+        let sentAnyFrame = false;
+        let anyFirstFrameAcrossTargets = false;
+        for (const targetSessionId of targetSessionIds) {
+          const cdp = this.deps.getCdp(targetSessionId);
+          if (!cdp) continue;
+          try {
+            const buf = await cdp.captureScreenshot({ quality: profile.quality });
+            if (!buf) {
+              if (this.debugCount <= 5) LOG.debug("Screenshot", `captureScreenshot returned null for target=${targetSessionId}`);
+              continue;
+            }
+            capturedAny = true;
+            const state = this.getTargetFrameState(targetSessionId);
             const hash2 = _ScreenshotController.fnvHash(buf);
-            const sizeMatch = buf.length === this.lastSize;
-            const hashMatch = hash2 === this.lastHash;
-            const anyNeedsFirstFrame = this.deps.hasAnyNeedingFirstFrame();
+            const sizeMatch = buf.length === state.lastSize;
+            const hashMatch = hash2 === state.lastHash;
+            const anyNeedsFirstFrame = this.deps.hasAnyNeedingFirstFrameForTarget?.(targetSessionId) ?? this.deps.hasAnyNeedingFirstFrame();
             const resizeTarget = anyNeedsFirstFrame ? profile.firstFrameLongEdge : profile.maxLongEdge;
+            anyFirstFrameAcrossTargets = anyFirstFrameAcrossTargets || anyNeedsFirstFrame;
             if (sizeMatch && hashMatch && !anyNeedsFirstFrame) {
-              this.staticFrameCount++;
-              if (this.staticFrameCount >= this.STATIC_THRESHOLD) {
+              state.staticFrameCount++;
+              if (state.staticFrameCount >= this.STATIC_THRESHOLD) {
                 this.currentInterval = Math.min(this.currentInterval + 200, profile.maxInterval);
               }
               if (this.debugCount <= 5 || this.debugCount % 50 === 0) {
-                LOG.debug("Screenshot", `skip (unchanged, static=${this.staticFrameCount}, interval=${this.currentInterval}ms, ${isRelay ? "RELAY" : "DIRECT"})`);
-              }
-            } else {
-              const normalizedBuf = await this.normalizeBuffer(buf, resizeTarget, profile.quality);
-              this.lastSize = buf.length;
-              this.lastHash = hash2;
-              this.staticFrameCount = 0;
-              this.currentInterval = profile.minInterval;
-              const sent = this.deps.sendScreenshotBuffer(normalizedBuf);
-              if (this.debugCount <= 3 || anyNeedsFirstFrame) {
-                LOG.debug("Screenshot", `sent: ${normalizedBuf.length} bytes, delivered=${sent}, interval=${this.currentInterval}ms, ${isRelay ? "RELAY" : "DIRECT"}${anyNeedsFirstFrame ? " (first-frame)" : ""}`);
+                LOG.debug("Screenshot", `skip target=${targetSessionId} (unchanged, static=${state.staticFrameCount}, interval=${this.currentInterval}ms, ${isRelay ? "RELAY" : "DIRECT"})`);
               }
+              continue;
             }
-          } else {
-            if (this.debugCount <= 5) LOG.debug("Screenshot", "captureScreenshot returned null");
+            const normalizedBuf = await this.normalizeBuffer(buf, resizeTarget, profile.quality);
+            state.lastSize = buf.length;
+            state.lastHash = hash2;
+            state.staticFrameCount = 0;
+            this.lastSize = buf.length;
+            this.lastHash = hash2;
+            this.staticFrameCount = 0;
+            this.currentInterval = profile.minInterval;
+            const sent = this.deps.sendScreenshotBufferForTarget ? this.deps.sendScreenshotBufferForTarget(targetSessionId, normalizedBuf) : this.deps.sendScreenshotBuffer(normalizedBuf);
+            sentAnyFrame = sentAnyFrame || sent;
+            if (this.debugCount <= 3 || anyNeedsFirstFrame) {
+              LOG.debug("Screenshot", `sent target=${targetSessionId}: ${normalizedBuf.length} bytes, delivered=${sent}, interval=${this.currentInterval}ms, ${isRelay ? "RELAY" : "DIRECT"}${anyNeedsFirstFrame ? " (first-frame)" : ""}`);
+            }
+          } catch (e) {
+            if (this.debugCount <= 5) LOG.warn("Screenshot", `error target=${targetSessionId}: ${e?.message}`);
           }
-        } catch (e) {
-          if (this.debugCount <= 5) LOG.warn("Screenshot", `error: ${e?.message}`);
+        }
+        if (!capturedAny) {
+          this.currentInterval = profile.maxInterval;
+        } else if (!sentAnyFrame && !anyFirstFrameAcrossTargets) {
+          this.currentInterval = Math.min(this.currentInterval + 200, profile.maxInterval);
         }
         this.timer = setTimeout(() => this.tick(), this.currentInterval);
       }
+      getActiveTargetSessionIds() {
+        const explicitTargets = this.deps.getScreenshotTargetSessionIds?.() || [];
+        const normalized = explicitTargets.map((target) => typeof target === "string" ? target.trim() : "").filter((target) => target.length > 0);
+        if (normalized.length > 0) return Array.from(new Set(normalized));
+        const legacyTarget = this.deps.getScreenshotTargetSessionId();
+        return legacyTarget ? [legacyTarget] : [];
+      }
+      getTargetFrameState(targetSessionId) {
+        let state = this.targetFrameState.get(targetSessionId);
+        if (!state) {
+          state = { lastSize: 0, lastHash: 0, staticFrameCount: 0 };
+          this.targetFrameState.set(targetSessionId, state);
+        }
+        return state;
+      }
       // ─── Budget ───────────────────────────────────
       checkBudgetReset() {
         const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -87319,7 +87558,7 @@ function killPid2(pid) {
     return false;
   }
 }
-function getWindowsProcessCommandLine(pid) {
+function getWindowsProcessCommandLine2(pid) {
   const pidFilter = `ProcessId=${pid}`;
   try {
     const psOut = (0, import_child_process13.execFileSync)("powershell.exe", [
@@ -87348,13 +87587,32 @@ function getWindowsProcessCommandLine(pid) {
   }
   return null;
 }
+function getProcessCommandLine2(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return null;
+  if (process.platform === "win32") return getWindowsProcessCommandLine2(pid);
+  try {
+    const text = (0, import_child_process13.execFileSync)("ps", ["-o", "command=", "-p", String(pid)], {
+      encoding: "utf8",
+      timeout: 3e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return text || null;
+  } catch {
+    return null;
+  }
+}
+function isManagedSessionHostPid2(pid) {
+  const commandLine = getProcessCommandLine2(pid);
+  if (!commandLine) return false;
+  return /session-host-daemon/i.test(commandLine);
+}
 function stopManagedSessionHostProcess() {
   let stopped = false;
   const pidFile = getSessionHostPidFile();
   try {
     if (fs22.existsSync(pidFile)) {
       const pid = Number.parseInt(fs22.readFileSync(pidFile, "utf8").trim(), 10);
-      if (Number.isFinite(pid) && pid !== process.pid) {
+      if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid2(pid)) {
         stopped = killPid2(pid) || stopped;
       }
     }
@@ -87368,40 +87626,7 @@ function stopManagedSessionHostProcess() {
   return stopped;
 }
 function stopSessionHost() {
-  let stopped = stopManagedSessionHostProcess();
-  if (process.platform === "win32") {
-    try {
-      const raw = (0, import_child_process13.execFileSync)("tasklist", ["/FO", "CSV", "/NH", "/FI", "IMAGENAME eq node.exe"], {
-        encoding: "utf8",
-        timeout: 5e3,
-        stdio: ["ignore", "pipe", "ignore"],
-        windowsHide: true
-      }).trim();
-      for (const line of raw.split(/\r?\n/)) {
-        const match = line.match(/^"node\.exe","(\d+)"/i);
-        if (!match) continue;
-        const candidatePid = Number.parseInt(match[1], 10);
-        if (!Number.isFinite(candidatePid) || candidatePid === process.pid) continue;
-        const commandLine = getWindowsProcessCommandLine(candidatePid);
-        if (commandLine?.includes("session-host-daemon")) {
-          stopped = killPid2(candidatePid) || stopped;
-        }
-      }
-    } catch {
-    }
-  } else {
-    try {
-      const raw = (0, import_child_process13.execFileSync)("pgrep", ["-f", "session-host-daemon"], { encoding: "utf8" }).trim();
-      for (const line of raw.split("\n")) {
-        const pid = Number.parseInt(line.trim(), 10);
-        if (Number.isFinite(pid) && pid !== process.pid && pid !== process.ppid) {
-          stopped = killPid2(pid) || stopped;
-        }
-      }
-    } catch {
-    }
-  }
-  return stopped;
+  return stopManagedSessionHostProcess();
 }
 async function ensureSessionHostReady2() {
   const quarantine = quarantineLegacyStandaloneSessions({
@@ -87658,10 +87883,65 @@ var init_session_host_controller = __esm({
 var adhdev_daemon_exports = {};
 __export(adhdev_daemon_exports, {
   AdhdevDaemon: () => AdhdevDaemon,
+  buildMandatoryUpdateInfoFromServerPayload: () => buildMandatoryUpdateInfoFromServerPayload,
+  buildMandatoryUpdateRequiredPayload: () => buildMandatoryUpdateRequiredPayload,
   getDaemonPid: () => getDaemonPid,
   isDaemonRunning: () => isDaemonRunning,
-  stopDaemon: () => stopDaemon
-});
+  stopDaemon: () => stopDaemon,
+  validateMandatoryUpdateTarget: () => validateMandatoryUpdateTarget,
+  verifyPublishedMandatoryUpdateTarget: () => verifyPublishedMandatoryUpdateTarget
+});
+function validateMandatoryUpdateTarget(targetVersion) {
+  if (typeof targetVersion !== "string") return { valid: false, error: "target version is required" };
+  if (targetVersion !== targetVersion.trim()) return { valid: false, error: "target version must not contain whitespace" };
+  const version2 = targetVersion;
+  if (!version2) return { valid: false, error: "target version is required" };
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z]+(?:\.[0-9A-Za-z]+)*)?(?:\+[0-9A-Za-z]+(?:\.[0-9A-Za-z]+)*)?$/.test(version2)) {
+    return { valid: false, error: `invalid semver target: ${version2}` };
+  }
+  return { valid: true };
+}
+function verifyPublishedMandatoryUpdateTarget(packageName, targetVersion, deps = {}) {
+  if (!/^(?:adhdev|@adhdev\/daemon-standalone)$/.test(packageName)) {
+    throw new Error(`invalid mandatory update package: ${packageName}`);
+  }
+  const validation = validateMandatoryUpdateTarget(targetVersion);
+  if (!validation.valid) throw new Error(validation.error || "invalid mandatory update target");
+  const run = deps.execFileSync || import_child_process14.execFileSync;
+  const npmExecutable = deps.npmExecutable || resolveCurrentGlobalInstallSurface({ packageName }).npmExecutable;
+  const published = String(run(npmExecutable, ["view", `${packageName}@${targetVersion}`, "version"], {
+    encoding: "utf-8",
+    timeout: 1e4,
+    stdio: ["pipe", "pipe", "pipe"],
+    ...process.platform === "win32" ? { shell: true, windowsHide: true } : {}
+  })).trim();
+  if (published !== targetVersion) {
+    throw new Error(`Published version mismatch: expected ${targetVersion}, got ${published || "unknown"}`);
+  }
+  return published;
+}
+function buildMandatoryUpdateInfoFromServerPayload(payload, fallbackVersion) {
+  const targetVersion = typeof payload?.latest === "string" && payload.latest ? payload.latest : fallbackVersion;
+  const validation = validateMandatoryUpdateTarget(targetVersion);
+  if (!validation.valid) return { info: null, error: validation.error || targetVersion };
+  return {
+    info: {
+      targetVersion,
+      reason: typeof payload?.reason === "string" && payload.reason.trim() ? payload.reason.trim() : "major_minor_mismatch",
+      minVersion: typeof payload?.minVersion === "string" && payload.minVersion.trim() ? payload.minVersion.trim() : void 0
+    }
+  };
+}
+function buildMandatoryUpdateRequiredPayload(pending, interactionId) {
+  return {
+    error: "A mandatory daemon update is pending. Finish current work and let the daemon update before starting a new session.",
+    code: "DAEMON_UPDATE_REQUIRED",
+    required: true,
+    latest: pending.targetVersion,
+    reason: pending.reason,
+    interactionId
+  };
+}
 function resolveDaemonPort(ref = {}) {
   return Number.isFinite(ref.port) && Number(ref.port) > 0 ? Number(ref.port) : DEFAULT_DAEMON_PORT;
 }
@@ -87688,7 +87968,7 @@ function removeDaemonPid(ref = {}) {
 function isDaemonRunning(ref = {}) {
   const port = resolveDaemonPort(ref);
   try {
-    const { execFileSync: execFileSync6 } = require("child_process");
+    const { execFileSync: execFileSync7 } = require("child_process");
     const probe = `
             const http = require('http');
             const req = http.get('http://127.0.0.1:${port}/health', { timeout: 1500 }, (res) => {
@@ -87698,7 +87978,7 @@ function isDaemonRunning(ref = {}) {
             req.on('error', () => process.stdout.write('0'));
             req.on('timeout', () => { req.destroy(); process.stdout.write('0'); });
         `;
-    const result = execFileSync6(process.execPath, ["-e", probe], {
+    const result = execFileSync7(process.execPath, ["-e", probe], {
       encoding: "utf-8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -87724,9 +88004,9 @@ function isDaemonRunning(ref = {}) {
 function isAdhdevProcess(pid) {
   try {
     if (process.platform === "win32") {
-      const { execFileSync: execFileSync6 } = require("child_process");
+      const { execFileSync: execFileSync7 } = require("child_process");
       try {
-        const psOut = execFileSync6("powershell.exe", [
+        const psOut = execFileSync7("powershell.exe", [
           "-NoProfile",
           "-NonInteractive",
           "-ExecutionPolicy",
@@ -87739,8 +88019,8 @@ function isAdhdevProcess(pid) {
         return true;
       }
     } else {
-      const { execFileSync: execFileSync6 } = require("child_process");
-      const cmdline = execFileSync6("ps", ["-o", "command=", "-p", String(pid)], {
+      const { execFileSync: execFileSync7 } = require("child_process");
+      const cmdline = execFileSync7("ps", ["-o", "command=", "-p", String(pid)], {
         encoding: "utf-8",
         timeout: 2e3,
         stdio: ["ignore", "pipe", "ignore"]
@@ -87754,7 +88034,7 @@ function isAdhdevProcess(pid) {
 function getDaemonHealthPid(ref = {}) {
   const port = resolveDaemonPort(ref);
   try {
-    const { execFileSync: execFileSync6 } = require("child_process");
+    const { execFileSync: execFileSync7 } = require("child_process");
     const probe = `
             const http = require('http');
             const req = http.get('http://127.0.0.1:${port}/health', { timeout: 1500 }, (res) => {
@@ -87772,7 +88052,7 @@ function getDaemonHealthPid(ref = {}) {
             req.on('error', () => {});
             req.on('timeout', () => { req.destroy(); });
         `;
-    const result = execFileSync6(process.execPath, ["-e", probe], {
+    const result = execFileSync7(process.execPath, ["-e", probe], {
       encoding: "utf-8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -87818,7 +88098,7 @@ function stopDaemon(ref = {}) {
     return false;
   }
 }
-var os28, fs23, path29, import_http, import_ws3, pkgVersion, AdhdevDaemon;
+var os28, fs23, path29, import_http, import_child_process14, import_ws3, pkgVersion, AdhdevDaemon;
 var init_adhdev_daemon = __esm({
   "src/adhdev-daemon.ts"() {
     "use strict";
@@ -87834,12 +88114,13 @@ var init_adhdev_daemon = __esm({
     fs23 = __toESM(require("fs"));
     path29 = __toESM(require("path"));
     import_http = require("http");
+    import_child_process14 = require("child_process");
     import_ws3 = require("ws");
     init_source();
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.32" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.34" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -87932,6 +88213,10 @@ var init_adhdev_daemon = __esm({
       getUpgradePackageName() {
         return process.argv[1]?.includes("daemon-standalone") ? "@adhdev/daemon-standalone" : "adhdev";
       }
+      getMandatoryUpdateBlockPayload(cmd, interactionId) {
+        if (!this.pendingMandatoryUpdate || !_AdhdevDaemon.MANDATORY_UPDATE_BLOCKED_COMMANDS.has(cmd)) return null;
+        return buildMandatoryUpdateRequiredPayload(this.pendingMandatoryUpdate, interactionId);
+      }
       hasBlockingSessionsForMandatoryUpdate() {
         if (!this.components) return false;
         const blocking = /* @__PURE__ */ new Set(["generating", "waiting_approval", "starting"]);
@@ -87957,15 +88242,7 @@ var init_adhdev_daemon = __esm({
         const pkgName = this.getUpgradePackageName();
         this.mandatoryUpgradeInFlight = true;
         try {
-          const { execSync: execSync8 } = await import("child_process");
-          const published = execSync8(`npm view ${pkgName}@${pending.targetVersion} version`, {
-            encoding: "utf-8",
-            timeout: 1e4,
-            stdio: ["pipe", "pipe", "pipe"]
-          }).trim();
-          if (published !== pending.targetVersion) {
-            throw new Error(`Published version mismatch: expected ${pending.targetVersion}, got ${published || "unknown"}`);
-          }
+          verifyPublishedMandatoryUpdateTarget(pkgName, pending.targetVersion);
           LOG.warn("Upgrade", `Applying mandatory daemon update (${pending.reason}) \u2192 v${pending.targetVersion}`);
           spawnDetachedDaemonUpgradeHelper({
             packageName: pkgName,
@@ -88067,7 +88344,7 @@ var init_adhdev_daemon = __esm({
         const now = Date.now();
         const cached2 = this.hotChatSnapshotCache;
         const sessions = cached2 && now - cached2.builtAt < _AdhdevDaemon.HOT_CHAT_SNAPSHOT_CACHE_TTL_MS ? cached2.sessions : (() => {
-          const built = this.buildLiveStatusSnapshot().sessions || [];
+          const built = this.components.instanceManager.collectHotChatSessionStates();
           this.hotChatSnapshotCache = { sessions: built, builtAt: now };
           return built;
         })();
@@ -88452,14 +88729,17 @@ ${err?.stack || ""}`);
               isRunning: () => this.running,
               isScreenshotActive: () => this.p2p?.screenshotActive ?? false,
               getScreenshotTargetSessionId: () => this.p2p?.screenshotTargetSessionId,
+              getScreenshotTargetSessionIds: () => this.p2p?.screenshotTargetSessionIds ?? [],
               isUsingRelay: () => this.p2p?.isUsingRelay ?? false,
               hasAnyNeedingFirstFrame: () => this.p2p?.hasAnyNeedingFirstFrame() ?? false,
+              hasAnyNeedingFirstFrameForTarget: (targetSessionId) => this.p2p?.hasAnyNeedingFirstFrameForTarget(targetSessionId) ?? false,
               getCdp: (targetSessionId) => {
                 if (targetSessionId) return this.getCdpFor(targetSessionId);
                 LOG.warn("P2P", "Screenshot requested without targetSessionId \u2014 cannot determine target session. Skipping frame.");
                 return null;
               },
-              sendScreenshotBuffer: (buf) => this.p2p.sendScreenshotBuffer(buf)
+              sendScreenshotBuffer: (buf) => this.p2p.sendScreenshotBuffer(buf),
+              sendScreenshotBufferForTarget: (targetSessionId, buf) => this.p2p.sendScreenshotBufferForTarget(targetSessionId, buf)
             }, planLimits ?? void 0);
             this.screenshotController.start();
             this.p2p.onScreenshotStart(() => this.screenshotController?.triggerImmediate());
@@ -88488,11 +88768,12 @@ ${err?.stack || ""}`);
           });
           this.serverConn.on("force_update_required", (msg) => {
             const payload = msg.payload;
-            this.pendingMandatoryUpdate = {
-              targetVersion: typeof payload.latest === "string" && payload.latest.trim() ? payload.latest.trim() : pkgVersion,
-              reason: typeof payload.reason === "string" && payload.reason.trim() ? payload.reason.trim() : "major_minor_mismatch",
-              minVersion: typeof payload.minVersion === "string" && payload.minVersion.trim() ? payload.minVersion.trim() : void 0
-            };
+            const parsedUpdate = buildMandatoryUpdateInfoFromServerPayload(payload, pkgVersion);
+            if (!parsedUpdate.info) {
+              LOG.error("Upgrade", `Ignoring invalid mandatory daemon update target from server: ${parsedUpdate.error || "unknown"}`);
+              return;
+            }
+            this.pendingMandatoryUpdate = parsedUpdate.info;
             LOG.warn("Upgrade", `Mandatory daemon update required (${this.pendingMandatoryUpdate.reason})`);
             void this.maybeApplyMandatoryUpdate("server-force-update");
           });
@@ -88603,15 +88884,9 @@ ${err?.stack || ""}`);
         const cmdStart = Date.now();
         const source = msg.ipcWs ? "ext" : typeof msg.source === "string" && msg.source.trim() ? msg.source : "ws";
         try {
-          if (this.pendingMandatoryUpdate && _AdhdevDaemon.MANDATORY_UPDATE_BLOCKED_COMMANDS.has(cmd)) {
-            this.sendResult(msg, false, {
-              error: "A mandatory daemon update is pending. Finish current work and let the daemon update before starting a new session.",
-              code: "DAEMON_UPDATE_REQUIRED",
-              required: true,
-              latest: this.pendingMandatoryUpdate.targetVersion,
-              reason: this.pendingMandatoryUpdate.reason,
-              interactionId
-            });
+          const mandatoryUpdateBlock = this.getMandatoryUpdateBlockPayload(cmd, interactionId);
+          if (mandatoryUpdateBlock) {
+            this.sendResult(msg, false, mandatoryUpdateBlock);
             return;
           }
           if (source === "api" && !loadConfig().allowServerApiProxy) {
@@ -88656,6 +88931,10 @@ ${err?.stack || ""}`);
         const interactionId = String(normalizedData._interactionId);
         const cmdStart = Date.now();
         try {
+          const mandatoryUpdateBlock = this.getMandatoryUpdateBlockPayload(cmdType, interactionId);
+          if (mandatoryUpdateBlock) {
+            return { success: false, ...mandatoryUpdateBlock };
+          }
           switch (cmdType) {
             case "get_runtime_snapshot": {
               const sessionId = typeof normalizedData.sessionId === "string" ? normalizedData.sessionId : "";
@@ -88834,8 +89113,22 @@ ${err?.stack || ""}`);
           }));
           return;
         }
+        const normalizedArgs = this.ensureInteractionContext(args);
+        const interactionId = String(normalizedArgs._interactionId);
+        const mandatoryUpdateBlock = this.getMandatoryUpdateBlockPayload(command, interactionId);
+        if (mandatoryUpdateBlock) {
+          ws.send(JSON.stringify({
+            type: "ext:command_result",
+            payload: {
+              requestId,
+              success: false,
+              ...mandatoryUpdateBlock
+            }
+          }));
+          return;
+        }
         try {
-          const result = await this.components.router.execute(command, args, "ipc");
+          const result = await this.components.router.execute(command, normalizedArgs, "ipc");
           ws.send(JSON.stringify({
             type: "ext:command_result",
             payload: {
@@ -89005,9 +89298,9 @@ async function runWizard(options = {}) {
 }
 async function checkForUpdate() {
   try {
-    const { execFileSync: execFileSync6 } = await import("child_process");
+    const { execFileSync: execFileSync7 } = await import("child_process");
     const currentVersion = resolvePackageVersion();
-    const latestVersion = readLatestPublishedCliVersion(execFileSync6);
+    const latestVersion = readLatestPublishedCliVersion(execFileSync7);
     if (!latestVersion) return;
     if (!currentVersion || !latestVersion || currentVersion === latestVersion) return;
     console.log(source_default.yellow(`  Update available: ${currentVersion} \u2192 ${latestVersion}`));
@@ -89024,7 +89317,7 @@ async function checkForUpdate() {
     const spinner = (await Promise.resolve().then(() => (init_ora(), ora_exports))).default("Updating adhdev CLI...").start();
     try {
       const installCommand = buildPinnedGlobalInstallCommand({ packageName: "adhdev", targetVersion: "latest" });
-      execFileSync6(installCommand.command, installCommand.args, {
+      execFileSync7(installCommand.command, installCommand.args, {
         encoding: "utf-8",
         timeout: 6e4,
         stdio: ["pipe", "pipe", "pipe"]
@@ -92319,7 +92612,7 @@ function registerDaemonCommands(program2, pkgVersion3) {
 
 // src/cli/doctor-commands.ts
 init_source();
-var import_child_process14 = require("child_process");
+var import_child_process15 = require("child_process");
 var fs26 = __toESM(require("fs"));
 var os30 = __toESM(require("os"));
 var path33 = __toESM(require("path"));
@@ -92961,7 +93254,7 @@ function findCommandPaths(command) {
   try {
     const bin = process.platform === "win32" ? "where.exe" : "which";
     const args = process.platform === "win32" ? [command] : ["-a", command];
-    const output = (0, import_child_process14.execFileSync)(bin, args, {
+    const output = (0, import_child_process15.execFileSync)(bin, args, {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -92976,7 +93269,7 @@ function probeCliBinary(commandPath, currentVersion) {
     currentVersion
   };
   try {
-    probe.version = (0, import_child_process14.execFileSync)(commandPath, ["--version"], {
+    probe.version = (0, import_child_process15.execFileSync)(commandPath, ["--version"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
@@ -92984,7 +93277,7 @@ function probeCliBinary(commandPath, currentVersion) {
     probe.versionError = error48?.stderr?.toString?.().trim() || error48?.message || "version probe failed";
   }
   try {
-    probe.helpText = (0, import_child_process14.execFileSync)(commandPath, ["--help"], {
+    probe.helpText = (0, import_child_process15.execFileSync)(commandPath, ["--help"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     });