adhdev 0.9.32 → 0.9.34

package/dist/index.js

@@ -7461,6 +7461,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]);
@@ -7492,6 +7512,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) {
@@ -7503,6 +7532,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 {
@@ -11371,13 +11413,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;
     }
@@ -11385,7 +11428,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);
@@ -12477,7 +12520,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 || "-"}`
           );
@@ -13293,9 +13336,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) => {
@@ -14186,6 +14263,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);
@@ -14341,6 +14432,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;
@@ -35469,10 +35569,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";
       }
@@ -35600,7 +35712,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 {
@@ -37448,6 +37560,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) {
@@ -37464,7 +37621,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);
       }
     }
@@ -37475,18 +37632,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 = path16.join(os19.homedir(), ".adhdev", "daemon.pid");
@@ -39828,6 +39973,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"() {
@@ -39928,6 +40087,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
       */
@@ -47410,19 +47590,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);
@@ -47454,18 +47635,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 };
+            }
           }
         }
       }
@@ -47483,19 +47678,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;
@@ -47854,14 +48042,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;
@@ -47970,6 +48163,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);
       }
@@ -48033,11 +48234,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) {
-        return this.screenshotSender.sendScreenshotBuffer(this.peers, buffer);
+      sendScreenshotBuffer(buffer, targetSessionId) {
+        return this.screenshotSender.sendScreenshotBuffer(this.peers, buffer, targetSessionId);
+      }
+      sendScreenshotBufferForTarget(targetSessionId, buffer) {
+        return this.sendScreenshotBuffer(buffer, targetSessionId);
       }
       // ─── Handler registration (unchanged API) ───────
       onFileRequest(handler) {
@@ -54761,6 +54965,7 @@ var init_screenshot_controller = __esm({
       lastSize = 0;
       lastHash = 0;
       staticFrameCount = 0;
+      targetFrameState = /* @__PURE__ */ new Map();
       currentInterval;
       // Quality profiles
       profileDirect;
@@ -54824,14 +55029,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();
@@ -54846,49 +55050,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);
@@ -55079,7 +55318,7 @@ function killPid2(pid) {
     return false;
   }
 }
-function getWindowsProcessCommandLine(pid) {
+function getWindowsProcessCommandLine2(pid) {
   const pidFilter = `ProcessId=${pid}`;
   try {
     const psOut = (0, import_child_process12.execFileSync)("powershell.exe", [
@@ -55108,13 +55347,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_process12.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 (fs17.existsSync(pidFile)) {
       const pid = Number.parseInt(fs17.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;
       }
     }
@@ -55128,40 +55386,7 @@ function stopManagedSessionHostProcess() {
   return stopped;
 }
 function stopSessionHost() {
-  let stopped = stopManagedSessionHostProcess();
-  if (process.platform === "win32") {
-    try {
-      const raw = (0, import_child_process12.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_process12.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({
@@ -55938,10 +56163,65 @@ var init_version = __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_process13.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;
 }
@@ -55968,7 +56248,7 @@ function removeDaemonPid(ref = {}) {
 function isDaemonRunning(ref = {}) {
   const port = resolveDaemonPort(ref);
   try {
-    const { execFileSync: execFileSync5 } = require("child_process");
+    const { execFileSync: execFileSync6 } = require("child_process");
     const probe = `
             const http = require('http');
             const req = http.get('http://127.0.0.1:${port}/health', { timeout: 1500 }, (res) => {
@@ -55978,7 +56258,7 @@ function isDaemonRunning(ref = {}) {
             req.on('error', () => process.stdout.write('0'));
             req.on('timeout', () => { req.destroy(); process.stdout.write('0'); });
         `;
-    const result = execFileSync5(process.execPath, ["-e", probe], {
+    const result = execFileSync6(process.execPath, ["-e", probe], {
       encoding: "utf-8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -56004,9 +56284,9 @@ function isDaemonRunning(ref = {}) {
 function isAdhdevProcess(pid) {
   try {
     if (process.platform === "win32") {
-      const { execFileSync: execFileSync5 } = require("child_process");
+      const { execFileSync: execFileSync6 } = require("child_process");
       try {
-        const psOut = execFileSync5("powershell.exe", [
+        const psOut = execFileSync6("powershell.exe", [
           "-NoProfile",
           "-NonInteractive",
           "-ExecutionPolicy",
@@ -56019,8 +56299,8 @@ function isAdhdevProcess(pid) {
         return true;
       }
     } else {
-      const { execFileSync: execFileSync5 } = require("child_process");
-      const cmdline = execFileSync5("ps", ["-o", "command=", "-p", String(pid)], {
+      const { execFileSync: execFileSync6 } = require("child_process");
+      const cmdline = execFileSync6("ps", ["-o", "command=", "-p", String(pid)], {
         encoding: "utf-8",
         timeout: 2e3,
         stdio: ["ignore", "pipe", "ignore"]
@@ -56034,7 +56314,7 @@ function isAdhdevProcess(pid) {
 function getDaemonHealthPid(ref = {}) {
   const port = resolveDaemonPort(ref);
   try {
-    const { execFileSync: execFileSync5 } = require("child_process");
+    const { execFileSync: execFileSync6 } = require("child_process");
     const probe = `
             const http = require('http');
             const req = http.get('http://127.0.0.1:${port}/health', { timeout: 1500 }, (res) => {
@@ -56052,7 +56332,7 @@ function getDaemonHealthPid(ref = {}) {
             req.on('error', () => {});
             req.on('timeout', () => { req.destroy(); });
         `;
-    const result = execFileSync5(process.execPath, ["-e", probe], {
+    const result = execFileSync6(process.execPath, ["-e", probe], {
       encoding: "utf-8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -56098,7 +56378,7 @@ function stopDaemon(ref = {}) {
     return false;
   }
 }
-var os26, fs18, path26, import_http, import_ws3, pkgVersion, AdhdevDaemon;
+var os26, fs18, path26, import_http, import_child_process13, import_ws3, pkgVersion, AdhdevDaemon;
 var init_adhdev_daemon = __esm({
   "src/adhdev-daemon.ts"() {
     "use strict";
@@ -56114,12 +56394,13 @@ var init_adhdev_daemon = __esm({
     fs18 = __toESM(require("fs"));
     path26 = __toESM(require("path"));
     import_http = require("http");
+    import_child_process13 = require("child_process");
     import_ws3 = require("ws");
     init_source2();
     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;
@@ -56212,6 +56493,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"]);
@@ -56237,15 +56522,7 @@ var init_adhdev_daemon = __esm({
         const pkgName = this.getUpgradePackageName();
         this.mandatoryUpgradeInFlight = true;
         try {
-          const { execSync: execSync7 } = await import("child_process");
-          const published = execSync7(`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,
@@ -56347,7 +56624,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;
         })();
@@ -56732,14 +57009,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());
@@ -56768,11 +57048,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");
           });
@@ -56883,15 +57164,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) {
@@ -56936,6 +57211,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 : "";
@@ -57114,8 +57393,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: {
@@ -85940,12 +86233,12 @@ function splitStringBySpace(str) {
   }
   return pieces;
 }
-var import_chardet, import_child_process13, import_fs7, import_node_path2, import_node_os4, import_node_crypto, import_iconv_lite, ExternalEditor;
+var import_chardet, import_child_process14, import_fs7, import_node_path2, import_node_os4, import_node_crypto, import_iconv_lite, ExternalEditor;
 var init_esm2 = __esm({
   "../../node_modules/@inquirer/external-editor/dist/esm/index.js"() {
     "use strict";
     import_chardet = __toESM(require_lib2(), 1);
-    import_child_process13 = require("child_process");
+    import_child_process14 = require("child_process");
     import_fs7 = require("fs");
     import_node_path2 = __toESM(require("path"), 1);
     import_node_os4 = __toESM(require("os"), 1);
@@ -86052,7 +86345,7 @@ var init_esm2 = __esm({
       }
       launchEditor() {
         try {
-          const editorProcess = (0, import_child_process13.spawnSync)(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
+          const editorProcess = (0, import_child_process14.spawnSync)(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
           this.lastExitStatus = editorProcess.status ?? 0;
         } catch (launchError) {
           throw new LaunchEditorError(launchError);
@@ -86060,7 +86353,7 @@ var init_esm2 = __esm({
       }
       launchEditorAsync(callback) {
         try {
-          const editorProcess = (0, import_child_process13.spawn)(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
+          const editorProcess = (0, import_child_process14.spawn)(this.editor.bin, this.editor.args.concat([this.tempFile]), { stdio: "inherit" });
           editorProcess.on("exit", (code) => {
             this.lastExitStatus = code;
             setImmediate(callback);
@@ -88338,9 +88631,9 @@ async function runWizard(options = {}) {
 }
 async function checkForUpdate() {
   try {
-    const { execFileSync: execFileSync5 } = await import("child_process");
+    const { execFileSync: execFileSync6 } = await import("child_process");
     const currentVersion = resolvePackageVersion();
-    const latestVersion = readLatestPublishedCliVersion(execFileSync5);
+    const latestVersion = readLatestPublishedCliVersion(execFileSync6);
     if (!latestVersion) return;
     if (!currentVersion || !latestVersion || currentVersion === latestVersion) return;
     console.log(source_default2.yellow(`  Update available: ${currentVersion} \u2192 ${latestVersion}`));
@@ -88357,7 +88650,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" });
-      execFileSync5(installCommand.command, installCommand.args, {
+      execFileSync6(installCommand.command, installCommand.args, {
         encoding: "utf-8",
         timeout: 6e4,
         stdio: ["pipe", "pipe", "pipe"]