@adhdev/daemon-core 0.8.28 → 0.8.30

package/dist/index.mjs

@@ -1640,6 +1640,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) {
@@ -4884,11 +4887,72 @@ import * as path7 from "path";
 import * as os5 from "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
@@ -4910,14 +4974,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,
@@ -4937,6 +5023,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)}`);
         }
@@ -4950,6 +5038,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,
@@ -4980,6 +5116,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));
@@ -5021,10 +5167,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() {
@@ -5065,23 +5262,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 };
@@ -5503,6 +5714,55 @@ ${effect.notification.body || ""}`.trim();
 
 // src/providers/ide-provider-instance.ts
 init_logger();
+
+// src/providers/approval-utils.ts
+var DEFAULT_APPROVAL_POSITIVE_HINTS = [
+  "run",
+  "approve",
+  "accept",
+  "allow once",
+  "always allow",
+  "allow",
+  "yes",
+  "proceed",
+  "continue",
+  "confirm",
+  "save",
+  "ok",
+  "trust"
+];
+function normalizeApprovalLabel(value) {
+  return String(value || "").toLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+}
+function getApprovalPositiveHints(provider) {
+  const customHints = Array.isArray(provider?.approvalPositiveHints) ? provider.approvalPositiveHints.map((hint) => normalizeApprovalLabel(String(hint || ""))).filter(Boolean) : [];
+  return customHints.length > 0 ? customHints : DEFAULT_APPROVAL_POSITIVE_HINTS;
+}
+function pickApprovalButton(buttons, provider) {
+  const labels = (buttons || []).map((button) => String(button || "").trim()).filter(Boolean);
+  if (labels.length === 0) {
+    return { index: 0, label: "Approve" };
+  }
+  const normalizedButtons = labels.map((label) => normalizeApprovalLabel(label));
+  const hints = getApprovalPositiveHints(provider);
+  for (const hint of hints) {
+    const exactIndex = normalizedButtons.findIndex((label) => label === hint);
+    if (exactIndex >= 0) return { index: exactIndex, label: labels[exactIndex] };
+    const prefixIndex = normalizedButtons.findIndex((label) => label.startsWith(hint));
+    if (prefixIndex >= 0) return { index: prefixIndex, label: labels[prefixIndex] };
+    const includeIndex = normalizedButtons.findIndex((label) => label.includes(hint));
+    if (includeIndex >= 0) return { index: includeIndex, label: labels[includeIndex] };
+  }
+  return { index: 0, label: labels[0] };
+}
+function formatAutoApprovalMessage(modalMessage, buttonLabel) {
+  const lines = [`Auto-approved${buttonLabel ? `: ${buttonLabel}` : ""}`];
+  const cleanMessage = String(modalMessage || "").trim();
+  if (cleanMessage) lines.push(cleanMessage);
+  return lines.join("\n");
+}
+
+// src/providers/ide-provider-instance.ts
 var IdeProviderInstance = class {
   type;
   category = "ide";
@@ -5569,6 +5829,8 @@ var IdeProviderInstance = class {
   }
   getState() {
     const cdp = this.context?.cdp;
+    const autoApproveActive = (this.currentStatus === "waiting_approval" || this.cachedChat?.status === "waiting_approval") && this.canAutoApprove();
+    const visibleStatus = autoApproveActive ? "generating" : this.currentStatus;
     const extensionStates = [];
     for (const ext of this.extensions.values()) {
       extensionStates.push(ext.getState());
@@ -5577,13 +5839,13 @@ var IdeProviderInstance = class {
       type: this.type,
       name: this.provider.name,
       category: "ide",
-      status: this.currentStatus,
+      status: visibleStatus,
       activeChat: this.cachedChat ? {
         id: this.cachedChat.id || "active_session",
         title: this.cachedChat.title || this.type,
-        status: this.cachedChat.status || this.currentStatus,
+        status: autoApproveActive && this.cachedChat.status === "waiting_approval" ? "generating" : this.cachedChat.status || visibleStatus,
         messages: this.mergeConversationMessages(this.cachedChat.messages || []),
-        activeModal: this.cachedChat.activeModal || null,
+        activeModal: autoApproveActive ? null : this.cachedChat.activeModal || null,
         inputContent: this.cachedChat.inputContent || ""
       } : null,
       workspace: this.workspace || null,
@@ -5802,7 +6064,9 @@ var IdeProviderInstance = class {
     const chatStatus = chatData?.status;
     if (!chatStatus) return;
     const agentKey = `${this.type}:native`;
-    const agentStatus = chatStatus === "streaming" || chatStatus === "generating" ? "generating" : chatStatus === "waiting_approval" ? "waiting_approval" : "idle";
+    const rawAgentStatus = chatStatus === "streaming" || chatStatus === "generating" ? "generating" : chatStatus === "waiting_approval" ? "waiting_approval" : "idle";
+    const autoApproveActive = rawAgentStatus === "waiting_approval" && this.canAutoApprove();
+    const agentStatus = autoApproveActive ? "generating" : rawAgentStatus;
     const lastMsg = Array.isArray(chatData?.messages) && chatData.messages.length > 0 ? chatData.messages[chatData.messages.length - 1] : null;
     const progressFingerprint = agentStatus === "generating" ? `${lastMsg?.role || ""}:${typeof lastMsg?.content === "string" ? lastMsg.content : JSON.stringify(lastMsg?.content || "")}`.slice(-2e3) : void 0;
     this.currentStatus = agentStatus;
@@ -5834,7 +6098,7 @@ var IdeProviderInstance = class {
     this.applyProviderResponse(chatData, {
       phase: agentStatus === "idle" && (lastStatus === "generating" || lastStatus === "waiting_approval") ? "turn_completed" : "immediate"
     });
-    if (agentStatus === "waiting_approval" && this.settings.autoApprove && !this.autoApproveBusy) {
+    if (rawAgentStatus === "waiting_approval" && autoApproveActive && !this.autoApproveBusy) {
       this.autoApproveViaScript(chatData);
     }
     const monitorEvents = this.monitor.check(agentKey, agentStatus, now, progressFingerprint);
@@ -5985,6 +6249,9 @@ ${effect.notification.body || ""}`.trim();
   updateCdp(cdp) {
     if (this.context) this.context.cdp = cdp;
   }
+  canAutoApprove() {
+    return this.settings.autoApprove !== false && typeof this.provider.scripts?.resolveAction === "function" && !!this.context?.cdp?.isConnected;
+  }
   // ─── Auto-approve via CDP script ────────────────────
   async autoApproveViaScript(_chatData) {
     const cdp = this.context?.cdp;
@@ -5996,17 +6263,15 @@ ${effect.notification.body || ""}`.trim();
     }
     this.autoApproveBusy = true;
     try {
-      let targetButton = _chatData?.activeModal?.buttons?.[0] || "Run";
-      const buttons = _chatData?.activeModal?.buttons || [];
-      for (const b of buttons) {
-        const lower = String(b).toLowerCase().replace(/[^\w]/g, "");
-        if (/^(run|approve|accept|yes|allow|always|proceed|save)/.test(lower)) {
-          targetButton = b;
-          break;
-        }
-      }
+      const { label: targetButton } = pickApprovalButton(_chatData?.activeModal?.buttons, this.provider);
       const script = scriptFn({ action: "approve", button: targetButton, buttonText: targetButton });
       if (!script) return;
+      const now = Date.now();
+      this.appendRuntimeSystemMessage(
+        formatAutoApprovalMessage(_chatData?.activeModal?.message, targetButton),
+        `auto_approval:${now}:${targetButton}`,
+        now
+      );
       LOG.info("IdeInstance", `[IdeInstance:${this.type}] autoApprove: executing resolveAction for "${targetButton}"`);
       let rawResult = await cdp.evaluate(script, 1e4);
       if (typeof rawResult === "string") {
@@ -6028,12 +6293,6 @@ ${effect.notification.body || ""}`.trim();
           LOG.warn("IdeInstance", `[IdeInstance:${this.type}] autoApprove: cdp.send() not available for coordinate click`);
         }
       }
-      this.pushEvent({
-        event: "agent:auto_approved",
-        chatTitle: _chatData?.title || this.provider.name,
-        timestamp: Date.now(),
-        ideType: this.type
-      });
     } catch (e) {
       LOG.warn("IdeInstance", `[IdeInstance:${this.type}] autoApprove error: ${e?.message}`);
     } finally {
@@ -6935,6 +7194,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);
@@ -7115,12 +7414,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`);
@@ -7625,7 +7929,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") {
@@ -9032,6 +9336,7 @@ var CliProviderInstance = class {
   historyWriter;
   runtimeMessages = [];
   instanceId;
+  suppressIdleHistoryReplay = false;
   presentationMode;
   providerSessionId;
   launchMode;
@@ -9059,7 +9364,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) => ({
@@ -9103,7 +9416,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") {
@@ -9147,6 +9460,8 @@ var CliProviderInstance = class {
   getState() {
     const adapterStatus = this.adapter.getStatus();
     const parsedStatus = this.adapter.getScriptParsedStatus?.() || null;
+    const autoApproveActive = adapterStatus.status === "waiting_approval" && this.shouldAutoApprove();
+    const visibleStatus = autoApproveActive ? "generating" : adapterStatus.status;
     const parsedProviderSessionId = typeof parsedStatus?.providerSessionId === "string" ? parsedStatus.providerSessionId.trim() : "";
     if (parsedProviderSessionId) {
       this.promoteProviderSessionId(parsedProviderSessionId);
@@ -9163,6 +9478,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;
@@ -9170,7 +9486,7 @@ var CliProviderInstance = class {
           messagesToSave = messagesToSave.slice(0, lastIdx);
         }
       }
-      if (messagesToSave.length > 0) {
+      if (!shouldSkipReplayPersist && messagesToSave.length > 0) {
         this.historyWriter.appendNewMessages(
           this.type,
           messagesToSave,
@@ -9185,14 +9501,14 @@ var CliProviderInstance = class {
       type: this.type,
       name: this.provider.name,
       category: "cli",
-      status: adapterStatus.status,
+      status: visibleStatus,
       mode: this.presentationMode,
       activeChat: {
         id: `${this.type}_${this.workingDir}`,
         title: parsedStatus?.title || dirName,
-        status: parsedStatus?.status || adapterStatus.status,
+        status: autoApproveActive && parsedStatus?.status === "waiting_approval" ? "generating" : parsedStatus?.status || visibleStatus,
         messages: mergedMessages,
-        activeModal: parsedStatus?.activeModal ?? adapterStatus.activeModal,
+        activeModal: autoApproveActive ? null : parsedStatus?.activeModal ?? adapterStatus.activeModal,
         inputContent: ""
       },
       workspace: this.workingDir,
@@ -9256,7 +9572,16 @@ var CliProviderInstance = class {
     const now = Date.now();
     const adapterStatus = this.adapter.getStatus();
     const parsedStatus = this.adapter.getScriptParsedStatus?.() || null;
-    const newStatus = adapterStatus.status;
+    const rawStatus = adapterStatus.status;
+    const autoApproveActive = rawStatus === "waiting_approval" && this.shouldAutoApprove();
+    if (autoApproveActive) {
+      const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(adapterStatus.activeModal?.buttons, this.provider);
+      this.recordAutoApproval(adapterStatus.activeModal?.message, buttonLabel, now);
+      setTimeout(() => {
+        this.adapter.resolveModal(buttonIndex);
+      }, 0);
+    }
+    const newStatus = autoApproveActive ? "generating" : rawStatus;
     const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
     const chatTitle = `${this.provider.name} \xB7 ${dirName}`;
     const partial = this.adapter.getPartialResponse();
@@ -9265,6 +9590,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) {
@@ -9284,6 +9610,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);
@@ -9464,6 +9791,16 @@ ${effect.notification.body || ""}`.trim();
   get cliName() {
     return this.provider.name;
   }
+  shouldAutoApprove() {
+    return this.settings.autoApprove !== false;
+  }
+  recordAutoApproval(modalMessage, buttonLabel, now = Date.now()) {
+    this.appendRuntimeSystemMessage(
+      formatAutoApprovalMessage(modalMessage, buttonLabel),
+      `auto_approval:${now}:${buttonLabel || "approve"}`,
+      now
+    );
+  }
   recordApprovalSelection(buttonText) {
     const cleanButton = String(buttonText || "").trim();
     if (!cleanButton) return;
@@ -10042,8 +10379,10 @@ var AcpProviderInstance = class {
             input: tc.rawInput ? typeof tc.rawInput === "string" ? tc.rawInput : JSON.stringify(tc.rawInput) : void 0
           });
         }
-        if (this.settings.autoApprove) {
-          this.log.info(`[${this.type}] Auto-approving: ${tc.title || tc.toolCallId}`);
+        if (this.settings.autoApprove !== false) {
+          const toolTitle = tc.title || tc.toolCallId || "tool call";
+          this.log.info(`[${this.type}] Auto-approving: ${toolTitle}`);
+          this.appendSystemMessage(`Auto-approved: ${toolTitle}`);
           const allowOption = params.options.find((o) => o.kind === "allow_once") || params.options.find((o) => o.kind === "allow_always");
           if (allowOption) {
             return { outcome: { outcome: "selected", optionId: allowOption.optionId } };
@@ -10495,6 +10834,18 @@ var AcpProviderInstance = class {
     this.events.push(event);
     if (this.events.length > 50) this.events = this.events.slice(-50);
   }
+  appendSystemMessage(content, timestamp = Date.now()) {
+    const normalizedContent = String(content || "").trim();
+    if (!normalizedContent) return;
+    this.messages.push({
+      role: "system",
+      content: normalizedContent,
+      timestamp
+    });
+    if (this.messages.length > 200) {
+      this.messages = this.messages.slice(-100);
+    }
+  }
   flushEvents() {
     const events = [...this.events];
     this.events = [];
@@ -11001,6 +11352,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;
@@ -11014,6 +11366,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,
@@ -11029,6 +11393,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) {
@@ -12055,7 +12420,7 @@ var ProviderLoader = class _ProviderLoader {
   */
   getSettingValue(type, key) {
     const schemaDef = this.getSettingsSchema(type)[key];
-    const defaultVal = schemaDef ? schemaDef.default : void 0;
+    const defaultVal = schemaDef ? key === "autoApprove" && schemaDef.type === "boolean" ? true : schemaDef.default : void 0;
     try {
       const { loadConfig: loadConfig2 } = (init_config(), __toCommonJS(config_exports));
       const config = loadConfig2();
@@ -12114,13 +12479,32 @@ var ProviderLoader = class _ProviderLoader {
   getSettingsSchema(type) {
     const provider = this.providers.get(type);
     if (!provider) return {};
-    return {
+    const result = {
       ...this.getSyntheticSettings(type, provider),
       ...provider.settings || {}
     };
+    if (result.autoApprove?.type === "boolean") {
+      result.autoApprove = {
+        ...result.autoApprove,
+        default: true,
+        public: true,
+        label: result.autoApprove.label || "Auto Approve",
+        description: result.autoApprove.description || "Automatically approve actionable prompts without sending approval alerts."
+      };
+    }
+    return result;
   }
   getSyntheticSettings(type, provider) {
     const result = {};
+    if (!provider.settings?.autoApprove) {
+      result.autoApprove = {
+        type: "boolean",
+        default: true,
+        public: true,
+        label: "Auto Approve",
+        description: "Automatically approve actionable prompts without sending approval alerts."
+      };
+    }
     if ((provider.category === "cli" || provider.category === "acp") && provider.spawn?.command && !provider.settings?.executablePath) {
       result.executablePath = {
         type: "string",
@@ -13380,6 +13764,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 : "";
@@ -13965,6 +14358,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");
@@ -13990,6 +14428,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);
@@ -14013,6 +14454,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`);
@@ -14030,7 +14477,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}`);
@@ -14041,7 +14490,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");
@@ -14078,7 +14535,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;
   }
@@ -14286,7 +14750,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;
@@ -14296,7 +14760,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;
@@ -14526,7 +14990,43 @@ var AgentStreamPoller = class {
       }
       try {
         await agentStreamManager.syncActiveSession(cdp, parentSessionId);
-        const stream = await agentStreamManager.collectActiveSession(cdp, parentSessionId);
+        let stream = await agentStreamManager.collectActiveSession(cdp, parentSessionId);
+        if (stream?.status === "waiting_approval") {
+          const autoApprove = providerLoader.getSettings(stream.agentType).autoApprove !== false;
+          if (autoApprove && resolvedActiveSessionId) {
+            const provider = providerLoader.getMeta(stream.agentType);
+            const { label: buttonLabel } = pickApprovalButton(stream.activeModal?.buttons, provider);
+            const approved = await agentStreamManager.resolveSessionAction(cdp, resolvedActiveSessionId, "approve", buttonLabel);
+            if (approved) {
+              const effectId = [
+                "auto_approval",
+                resolvedActiveSessionId,
+                String(stream.messages?.length || 0),
+                buttonLabel,
+                String(stream.activeModal?.message || "").trim()
+              ].join(":");
+              stream = {
+                ...stream,
+                status: "streaming",
+                activeModal: void 0,
+                effects: [
+                  ...stream.effects || [],
+                  {
+                    type: "message",
+                    id: effectId,
+                    persist: true,
+                    message: {
+                      role: "system",
+                      senderName: "System",
+                      kind: "system",
+                      content: formatAutoApprovalMessage(stream.activeModal?.message, buttonLabel)
+                    }
+                  }
+                ]
+              };
+            }
+          }
+        }
         this.deps.onStreamsUpdated?.(ideType, stream ? [stream] : []);
       } catch {
       }