@adhdev/daemon-core 0.9.33 → 0.9.35

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);
@@ -2083,6 +2084,8 @@ var init_provider_cli_adapter = __esm({
       messages = [];
       committedMessages = [];
       structuredMessages = [];
+      committedMessagesActivitySignature = "";
+      committedMessagesChangedAt = 0;
       currentStatus = "starting";
       onStatusChange = null;
       responseBuffer = "";
@@ -2164,10 +2167,35 @@ var init_provider_cli_adapter = __esm({
       providerResolutionMeta;
       static FINISH_RETRY_DELAY_MS = 300;
       static MAX_FINISH_RETRIES = 2;
+      buildCommittedMessagesActivitySignature() {
+        const last = this.committedMessages[this.committedMessages.length - 1];
+        return [
+          String(this.committedMessages.length),
+          String(last?.role || ""),
+          String(last?.kind || ""),
+          String(last?.senderName || ""),
+          String(last?.timestamp || ""),
+          String(last?.receivedAt || ""),
+          normalizeComparableMessageContent(last?.content || "").slice(-240)
+        ].join("|");
+      }
       syncMessageViews() {
+        const signature = this.buildCommittedMessagesActivitySignature();
+        if (signature !== this.committedMessagesActivitySignature) {
+          this.committedMessagesActivitySignature = signature;
+          this.committedMessagesChangedAt = Date.now();
+        }
         this.messages = [...this.committedMessages];
         this.structuredMessages = [...this.committedMessages];
       }
+      getLastCommittedMessageActivityAt() {
+        const last = this.committedMessages[this.committedMessages.length - 1];
+        const messageTime = Math.max(
+          typeof last?.receivedAt === "number" && Number.isFinite(last.receivedAt) ? last.receivedAt : 0,
+          typeof last?.timestamp === "number" && Number.isFinite(last.timestamp) ? last.timestamp : 0
+        );
+        return Math.max(messageTime, this.committedMessagesChangedAt || 0);
+      }
       readTerminalScreenText(now = Date.now()) {
         const screenText = this.terminalScreen.getText() || "";
         this.lastScreenText = screenText;
@@ -2307,9 +2335,16 @@ var init_provider_cli_adapter = __esm({
       /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */
       setCliScripts(scripts) {
         this.cliScripts = scripts;
+        this.parsedStatusCache = null;
+        this.parseErrorMessage = null;
         const scriptNames = listCliScriptNames(scripts);
         LOG.info("CLI", `[${this.cliType}] CLI scripts injected: [${scriptNames.join(", ")}]`);
       }
+      /** Refresh provider scripts/config used by this adapter without restarting the PTY runtime. */
+      refreshProviderDefinition(provider) {
+        this.provider = provider;
+        this.setCliScripts(provider.scripts || {});
+      }
       updateRuntimeSettings(settings) {
         this.runtimeSettings = { ...settings };
       }
@@ -2793,7 +2828,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 +3644,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) => {
@@ -12790,7 +12859,14 @@ var DaemonCommandHandler = class {
       await this._ctx.providerLoader.fetchLatest().catch(() => {
       });
       this._ctx.providerLoader.reload();
-      return { success: true };
+      this._ctx.providerLoader.registerToDetector();
+      const refreshedInstances = this._ctx.instanceManager ? this._ctx.instanceManager.refreshProviderDefinitions((providerType) => this._ctx.providerLoader.resolve(providerType)) : 0;
+      const providers = this._ctx.providerLoader.getAll().map((provider) => ({
+        type: provider.type,
+        name: provider.name,
+        category: provider.category
+      }));
+      return { success: true, refreshedInstances, providers };
     }
     return { success: false, error: "ProviderLoader not initialized" };
   }
@@ -13045,6 +13121,11 @@ var CliProviderInstance = class {
   launchMode;
   startedAt = Date.now();
   onProviderSessionResolved;
+  refreshProviderDefinition(provider) {
+    if (provider.type !== this.type || provider.category !== "cli") return;
+    this.provider = provider;
+    this.adapter.refreshProviderDefinition(provider);
+  }
   // ─── Lifecycle ─────────────────────────────────
   async init(context) {
     this.context = context;
@@ -13250,6 +13331,22 @@ 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();
+    const lastCommittedMessageActivityAt = typeof this.adapter.getLastCommittedMessageActivityAt === "function" ? this.adapter.getLastCommittedMessageActivityAt() : 0;
+    return {
+      id: this.instanceId,
+      status: visibleStatus,
+      lastMessageAt: lastCommittedMessageActivityAt || void 0,
+      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);
@@ -13405,6 +13502,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;
@@ -18416,6 +18522,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) {
@@ -18432,7 +18583,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);
       }
     }
@@ -18443,18 +18594,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");
@@ -20689,6 +20828,23 @@ 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,
+    unread: item.unread,
+    inboxBucket: item.inboxBucket,
+    lastMessageAt: item.lastMessageAt ?? item.activeChat?.lastMessageAt,
+    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;
@@ -20784,6 +20940,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
   */
@@ -20865,6 +21042,17 @@ var ProviderInstanceManager = class {
     }
     return updated;
   }
+  refreshProviderDefinitions(resolveProvider) {
+    let refreshed = 0;
+    for (const instance of this.instances.values()) {
+      if (typeof instance.refreshProviderDefinition !== "function") continue;
+      const provider = resolveProvider(instance.type);
+      if (!provider || typeof provider !== "object") continue;
+      instance.refreshProviderDefinition(provider);
+      refreshed += 1;
+    }
+    return refreshed;
+  }
   // ─── cleanup ──────────────────────────────────────
   /**
   * All terminate
@@ -25109,20 +25297,7 @@ var DevServer = class _DevServer {
   async handleReload(_req, res) {
     try {
       this.providerLoader.reload();
-      let refreshedInstances = 0;
-      if (this.instanceManager) {
-        for (const id of this.instanceManager.listInstanceIds()) {
-          const instance = this.instanceManager.getInstance(id);
-          const providerType = typeof instance?.type === "string" ? instance.type : "";
-          if (!providerType) continue;
-          const resolved = this.providerLoader.resolve(providerType);
-          if (!resolved) continue;
-          if (instance && typeof instance === "object" && "provider" in instance) {
-            instance.provider = resolved;
-            refreshedInstances += 1;
-          }
-        }
-      }
+      const refreshedInstances = this.instanceManager ? this.instanceManager.refreshProviderDefinitions((providerType) => this.providerLoader.resolve(providerType)) : 0;
       const providers = this.providerLoader.getAll().map((p) => ({
         type: p.type,
         name: p.name,