@adhdev/daemon-standalone 0.8.28 → 0.8.29

package/dist/index.js

@@ -9495,6 +9495,9 @@ var require_dist = __commonJS({
         state.record.lastActivityAt = Date.now();
         return this.cloneRecord(state.record);
       }
+      deleteSession(sessionId) {
+        return this.sessions.delete(sessionId);
+      }
       requireSession(sessionId) {
         const state = this.sessions.get(sessionId);
         if (!state) throw new Error(`Unknown session: ${sessionId}`);
@@ -9676,10 +9679,12 @@ var require_dist = __commonJS({
         env[key] = value;
       }
       for (const key of Object.keys(env)) {
-        if (key === "INIT_CWD" || key === "npm_command" || key === "npm_execpath" || key === "npm_node_execpath" || key.startsWith("npm_") || key.startsWith("npm_config_") || key.startsWith("npm_package_") || key.startsWith("npm_lifecycle_") || key.startsWith("PNPM_") || key.startsWith("YARN_") || key.startsWith("BUN_")) {
+        if (key === "INIT_CWD" || key === "npm_command" || key === "npm_execpath" || key === "npm_node_execpath" || key.startsWith("npm_") || key.startsWith("npm_config_") || key.startsWith("npm_package_") || key.startsWith("npm_lifecycle_") || key.startsWith("PNPM_") || key.startsWith("YARN_") || key.startsWith("BUN_") || key.startsWith("VSCODE_") || key.startsWith("ELECTRON_")) {
           delete env[key];
         }
       }
+      delete env.CODEX_THREAD_ID;
+      delete env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE;
       applyTerminalColorEnv(env);
       return env;
     }
@@ -29440,6 +29445,9 @@ var require_dist2 = __commonJS({
           looksLikeVisibleIdlePrompt(screenText) {
             const text = String(screenText || "");
             if (!text.trim()) return false;
+            if (this.cliType === "codex-cli" && /(^|\n)\s*[❯›>]\s+(?:Find and fix a bug in @filename|Improve documentation in @filename|Use \/skills|Write tests for @filename|Explain this codebase|Summarize recent commits|Implement \{feature\}|Run \/review on my current changes)(?:\n|$)/im.test(text)) {
+              return true;
+            }
             return /(^|\n)\s*[❯›>]\s*(?:\n|$)/m.test(text) || /⏎\s+send/i.test(text) || /\?\s*for\s*shortcuts/i.test(text) || /Type your message(?:\s+or\s+@path\/to\/file)?/i.test(text) || /workspace\s*\(\/directory\)/i.test(text) || /for\s*shortcuts/i.test(text);
           }
           findLastMatchingLineIndex(lines, predicate) {
@@ -32739,11 +32747,72 @@ ${data.message || ""}`.trim();
     var os52 = __toESM2(require("os"));
     var HISTORY_DIR = path7.join(os52.homedir(), ".adhdev", "history");
     var RETAIN_DAYS = 30;
+    var CODEX_STARTER_PROMPT_RE = /^(?:[›❯]\s*)?(?:Find and fix a bug in @filename|Improve documentation in @filename|Write tests for @filename|Explain this codebase|Summarize recent commits|Implement \{feature\}|Use \/skills(?: to list available skills)?|Run \/review on my current changes)$/i;
+    function normalizeHistoryComparable(text) {
+      return String(text || "").replace(/\s+/g, " ").trim();
+    }
+    function cleanupHistoryContent(agentType, role, content) {
+      let value = String(content || "").replace(/\r\n/g, "\n").trim();
+      if (!value) return "";
+      if (agentType === "codex-cli" && role === "assistant") {
+        const filtered = value.split("\n").filter((line) => !CODEX_STARTER_PROMPT_RE.test(line.trim())).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+        value = filtered;
+      }
+      return value;
+    }
+    function buildHistoryMessageHash(agentType, message) {
+      if (message.historyDedupKey) return message.historyDedupKey;
+      const cleaned = cleanupHistoryContent(agentType, message.role, message.content);
+      return `${message.kind || "standard"}:${message.role}:${message.receivedAt || 0}:${normalizeHistoryComparable(cleaned)}`;
+    }
+    function buildHistoryMessageSignature(agentType, message) {
+      const cleaned = cleanupHistoryContent(agentType, message.role, message.content);
+      return `${message.kind || "standard"}:${message.role}:${normalizeHistoryComparable(cleaned)}`;
+    }
+    function isAdjacentHistoryDuplicate(agentType, previous, next) {
+      if (!previous || !next) return false;
+      return buildHistoryMessageSignature(agentType, previous) === buildHistoryMessageSignature(agentType, next);
+    }
+    function collapseReplayAssistantTurns(agentType, messages) {
+      if (agentType !== "codex-cli") return messages;
+      const collapsed = [];
+      let sawAssistantSinceLastUser = false;
+      for (const message of messages) {
+        if (message.role === "user") {
+          sawAssistantSinceLastUser = false;
+          collapsed.push(message);
+          continue;
+        }
+        if (message.role === "assistant") {
+          if (sawAssistantSinceLastUser) continue;
+          sawAssistantSinceLastUser = true;
+          collapsed.push(message);
+          continue;
+        }
+        collapsed.push(message);
+      }
+      return collapsed;
+    }
+    function sanitizeHistoryMessage(agentType, message) {
+      if (!message || message.role !== "user" && message.role !== "assistant" && message.role !== "system") {
+        return null;
+      }
+      const content = cleanupHistoryContent(agentType, message.role, message.content);
+      if (!content) return null;
+      return {
+        ...message,
+        content
+      };
+    }
     var ChatHistoryWriter = class {
       /** Last seen message count per agent (deduplication) */
       lastSeenCounts = /* @__PURE__ */ new Map();
       /** Last seen message hash per agent (deduplication) */
       lastSeenHashes = /* @__PURE__ */ new Map();
+      /** Last appended normalized message signature per agent/session */
+      lastSeenSignatures = /* @__PURE__ */ new Map();
+      /** Last appended normalized non-system turn signature per agent/session */
+      lastSeenTurnSignatures = /* @__PURE__ */ new Map();
       rotated = false;
       /**
       * Append new messages to history
@@ -32765,14 +32834,36 @@ ${data.message || ""}`.trim();
           }
           const newMessages = [];
           for (const msg of messages) {
-            const hash2 = msg.historyDedupKey || `${msg.kind || "standard"}:${msg.role}:${(msg.content || "").slice(0, 50)}`;
+            const role = msg.role;
+            if (role !== "user" && role !== "assistant" && role !== "system") continue;
+            const content = cleanupHistoryContent(agentType, role, msg.content || "");
+            if (!content) continue;
+            const receivedAt = msg.receivedAt || Date.now();
+            const hash2 = buildHistoryMessageHash(agentType, {
+              role,
+              content,
+              receivedAt,
+              kind: typeof msg.kind === "string" ? msg.kind : void 0,
+              historyDedupKey: msg.historyDedupKey
+            });
+            const signature = buildHistoryMessageSignature(agentType, {
+              role,
+              content,
+              kind: typeof msg.kind === "string" ? msg.kind : void 0
+            });
             if (seenHashes.has(hash2)) continue;
+            if (this.lastSeenSignatures.get(dedupKey) === signature) continue;
+            if (role !== "system" && this.lastSeenTurnSignatures.get(dedupKey) === signature) continue;
             seenHashes.add(hash2);
+            this.lastSeenSignatures.set(dedupKey, signature);
+            if (role !== "system") {
+              this.lastSeenTurnSignatures.set(dedupKey, signature);
+            }
             newMessages.push({
-              ts: new Date(msg.receivedAt || Date.now()).toISOString(),
-              receivedAt: msg.receivedAt || Date.now(),
-              role: msg.role,
-              content: msg.content || "",
+              ts: new Date(receivedAt).toISOString(),
+              receivedAt,
+              role,
+              content,
               kind: typeof msg.kind === "string" ? msg.kind : void 0,
               senderName: typeof msg.senderName === "string" ? msg.senderName : void 0,
               agent: agentType,
@@ -32792,6 +32883,8 @@ ${data.message || ""}`.trim();
           const prevCount = this.lastSeenCounts.get(dedupKey) || 0;
           if (messages.length < prevCount * 0.5 && prevCount > 3) {
             seenHashes.clear();
+            this.lastSeenSignatures.delete(dedupKey);
+            this.lastSeenTurnSignatures.delete(dedupKey);
             for (const msg of messages) {
               seenHashes.add(msg.historyDedupKey || `${msg.kind || "standard"}:${msg.role}:${(msg.content || "").slice(0, 50)}`);
             }
@@ -32805,6 +32898,54 @@ ${data.message || ""}`.trim();
         } catch {
         }
       }
+      seedSessionHistory(agentType, messages = [], historySessionId, instanceId) {
+        const effectiveHistoryKey = historySessionId || instanceId;
+        const dedupKey = effectiveHistoryKey ? `${agentType}:${effectiveHistoryKey}` : agentType;
+        const seenHashes = /* @__PURE__ */ new Set();
+        for (const raw of messages) {
+          const role = raw?.role;
+          if (role !== "user" && role !== "assistant" && role !== "system") continue;
+          const content = cleanupHistoryContent(agentType, role, raw?.content || "");
+          if (!content) continue;
+          seenHashes.add(buildHistoryMessageHash(agentType, {
+            role,
+            content,
+            receivedAt: raw?.receivedAt || 0,
+            kind: typeof raw?.kind === "string" ? raw.kind : void 0,
+            historyDedupKey: raw?.historyDedupKey
+          }));
+        }
+        this.lastSeenHashes.set(dedupKey, seenHashes);
+        this.lastSeenCounts.set(dedupKey, messages.length);
+        const lastMessage = [...messages].reverse().find((raw) => {
+          const role = raw?.role;
+          if (role !== "user" && role !== "assistant" && role !== "system") return false;
+          return !!cleanupHistoryContent(agentType, role, raw?.content || "");
+        });
+        const lastTurnMessage = [...messages].reverse().find((raw) => {
+          const role = raw?.role;
+          if (role !== "user" && role !== "assistant") return false;
+          return !!cleanupHistoryContent(agentType, role, raw?.content || "");
+        });
+        if (lastMessage) {
+          this.lastSeenSignatures.set(dedupKey, buildHistoryMessageSignature(agentType, {
+            role: lastMessage.role,
+            content: lastMessage.content,
+            kind: typeof lastMessage.kind === "string" ? lastMessage.kind : void 0
+          }));
+        } else {
+          this.lastSeenSignatures.delete(dedupKey);
+        }
+        if (lastTurnMessage) {
+          this.lastSeenTurnSignatures.set(dedupKey, buildHistoryMessageSignature(agentType, {
+            role: lastTurnMessage.role,
+            content: lastTurnMessage.content,
+            kind: typeof lastTurnMessage.kind === "string" ? lastTurnMessage.kind : void 0
+          }));
+        } else {
+          this.lastSeenTurnSignatures.delete(dedupKey);
+        }
+      }
       appendSystemMarker(agentType, content, options = {}) {
         this.appendNewMessages(
           agentType,
@@ -32835,6 +32976,16 @@ ${data.message || ""}`.trim();
             this.lastSeenHashes.set(toDedupKey, nextHashes);
             this.lastSeenHashes.delete(fromDedupKey);
           }
+          const fromSignature = this.lastSeenSignatures.get(fromDedupKey);
+          if (fromSignature) {
+            this.lastSeenSignatures.set(toDedupKey, fromSignature);
+            this.lastSeenSignatures.delete(fromDedupKey);
+          }
+          const fromTurnSignature = this.lastSeenTurnSignatures.get(fromDedupKey);
+          if (fromTurnSignature) {
+            this.lastSeenTurnSignatures.set(toDedupKey, fromTurnSignature);
+            this.lastSeenTurnSignatures.delete(fromDedupKey);
+          }
           const fromCount = this.lastSeenCounts.get(fromDedupKey);
           if (typeof fromCount === "number") {
             this.lastSeenCounts.set(toDedupKey, Math.max(fromCount, this.lastSeenCounts.get(toDedupKey) || 0));
@@ -32876,10 +33027,61 @@ ${data.message || ""}`.trim();
         } catch {
         }
       }
+      compactHistorySession(agentType, historySessionId) {
+        const sessionId = String(historySessionId || "").trim();
+        if (!sessionId) return;
+        try {
+          const dir = path7.join(HISTORY_DIR, this.sanitize(agentType));
+          if (!fs32.existsSync(dir)) return;
+          const prefix = `${this.sanitize(sessionId)}_`;
+          const files = fs32.readdirSync(dir).filter((file2) => file2.startsWith(prefix) && file2.endsWith(".jsonl")).sort();
+          const seen = /* @__PURE__ */ new Set();
+          for (const file2 of files) {
+            const filePath = path7.join(dir, file2);
+            const lines = fs32.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+            const next = [];
+            for (const line of lines) {
+              let parsed = null;
+              try {
+                parsed = JSON.parse(line);
+              } catch {
+                parsed = null;
+              }
+              if (!parsed || parsed.historySessionId !== sessionId) continue;
+              const sanitized = sanitizeHistoryMessage(agentType, parsed);
+              if (!sanitized) continue;
+              const hash2 = buildHistoryMessageHash(agentType, sanitized);
+              if (seen.has(hash2)) continue;
+              seen.add(hash2);
+              next.push(sanitized);
+            }
+            next.sort((a, b2) => a.receivedAt - b2.receivedAt);
+            const dedupedAdjacent = [];
+            let lastTurn = null;
+            for (const entry of next) {
+              const previous = dedupedAdjacent[dedupedAdjacent.length - 1];
+              if (isAdjacentHistoryDuplicate(agentType, previous, entry)) continue;
+              if (entry.role !== "system" && isAdjacentHistoryDuplicate(agentType, lastTurn, entry)) continue;
+              dedupedAdjacent.push(entry);
+              if (entry.role !== "system") lastTurn = entry;
+            }
+            const collapsed = collapseReplayAssistantTurns(agentType, dedupedAdjacent);
+            if (collapsed.length === 0) {
+              fs32.unlinkSync(filePath);
+              continue;
+            }
+            fs32.writeFileSync(filePath, `${collapsed.map((entry) => JSON.stringify(entry)).join("\n")}
+`, "utf-8");
+          }
+        } catch {
+        }
+      }
       /** Called when agent session is explicitly changed */
       onSessionChange(agentType) {
         this.lastSeenHashes.delete(agentType);
         this.lastSeenCounts.delete(agentType);
+        this.lastSeenSignatures.delete(agentType);
+        this.lastSeenTurnSignatures.delete(agentType);
       }
       /** Delete history files older than 30 days */
       async rotateOldFiles() {
@@ -32920,23 +33122,37 @@ ${data.message || ""}`.trim();
           return true;
         }).sort().reverse();
         const allMessages = [];
-        const needed = offset + limit + 1;
+        const seen = /* @__PURE__ */ new Set();
         for (const file2 of files) {
-          if (allMessages.length >= needed) break;
           const filePath = path7.join(dir, file2);
           const content = fs32.readFileSync(filePath, "utf-8");
           const lines = content.trim().split("\n").filter(Boolean);
-          for (let i = lines.length - 1; i >= 0; i--) {
-            if (allMessages.length >= needed) break;
+          for (let i = 0; i < lines.length; i++) {
             try {
-              allMessages.push(JSON.parse(lines[i]));
+              const parsed = JSON.parse(lines[i]);
+              const sanitizedMessage = sanitizeHistoryMessage(agentType, parsed);
+              if (!sanitizedMessage) continue;
+              const hash2 = buildHistoryMessageHash(agentType, sanitizedMessage);
+              if (seen.has(hash2)) continue;
+              seen.add(hash2);
+              allMessages.push(sanitizedMessage);
             } catch {
             }
           }
         }
-        const sliced = allMessages.slice(offset, offset + limit);
-        const hasMore = allMessages.length > offset + limit;
-        sliced.reverse();
+        allMessages.sort((a, b2) => a.receivedAt - b2.receivedAt);
+        const chronological = [];
+        let lastTurn = null;
+        for (const message of allMessages) {
+          const previous = chronological[chronological.length - 1];
+          if (isAdjacentHistoryDuplicate(agentType, previous, message)) continue;
+          if (message.role !== "system" && isAdjacentHistoryDuplicate(agentType, lastTurn, message)) continue;
+          chronological.push(message);
+          if (message.role !== "system") lastTurn = message;
+        }
+        const collapsed = collapseReplayAssistantTurns(agentType, chronological);
+        const sliced = collapsed.slice(offset, offset + limit);
+        const hasMore = collapsed.length > offset + limit;
         return { messages: sliced, hasMore };
       } catch {
         return { messages: [], hasMore: false };
@@ -34770,6 +34986,46 @@ ${effect.notification.body || ""}`.trim();
       if (!parsed || typeof parsed !== "object") return false;
       return parsed.sent === true || parsed.success === true || parsed.ok === true || parsed.submitted === true || parsed.dispatched === true;
     }
+    async function readExtensionChatState(h) {
+      try {
+        const evalResult = await h.evaluateProviderScript("readChat", void 0, 5e4);
+        if (!evalResult?.result) return null;
+        const parsed = parseMaybeJson(evalResult.result);
+        return parsed && typeof parsed === "object" ? parsed : null;
+      } catch {
+        return null;
+      }
+    }
+    function getStateMessageCount(state) {
+      return Array.isArray(state?.messages) ? state.messages.length : 0;
+    }
+    function getStateLastSignature(state) {
+      const messages = Array.isArray(state?.messages) ? state.messages : [];
+      const last = messages[messages.length - 1];
+      if (!last) return "";
+      return `${last.role || ""}:${String(last.content || "").replace(/\s+/g, " ").trim()}`;
+    }
+    async function getStableExtensionBaseline(h) {
+      const first = await readExtensionChatState(h);
+      if (getStateMessageCount(first) > 0 || getStateLastSignature(first)) return first;
+      await new Promise((resolve12) => setTimeout(resolve12, 150));
+      const second = await readExtensionChatState(h);
+      return getStateMessageCount(second) >= getStateMessageCount(first) ? second : first;
+    }
+    async function verifyExtensionSendObserved(h, before) {
+      const beforeCount = getStateMessageCount(before);
+      const beforeSignature = getStateLastSignature(before);
+      for (let attempt = 0; attempt < 12; attempt += 1) {
+        await new Promise((resolve12) => setTimeout(resolve12, 250));
+        const state = await readExtensionChatState(h);
+        if (state?.status === "waiting_approval") return true;
+        const afterCount = getStateMessageCount(state);
+        const afterSignature = getStateLastSignature(state);
+        if (afterCount > beforeCount) return true;
+        if (afterSignature && afterSignature !== beforeSignature) return true;
+      }
+      return false;
+    }
     async function handleChatHistory(h, args) {
       const { agentType, offset, limit } = args;
       const historySessionId = getHistorySessionId(h, args);
@@ -34950,12 +35206,17 @@ ${effect.notification.body || ""}`.trim();
       if (isExtensionTransport(transport)) {
         _log(`Extension: ${provider?.type || "unknown_extension"}`);
         try {
+          const beforeState = await getStableExtensionBaseline(h);
           const evalResult = await h.evaluateProviderScript("sendMessage", { message: text }, 3e4);
           if (evalResult?.result) {
             const parsed = parseMaybeJson(evalResult.result);
             if (didProviderConfirmSend(parsed)) {
-              _log(`Extension script sent OK`);
-              return _logSendSuccess("extension-script");
+              const observed = await verifyExtensionSendObserved(h, beforeState);
+              if (observed) {
+                _log(`Extension script sent OK`);
+                return _logSendSuccess("extension-script");
+              }
+              _log(`Extension script reported send but no chat-state change was observed`);
             }
             if (parsed?.needsTypeAndSend) {
               _log(`Extension needsTypeAndSend \u2192 AgentStreamManager`);
@@ -35460,7 +35721,7 @@ ${effect.notification.body || ""}`.trim();
         return { success: true, buttonIndex, button: buttons[buttonIndex] ?? button };
       }
       if (isExtensionTransport(transport) && h.agentStream && h.getCdp() && h.currentSession?.sessionId) {
-        const ok = await h.agentStream.resolveSessionAction(h.getCdp(), h.currentSession.sessionId, action);
+        const ok = await h.agentStream.resolveSessionAction(h.getCdp(), h.currentSession.sessionId, action, button);
         return { success: ok };
       }
       if (transport === "acp") {
@@ -36855,6 +37116,7 @@ ${effect.notification.body || ""}`.trim();
       historyWriter;
       runtimeMessages = [];
       instanceId;
+      suppressIdleHistoryReplay = false;
       presentationMode;
       providerSessionId;
       launchMode;
@@ -36882,7 +37144,15 @@ ${effect.notification.body || ""}`.trim();
         await this.adapter.spawn();
         this.maybeAppendRuntimeRecoveryMessage(this.adapter.getRuntimeMetadata());
         if (this.providerSessionId) {
+          this.historyWriter.compactHistorySession(this.type, this.providerSessionId);
           const restoredHistory = readChatHistory(this.type, 0, 200, this.providerSessionId);
+          this.historyWriter.seedSessionHistory(
+            this.type,
+            restoredHistory.messages,
+            this.providerSessionId,
+            this.instanceId
+          );
+          this.suppressIdleHistoryReplay = restoredHistory.messages.length > 0;
           if (restoredHistory.messages.length > 0) {
             this.adapter.seedCommittedMessages(
               restoredHistory.messages.map((message) => ({
@@ -36926,7 +37196,7 @@ ${effect.notification.body || ""}`.trim();
           } else if (this.type === "codex-cli") {
             probedSessionId = this.probeSessionIdFromConfig({
               dbPath: "~/.codex/state_5.sqlite",
-              query: "select id from threads where cwd in ({dirs}) and created_at >= ? and archived = 0 order by created_at desc limit 1",
+              query: "select id from threads where cwd in ({dirs}) and updated_at >= ? and archived = 0 order by updated_at desc limit 1",
               timestampFormat: "unix_s"
             });
           } else if (this.type === "goose-cli") {
@@ -36986,6 +37256,7 @@ ${effect.notification.body || ""}`.trim();
         const mergedMessages = this.mergeConversationMessages(parsedMessages);
         const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
         if (parsedMessages.length > 0) {
+          const shouldSkipReplayPersist = this.suppressIdleHistoryReplay && adapterStatus.status === "idle" && parsedStatus?.status === "idle";
           let messagesToSave = parsedMessages;
           if (parsedStatus?.status === "generating" || parsedStatus?.status === "long_generating") {
             const lastIdx = messagesToSave.length - 1;
@@ -36993,7 +37264,7 @@ ${effect.notification.body || ""}`.trim();
               messagesToSave = messagesToSave.slice(0, lastIdx);
             }
           }
-          if (messagesToSave.length > 0) {
+          if (!shouldSkipReplayPersist && messagesToSave.length > 0) {
             this.historyWriter.appendNewMessages(
               this.type,
               messagesToSave,
@@ -37088,6 +37359,7 @@ ${effect.notification.body || ""}`.trim();
         if (newStatus !== this.lastStatus) {
           LOG2.info("CLI", `[${this.type}] status: ${this.lastStatus} \u2192 ${newStatus}`);
           if (this.lastStatus === "idle" && newStatus === "generating") {
+            this.suppressIdleHistoryReplay = false;
             if (this.completedDebouncePending) {
               LOG2.info("CLI", `[${this.type}] cancelled pending completed (resumed generating)`);
               if (this.completedDebounceTimer) {
@@ -37107,6 +37379,7 @@ ${effect.notification.body || ""}`.trim();
               this.generatingDebounceTimer = null;
             }, 1e3);
           } else if (newStatus === "waiting_approval") {
+            this.suppressIdleHistoryReplay = false;
             if (this.generatingDebouncePending) {
               if (this.generatingDebounceTimer) {
                 clearTimeout(this.generatingDebounceTimer);
@@ -38811,6 +39084,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (!instanceManager) return 0;
         const sessions = records || await this.deps.listHostedCliRuntimes?.() || [];
         let restored = 0;
+        const restoredBindings = /* @__PURE__ */ new Set();
         for (const record2 of sessions) {
           if (!record2?.runtimeId || !record2?.cliType || !record2?.workspace) continue;
           if (this.adapters.has(record2.runtimeId) || instanceManager.getInstance(record2.runtimeId)) continue;
@@ -38824,6 +39098,18 @@ Run 'adhdev doctor' for detailed diagnostics.`
             record2.cliArgs,
             record2.providerSessionId
           );
+          const bindingKey = [
+            normalizedType,
+            record2.workspace,
+            sessionBinding.providerSessionId || record2.runtimeId
+          ].join("::");
+          if (restoredBindings.has(bindingKey)) {
+            LOG2.info(
+              "CLI",
+              `\u21B7 Skipping duplicate hosted runtime restore: ${record2.runtimeKey || record2.runtimeId} (${normalizedType} @ ${record2.workspace}) binding=${sessionBinding.providerSessionId || "runtime"}`
+            );
+            continue;
+          }
           try {
             await this.registerCliInstance(
               record2.runtimeId,
@@ -38839,6 +39125,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 launchMode: "manual"
               }
             );
+            restoredBindings.add(bindingKey);
             restored += 1;
             LOG2.info("CLI", `\u267B Restored hosted runtime: ${record2.runtimeKey || record2.runtimeId} (${record2.displayName || record2.workspace})`);
           } catch (error48) {
@@ -41172,6 +41459,15 @@ Run 'adhdev doctor' for detailed diagnostics.`
             const record2 = await this.deps.sessionHostControl.forceDetachClient(sessionId, clientId);
             return { success: true, record: record2 };
           }
+          case "session_host_prune_duplicate_sessions": {
+            if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
+            const result = await this.deps.sessionHostControl.pruneDuplicateSessions({
+              providerType: typeof args?.providerType === "string" ? args.providerType : void 0,
+              workspace: typeof args?.workspace === "string" ? args.workspace : void 0,
+              dryRun: args?.dryRun === true
+            });
+            return { success: true, result };
+          }
           case "session_host_acquire_write": {
             if (!this.deps.sessionHostControl) return { success: false, error: "Session host control unavailable" };
             const sessionId = typeof args?.sessionId === "string" ? args.sessionId : "";
@@ -41749,6 +42045,51 @@ Run 'adhdev doctor' for detailed diagnostics.`
       isTransportError(reason) {
         return /Session with given id not found/i.test(reason) || /CDP not connected/i.test(reason) || /Target closed/i.test(reason) || /WebSocket not open/i.test(reason) || /not connected/i.test(reason) || /execution context/i.test(reason) || /Cannot find context with specified id/i.test(reason);
       }
+      titlesMatch(actual, expected) {
+        const lhs = actual.trim().toLowerCase();
+        const rhs = expected.trim().toLowerCase();
+        if (!lhs || !rhs) return false;
+        return lhs === rhs || lhs.includes(rhs) || rhs.includes(lhs);
+      }
+      messageCount(state) {
+        return Array.isArray(state?.messages) ? state.messages.length : 0;
+      }
+      lastMessageSignature(state) {
+        const messages = Array.isArray(state?.messages) ? state.messages : [];
+        const last = messages[messages.length - 1];
+        if (!last) return "";
+        return `${last.role || ""}:${String(last.content || "").replace(/\s+/g, " ").trim()}`;
+      }
+      async verifySendOutcome(evaluate, before) {
+        const beforeCount = this.messageCount(before);
+        const beforeSignature = this.lastMessageSignature(before);
+        for (let attempt = 0; attempt < 12; attempt += 1) {
+          await new Promise((resolve12) => setTimeout(resolve12, 250));
+          let state;
+          try {
+            state = await this.readChat(evaluate);
+          } catch {
+            continue;
+          }
+          if (state.status === "waiting_approval") {
+            return true;
+          }
+          const afterCount = this.messageCount(state);
+          const afterSignature = this.lastMessageSignature(state);
+          if (afterCount > beforeCount) return true;
+          if (afterSignature && afterSignature !== beforeSignature) return true;
+        }
+        return false;
+      }
+      async readStableBaselineState(evaluate) {
+        const first = await this.readChat(evaluate);
+        if (this.messageCount(first) > 0 || this.lastMessageSignature(first)) {
+          return first;
+        }
+        await new Promise((resolve12) => setTimeout(resolve12, 150));
+        const second = await this.readChat(evaluate);
+        return this.messageCount(second) >= this.messageCount(first) ? second : first;
+      }
       async readChat(evaluate) {
         const script = this.callScript("readChat");
         if (!script) return this.errorState("readChat script not available");
@@ -41774,6 +42115,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
             mode: data.mode,
             activeModal: data.activeModal
           };
+          if (typeof data.title === "string" && data.title.trim()) {
+            state.title = data.title.trim();
+          }
           const controlValues = extractProviderControlValues(this.provider.controls, data);
           if (controlValues) state.controlValues = controlValues;
           const effects = normalizeProviderEffects(data);
@@ -41797,6 +42141,12 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
       }
       async sendMessage(evaluate, text) {
+        let beforeState = null;
+        try {
+          beforeState = await this.readStableBaselineState(evaluate);
+        } catch {
+          beforeState = null;
+        }
         const params = { message: text };
         const script = this.callScript("sendMessage", params) || this.callScript("sendMessage", text);
         if (!script) throw new Error(`[${this.agentName}] sendMessage script not available`);
@@ -41814,7 +42164,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         if (parsed && typeof parsed === "object") {
           if (parsed.sent === true || parsed.success === true || parsed.ok === true || parsed.submitted === true || parsed.dispatched === true) {
-            return;
+            const verified = await this.verifySendOutcome(evaluate, beforeState);
+            if (verified) return;
+            throw new Error(`[${this.agentName}] sendMessage was not observed in chat state`);
           }
           if (typeof parsed.error === "string" && parsed.error.trim()) {
             throw new Error(`[${this.agentName}] sendMessage failed: ${parsed.error}`);
@@ -41825,7 +42177,15 @@ Run 'adhdev doctor' for detailed diagnostics.`
       async resolveAction(evaluate, action, button) {
         const script = this.callScript("resolveAction", { action, button });
         if (!script) return false;
-        return await evaluate(script) === true;
+        const result = await evaluate(script);
+        const parsed = this.parseMaybeJson(result);
+        if (parsed === true) return true;
+        if (typeof parsed === "string") {
+          const normalized = parsed.trim().toLowerCase();
+          return normalized === "ok" || normalized === "success" || normalized === "true" || normalized === "resolved" || normalized === "approved" || normalized === "rejected";
+        }
+        if (!parsed || typeof parsed !== "object") return false;
+        return parsed.resolved === true || parsed.success === true || parsed.ok === true || parsed.found === true;
       }
       async newSession(evaluate) {
         const script = this.callScript("newSession");
@@ -41862,7 +42222,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
           return normalized === "true" || normalized === "ok" || normalized === "switched" || normalized === "success";
         }
         if (data && typeof data === "object") {
-          return data.switched === true || data.success === true || data.ok === true;
+          if (data.switched === true || data.success === true || data.ok === true) return true;
+          if (typeof data.error === "string" && data.error.trim()) return false;
+        }
+        for (let attempt = 0; attempt < 6; attempt += 1) {
+          await new Promise((resolve12) => setTimeout(resolve12, 250));
+          const state = await this.readChat(evaluate);
+          const title = typeof state.title === "string" ? state.title : "";
+          if (this.titlesMatch(title, sessionId)) return true;
         }
         return false;
       }
@@ -42068,7 +42435,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           return false;
         }
       }
-      async resolveSessionAction(cdp, sessionId, action) {
+      async resolveSessionAction(cdp, sessionId, action, button) {
         await this.ensureSessionPanelOpen(sessionId);
         const target = this.getSessionTarget(sessionId);
         if (!target?.parentSessionId) return false;
@@ -42078,7 +42445,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (!agent) return false;
         try {
           const evaluate = (expr, timeout) => cdp.evaluateInSessionFrame(agent.cdpSessionId, expr, timeout);
-          return await agent.adapter.resolveAction(evaluate, action);
+          return await agent.adapter.resolveAction(evaluate, action, button);
         } catch (e) {
           this.logFn(`[AgentStream] resolveAction(${sessionId}) error: ${e.message}`);
           return false;
@@ -48995,6 +49362,9 @@ var StandaloneSessionHostControlPlane = class {
   async forceDetachClient(sessionId, clientId) {
     return this.request("force_detach_client", { sessionId, clientId });
   }
+  async pruneDuplicateSessions(payload = {}) {
+    return this.request("prune_duplicate_sessions", payload);
+  }
   async acquireWrite(payload) {
     return this.request("acquire_write", payload);
   }