@adhdev/daemon-standalone 0.9.33 → 0.9.35

package/dist/index.js

@@ -29560,13 +29560,14 @@ var require_dist2 = __commonJS({
     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;
         }
@@ -29574,7 +29575,7 @@ var require_dist2 = __commonJS({
           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);
@@ -29953,6 +29954,8 @@ var require_dist2 = __commonJS({
           messages = [];
           committedMessages = [];
           structuredMessages = [];
+          committedMessagesActivitySignature = "";
+          committedMessagesChangedAt = 0;
           currentStatus = "starting";
           onStatusChange = null;
           responseBuffer = "";
@@ -30034,10 +30037,35 @@ var require_dist2 = __commonJS({
           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;
@@ -30177,9 +30205,16 @@ var require_dist2 = __commonJS({
           /** 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);
             LOG2.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 };
           }
@@ -30663,7 +30698,7 @@ var require_dist2 = __commonJS({
               return;
             }
             if (this.currentTurnScope && !lastParsedAssistant) {
-              LOG2.info(
+              LOG2.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 || "-"}`
               );
@@ -31479,9 +31514,43 @@ var require_dist2 = __commonJS({
           }
           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) => {
@@ -40712,7 +40781,14 @@ ${effect.notification.body || ""}`.trim();
           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" };
       }
@@ -40959,6 +41035,11 @@ ${effect.notification.body || ""}`.trim();
       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;
@@ -41164,6 +41245,22 @@ ${effect.notification.body || ""}`.trim();
       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);
@@ -41319,6 +41416,15 @@ ${effect.notification.body || ""}`.trim();
               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") {
+                    LOG2.info("CLI", `[${this.type}] cancelled pending completed (resumed ${latestVisibleStatus})`);
+                    this.completedDebouncePending = null;
+                    this.completedDebounceTimer = null;
+                    return;
+                  }
                   LOG2.info("CLI", `[${this.type}] completed in ${this.completedDebouncePending.duration}s`);
                   this.pushEvent({ event: "agent:generating_completed", ...this.completedDebouncePending });
                   this.completedDebouncePending = null;
@@ -46297,6 +46403,51 @@ Run 'adhdev doctor' for detailed diagnostics.`
         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) {
@@ -46313,7 +46464,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       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)) {
             killPid2(pid);
           }
         }
@@ -46324,18 +46475,6 @@ Run 'adhdev doctor' for detailed diagnostics.`
         } 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)) {
-              killPid2(pid);
-            }
-          }
-        } catch {
-        }
-      }
     }
     function removeDaemonPidFile() {
       const pidFile = path16.join(os17.homedir(), ".adhdev", "daemon.pid");
@@ -48548,6 +48687,23 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
     }
     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;
@@ -48643,6 +48799,27 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         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) {
+            LOG2.warn("InstanceMgr", `[InstanceManager] Failed to collect hot chat metadata from ${id}: ${e.message}`);
+          }
+        }
+        return sessions;
+      }
       /**
       * Per-category status collect
       */
@@ -48724,6 +48901,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         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
@@ -52950,20 +53138,7 @@ data: ${JSON.stringify(msg.data)}
       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,