@adhdev/daemon-core 0.9.32 → 0.9.34

package/dist/index.mjs

@@ -1688,13 +1688,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;
     }
@@ -1702,7 +1703,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);
@@ -2793,7 +2794,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 || "-"}`
           );
@@ -3609,9 +3610,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((error) => {
@@ -10356,6 +10391,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]);
@@ -10387,6 +10442,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) {
@@ -10398,6 +10462,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 {
@@ -13208,6 +13285,20 @@ var CliProviderInstance = class {
   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);
@@ -13363,6 +13454,15 @@ var CliProviderInstance = class {
           this.completedDebouncePending = { chatTitle, duration, 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;
@@ -16403,10 +16503,22 @@ var ProviderLoader = class _ProviderLoader {
   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";
   }
@@ -16534,7 +16646,7 @@ var ProviderLoader = class _ProviderLoader {
   }
   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 {
@@ -18362,6 +18474,51 @@ function killPid(pid) {
     return false;
   }
 }
+function getWindowsProcessCommandLine(pid) {
+  const pidFilter = `ProcessId=${pid}`;
+  try {
+    const psOut = execFileSync2("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 = execFileSync2("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 = execFileSync2("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) {
@@ -18378,7 +18535,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);
       }
     }
@@ -18389,18 +18546,6 @@ function stopSessionHostProcesses(appName) {
     } catch {
     }
   }
-  if (process.platform !== "win32") {
-    try {
-      const raw = execFileSync2("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(os17.homedir(), ".adhdev", "daemon.pid");
@@ -20635,6 +20780,20 @@ function forwardAgentStreamsToIdeInstance(instanceManager, ideType, streams) {
 
 // src/providers/provider-instance-manager.ts
 init_logger();
+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 = class {
   instances = /* @__PURE__ */ new Map();
   tickTimer = null;
@@ -20730,6 +20889,27 @@ var ProviderInstanceManager = class {
     }
     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
   */