@adhdev/daemon-core 0.8.28 → 0.8.29

package/dist/index.js

@@ -1642,6 +1642,9 @@ var init_provider_cli_adapter = __esm({
       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) {
@@ -4969,11 +4972,72 @@ var path7 = __toESM(require("path"));
 var os5 = __toESM(require("os"));
 var HISTORY_DIR = path7.join(os5.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
@@ -4995,14 +5059,36 @@ var ChatHistoryWriter = class {
       }
       const newMessages = [];
       for (const msg of messages) {
-        const hash = 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 hash = 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(hash)) continue;
+        if (this.lastSeenSignatures.get(dedupKey) === signature) continue;
+        if (role !== "system" && this.lastSeenTurnSignatures.get(dedupKey) === signature) continue;
         seenHashes.add(hash);
+        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,
@@ -5022,6 +5108,8 @@ var ChatHistoryWriter = class {
       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)}`);
         }
@@ -5035,6 +5123,54 @@ var ChatHistoryWriter = class {
     } 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,
@@ -5065,6 +5201,16 @@ var ChatHistoryWriter = class {
         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));
@@ -5106,10 +5252,61 @@ var ChatHistoryWriter = class {
     } catch {
     }
   }
+  compactHistorySession(agentType, historySessionId) {
+    const sessionId = String(historySessionId || "").trim();
+    if (!sessionId) return;
+    try {
+      const dir = path7.join(HISTORY_DIR, this.sanitize(agentType));
+      if (!fs3.existsSync(dir)) return;
+      const prefix = `${this.sanitize(sessionId)}_`;
+      const files = fs3.readdirSync(dir).filter((file) => file.startsWith(prefix) && file.endsWith(".jsonl")).sort();
+      const seen = /* @__PURE__ */ new Set();
+      for (const file of files) {
+        const filePath = path7.join(dir, file);
+        const lines = fs3.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 hash = buildHistoryMessageHash(agentType, sanitized);
+          if (seen.has(hash)) continue;
+          seen.add(hash);
+          next.push(sanitized);
+        }
+        next.sort((a, b) => a.receivedAt - b.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) {
+          fs3.unlinkSync(filePath);
+          continue;
+        }
+        fs3.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() {
@@ -5150,23 +5347,37 @@ function readChatHistory(agentType, offset = 0, limit = 30, historySessionId) {
       return true;
     }).sort().reverse();
     const allMessages = [];
-    const needed = offset + limit + 1;
+    const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
-      if (allMessages.length >= needed) break;
       const filePath = path7.join(dir, file);
       const content = fs3.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 hash = buildHistoryMessageHash(agentType, sanitizedMessage);
+          if (seen.has(hash)) continue;
+          seen.add(hash);
+          allMessages.push(sanitizedMessage);
         } catch {
         }
       }
     }
-    const sliced = allMessages.slice(offset, offset + limit);
-    const hasMore = allMessages.length > offset + limit;
-    sliced.reverse();
+    allMessages.sort((a, b) => a.receivedAt - b.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 };
@@ -7020,6 +7231,46 @@ function didProviderConfirmSend(result) {
   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);
@@ -7200,12 +7451,17 @@ async function handleSendChat(h, args) {
   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`);
@@ -7710,7 +7966,7 @@ async function handleResolveAction(h, args) {
     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") {
@@ -9117,6 +9373,7 @@ var CliProviderInstance = class {
   historyWriter;
   runtimeMessages = [];
   instanceId;
+  suppressIdleHistoryReplay = false;
   presentationMode;
   providerSessionId;
   launchMode;
@@ -9144,7 +9401,15 @@ var CliProviderInstance = class {
     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) => ({
@@ -9188,7 +9453,7 @@ var CliProviderInstance = class {
       } 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") {
@@ -9248,6 +9513,7 @@ var CliProviderInstance = class {
     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;
@@ -9255,7 +9521,7 @@ var CliProviderInstance = class {
           messagesToSave = messagesToSave.slice(0, lastIdx);
         }
       }
-      if (messagesToSave.length > 0) {
+      if (!shouldSkipReplayPersist && messagesToSave.length > 0) {
         this.historyWriter.appendNewMessages(
           this.type,
           messagesToSave,
@@ -9350,6 +9616,7 @@ var CliProviderInstance = class {
     if (newStatus !== this.lastStatus) {
       LOG.info("CLI", `[${this.type}] status: ${this.lastStatus} \u2192 ${newStatus}`);
       if (this.lastStatus === "idle" && newStatus === "generating") {
+        this.suppressIdleHistoryReplay = false;
         if (this.completedDebouncePending) {
           LOG.info("CLI", `[${this.type}] cancelled pending completed (resumed generating)`);
           if (this.completedDebounceTimer) {
@@ -9369,6 +9636,7 @@ var CliProviderInstance = class {
           this.generatingDebounceTimer = null;
         }, 1e3);
       } else if (newStatus === "waiting_approval") {
+        this.suppressIdleHistoryReplay = false;
         if (this.generatingDebouncePending) {
           if (this.generatingDebounceTimer) {
             clearTimeout(this.generatingDebounceTimer);
@@ -11081,6 +11349,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 record of sessions) {
       if (!record?.runtimeId || !record?.cliType || !record?.workspace) continue;
       if (this.adapters.has(record.runtimeId) || instanceManager.getInstance(record.runtimeId)) continue;
@@ -11094,6 +11363,18 @@ Run 'adhdev doctor' for detailed diagnostics.`
         record.cliArgs,
         record.providerSessionId
       );
+      const bindingKey = [
+        normalizedType,
+        record.workspace,
+        sessionBinding.providerSessionId || record.runtimeId
+      ].join("::");
+      if (restoredBindings.has(bindingKey)) {
+        LOG.info(
+          "CLI",
+          `\u21B7 Skipping duplicate hosted runtime restore: ${record.runtimeKey || record.runtimeId} (${normalizedType} @ ${record.workspace}) binding=${sessionBinding.providerSessionId || "runtime"}`
+        );
+        continue;
+      }
       try {
         await this.registerCliInstance(
           record.runtimeId,
@@ -11109,6 +11390,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             launchMode: "manual"
           }
         );
+        restoredBindings.add(bindingKey);
         restored += 1;
         LOG.info("CLI", `\u267B Restored hosted runtime: ${record.runtimeKey || record.runtimeId} (${record.displayName || record.workspace})`);
       } catch (error) {
@@ -13460,6 +13742,15 @@ var DaemonCommandRouter = class {
         const record = await this.deps.sessionHostControl.forceDetachClient(sessionId, clientId);
         return { success: true, record };
       }
+      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 : "";
@@ -14045,6 +14336,51 @@ var ProviderStreamAdapter = class {
   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");
@@ -14070,6 +14406,9 @@ var ProviderStreamAdapter = class {
         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);
@@ -14093,6 +14432,12 @@ var ProviderStreamAdapter = class {
     }
   }
   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`);
@@ -14110,7 +14455,9 @@ var ProviderStreamAdapter = class {
     }
     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}`);
@@ -14121,7 +14468,15 @@ var ProviderStreamAdapter = class {
   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");
@@ -14158,7 +14513,14 @@ var ProviderStreamAdapter = class {
       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;
   }
@@ -14366,7 +14728,7 @@ var DaemonAgentStreamManager = class {
       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;
@@ -14376,7 +14738,7 @@ var DaemonAgentStreamManager = class {
     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;