@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-web-access/content-find.js

@@ -11,7 +11,7 @@ function editDistanceWithin(left, right, maximum) {
     const current = [i];
     let rowMinimum = i;
     for (let j = 1;j <= right.length; j++) {
-      const value = Math.min((previous[j] ?? 0) + 1, (current[j - 1] ?? 0) + 1, (previous[j - 1] ?? 0) + (left[i - 1] === right[j - 1] ? 0 : 1));
+      const value = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + (left[i - 1] === right[j - 1] ? 0 : 1));
       current[j] = value;
       rowMinimum = Math.min(rowMinimum, value);
     }
@@ -19,7 +19,7 @@ function editDistanceWithin(left, right, maximum) {
       return false;
     previous = current;
   }
-  return (previous[right.length] ?? maximum + 1) <= maximum;
+  return previous[right.length] <= maximum;
 }
 function literalMatches(text, query, caseInsensitive) {
   const haystack = caseInsensitive ? text.toLocaleLowerCase() : text;
@@ -53,62 +53,196 @@ function fuzzyMatches(text, query) {
       const maximum = queryToken.length >= 9 ? 2 : queryToken.length >= 5 ? 1 : 0;
       return editDistanceWithin(queryToken, normalize(token[0]), maximum);
     }));
-    const start = paragraph.index + (first?.index ?? 0);
-    matches.push({ query, start, end: start + (first?.[0].length ?? query.length) });
+    const start = paragraph.index + first.index;
+    matches.push({ query, start, end: start + first[0].length });
   }
   return matches;
 }
-function mergeRanges(textLength, matches) {
+function mergeRanges(ranges) {
+  const merged = [];
+  for (const range of [...ranges].sort((left, right) => left.start - right.start || left.end - right.end)) {
+    const previous = merged.at(-1);
+    if (previous && range.start <= previous.end)
+      previous.end = Math.max(previous.end, range.end);
+    else
+      merged.push({ ...range });
+  }
+  return merged;
+}
+function contextRanges(textLength, matches) {
   const ranges = [];
-  for (const match of [...matches].sort((left, right) => left.start - right.start)) {
-    const start = Math.max(0, match.start - CONTEXT_CHARS);
-    const end = Math.min(textLength, match.end + CONTEXT_CHARS);
-    const previous = ranges.at(-1);
-    if (previous && start <= previous.end) {
-      previous.end = Math.max(previous.end, end);
-      previous.matches.push(match);
-    } else {
-      ranges.push({ start, end, matches: [match] });
-    }
+  for (const match of matches) {
+    ranges.push({
+      start: Math.max(0, match.start - CONTEXT_CHARS),
+      end: Math.min(textLength, match.end + CONTEXT_CHARS)
+    });
   }
-  return ranges;
+  return mergeRanges(ranges);
+}
+function lowerBound(values, target) {
+  let low = 0;
+  let high = values.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (values[middle] < target)
+      low = middle + 1;
+    else
+      high = middle;
+  }
+  return low;
+}
+function upperBound(values, target) {
+  let low = 0;
+  let high = values.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (values[middle] <= target)
+      low = middle + 1;
+    else
+      high = middle;
+  }
+  return low;
 }
 export function findContent(text, queries, mode) {
   const normalizedQueries = [...new Set(queries.map((query) => query.trim()).filter(Boolean))];
-  const matches = normalizedQueries.flatMap((query) => mode === "fuzzy" ? fuzzyMatches(text, query) : literalMatches(text, query, mode === "case-insensitive"));
-  const queryResults = normalizedQueries.map((query) => ({
-    query,
-    matchCount: matches.filter((match) => match.query === query).length
-  }));
+  const occurrences = normalizedQueries.map((query) => {
+    const matches = mode === "fuzzy" ? fuzzyMatches(text, query) : literalMatches(text, query, mode === "case-insensitive");
+    return { query, matches, starts: matches.map((match) => match.start), ends: matches.map((match) => match.end) };
+  });
+  const matches = occurrences.flatMap((result) => result.matches);
+  const queryResults = occurrences.map((result) => ({ query: result.query, matchCount: result.matches.length }));
   const heading = matches.length > 0 ? `Text matches (${mode})` : `Text matches (${mode}): no matches`;
-  const sections = [heading];
-  let formattedLength = heading.length;
-  let returnedMatches = 0;
-  for (const range of mergeRanges(text.length, matches)) {
-    const prefix = range.start > 0 ? "…" : "";
-    const suffix = range.end < text.length ? "…" : "";
-    const snippet = `${prefix}${text.slice(range.start, range.end).replace(/\s+/g, " ").trim()}${suffix}`;
-    const counts = [...new Set(range.matches.map((match) => match.query))].map((query) => `"${query}" ×${range.matches.filter((match) => match.query === query).length}`).join(", ");
-    const section = `${sections.length}. ${counts}
-${snippet}`;
-    if (formattedLength + 2 + section.length > MAX_OUTPUT_CHARS)
-      break;
-    sections.push(section);
-    formattedLength += 2 + section.length;
-    returnedMatches += range.matches.length;
-  }
   const missing = queryResults.filter((result) => result.matchCount === 0).map((result) => `"${result.query}"`);
-  const footer = [
-    ...missing.length > 0 ? [`No matches: ${missing.join(", ")}`] : [],
-    ...returnedMatches < matches.length ? [`Showing ${returnedMatches} of ${matches.length} matches.`] : []
-  ];
-  for (const section of footer) {
-    if (formattedLength + 2 + section.length > MAX_OUTPUT_CHARS)
-      break;
-    sections.push(section);
-    formattedLength += 2 + section.length;
+  const matchingQueries = occurrences.filter((result) => result.matches.length > 0).map((result, index) => ({
+    ...result,
+    id: `Q${index + 1}`,
+    order: index
+  }));
+  const whitespaceRuns = [...text.matchAll(/\s+/g)].map((run) => ({ start: run.index, end: run.index + run[0].length }));
+  const whitespaceStarts = whitespaceRuns.map((run) => run.start);
+  const whitespaceEnds = whitespaceRuns.map((run) => run.end);
+  const whitespaceSavings = [0];
+  for (const run of whitespaceRuns)
+    whitespaceSavings.push(whitespaceSavings.at(-1) + run.end - run.start - 1);
+  function normalizedLength(start, end) {
+    const firstRun = upperBound(whitespaceStarts, start) - 1;
+    if (firstRun >= 0 && whitespaceEnds[firstRun] > start)
+      start = whitespaceEnds[firstRun];
+    if (start >= end)
+      return 0;
+    const lastRun = upperBound(whitespaceStarts, end - 1) - 1;
+    if (lastRun >= 0 && whitespaceEnds[lastRun] >= end)
+      end = whitespaceStarts[lastRun];
+    if (start >= end)
+      return 0;
+    const first = lowerBound(whitespaceStarts, start);
+    const last = upperBound(whitespaceEnds, end);
+    return end - start - (whitespaceSavings[last] - whitespaceSavings[first]);
+  }
+  function rangeCounts(range) {
+    return matchingQueries.flatMap((result) => {
+      const first = lowerBound(result.starts, range.start);
+      const last = upperBound(result.ends, range.end);
+      return last > first ? [{ ...result, count: last - first, firstStart: result.starts[first] }] : [];
+    }).sort((left, right) => left.firstStart - right.firstStart || left.order - right.order);
   }
-  return { text: sections.join(`
+  const legend = matchingQueries.length > 0 ? `Queries: ${matchingQueries.map((result) => `${result.id} = "${result.query}"`).join(", ")}` : "";
+  const missingNotice = missing.length > 0 ? `No matches: ${missing.join(", ")}` : "";
+  function measure(ranges, overflow = false, omitted = []) {
+    let length = heading.length;
+    let returnedMatches = 0;
+    if (overflow && legend)
+      length += 2 + legend.length;
+    for (const [index, range] of ranges.entries()) {
+      const counts = rangeCounts(range);
+      if (counts.length === 0)
+        continue;
+      const labelsLength = counts.reduce((total, result) => total + (overflow ? result.id.length : result.query.length + 2) + 2 + String(result.count).length, 2 * (counts.length - 1));
+      const snippetLength = normalizedLength(range.start, range.end) + (range.start > 0 ? 1 : 0) + (range.end < text.length ? 1 : 0);
+      length += 2 + String(index + 1).length + 2 + labelsLength + 1 + snippetLength;
+      returnedMatches += counts.reduce((total, result) => total + result.count, 0);
+    }
+    if (missingNotice)
+      length += 2 + missingNotice.length;
+    if (omitted.length > 0)
+      length += 2 + `No representative excerpt: ${omitted.join(", ")}.`.length;
+    if (returnedMatches < matches.length)
+      length += 2 + `Showing ${returnedMatches} of ${matches.length} matches.`.length;
+    return { length, returnedMatches };
+  }
+  function formatRanges(ranges, overflow = false, omitted = []) {
+    const sections = [heading];
+    let returnedMatches = 0;
+    if (overflow && legend)
+      sections.push(legend);
+    for (const [index, range] of ranges.entries()) {
+      const contained = rangeCounts(range);
+      if (contained.length === 0)
+        continue;
+      const prefix = range.start > 0 ? "…" : "";
+      const suffix = range.end < text.length ? "…" : "";
+      const snippet = `${prefix}${text.slice(range.start, range.end).replace(/\s+/g, " ").trim()}${suffix}`;
+      const counts = contained.map((result) => `${overflow ? result.id : `"${result.query}"`} ×${result.count}`).join(", ");
+      sections.push(`${index + 1}. ${counts}
+${snippet}`);
+      returnedMatches += contained.reduce((total, result) => total + result.count, 0);
+    }
+    if (missingNotice)
+      sections.push(missingNotice);
+    if (omitted.length > 0)
+      sections.push(`No representative excerpt: ${omitted.join(", ")}.`);
+    if (returnedMatches < matches.length)
+      sections.push(`Showing ${returnedMatches} of ${matches.length} matches.`);
+    return { text: sections.join(`
 
 `), matchCount: matches.length, returnedMatches, queryResults };
+  }
+  const fullRanges = contextRanges(text.length, matches);
+  const full = measure(fullRanges);
+  if (full.returnedMatches === matches.length && full.length <= MAX_OUTPUT_CHARS)
+    return formatRanges(fullRanges);
+  let ranges = [];
+  let omitted = matchingQueries.map((result) => result.id);
+  if (measure(ranges, true, omitted).length > MAX_OUTPUT_CHARS) {
+    const text = `${heading}
+
+Unable to format bounded excerpts: query metadata exceeds ${MAX_OUTPUT_CHARS} characters.
+
+Showing 0 of ${matches.length} matches.`;
+    return { text, matchCount: matches.length, returnedMatches: 0, queryResults };
+  }
+  const witnesses = [];
+  for (const { id, matches: queryMatches } of matchingQueries) {
+    const proposedOmitted = omitted.filter((queryId) => queryId !== id);
+    const currentLength = measure(ranges, true, omitted).length;
+    let selected;
+    for (const witness of queryMatches) {
+      const proposedRanges = mergeRanges([...ranges, { start: witness.start, end: witness.end }]);
+      const summary = measure(proposedRanges, true, proposedOmitted);
+      const candidate = {
+        witness,
+        ranges: proposedRanges,
+        cost: summary.length - currentLength
+      };
+      if (summary.length <= MAX_OUTPUT_CHARS && (!selected || candidate.cost < selected.cost || candidate.cost === selected.cost && (witness.start < selected.witness.start || witness.start === selected.witness.start && witness.end < selected.witness.end)))
+        selected = candidate;
+    }
+    if (selected) {
+      ranges = selected.ranges;
+      omitted = proposedOmitted;
+      witnesses.push(selected.witness);
+    }
+  }
+  for (const witness of witnesses) {
+    const proposed = mergeRanges([...ranges, {
+      start: Math.max(0, witness.start - CONTEXT_CHARS),
+      end: Math.min(text.length, witness.end + CONTEXT_CHARS)
+    }]);
+    if (measure(proposed, true, omitted).length <= MAX_OUTPUT_CHARS)
+      ranges = proposed;
+  }
+  const allOccurrences = mergeRanges([...ranges, ...matches.map((match) => ({ start: match.start, end: match.end }))]);
+  if (measure(allOccurrences, true, omitted).length <= MAX_OUTPUT_CHARS)
+    ranges = allOccurrences;
+  return formatRanges(ranges, true, omitted);
 }

package/extensions/dm-web-access/crawl4ai.js

@@ -0,0 +1,166 @@
+import { existsSync, readFileSync } from "node:fs";
+import { activityMonitor } from "./activity.js";
+import { redactCredential, resolveCredential } from "./credential-source.js";
+import { fetchRemoteUrl, loadSsrfConfig, validateRemoteUrl } from "./ssrf-protection.js";
+import { getWebSearchConfigPath, isLoopbackHostname } from "./utils.js";
+const CONFIG_PATH = getWebSearchConfigPath();
+const EXTRACT_TIMEOUT_MS = 60000;
+const MARKDOWN_FILTER = "fit";
+let cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH)) {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+  const raw = readFileSync(CONFIG_PATH, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Invalid config in ${CONFIG_PATH}: expected a JSON object`);
+  }
+  cachedConfig = parsed;
+  return cachedConfig;
+}
+export function clearCrawl4aiConfigCache() {
+  cachedConfig = null;
+}
+function normalizeBaseUrl(value) {
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return null;
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw new Error(`Invalid Crawl4AI base URL in ${CONFIG_PATH}: expected an HTTP or HTTPS URL`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`Invalid Crawl4AI base URL in ${CONFIG_PATH}: expected an HTTP or HTTPS URL`);
+  }
+  if (parsed.username || parsed.password) {
+    throw new Error(`Invalid Crawl4AI base URL in ${CONFIG_PATH}: URL credentials are not allowed`);
+  }
+  parsed.pathname = parsed.pathname.replace(/\/+$/, "");
+  parsed.search = "";
+  parsed.hash = "";
+  return parsed.toString().replace(/\/+$/, "");
+}
+function getBaseUrl() {
+  return normalizeBaseUrl(process.env.CRAWL4AI_BASE_URL) ?? normalizeBaseUrl(loadConfig().crawl4aiBaseUrl);
+}
+function requireBaseUrl() {
+  const baseUrl = getBaseUrl();
+  if (!baseUrl) {
+    throw new Error(`Crawl4AI base URL not configured. Either:
+` + `  1. Set crawl4aiBaseUrl in ${CONFIG_PATH}
+` + "  2. Set CRAWL4AI_BASE_URL environment variable");
+  }
+  return baseUrl;
+}
+async function getApiToken(signal) {
+  return resolveCredential({
+    provider: "Crawl4AI",
+    configuredValue: loadConfig().crawl4aiApiToken,
+    environmentValue: process.env.CRAWL4AI_API_TOKEN,
+    signal
+  });
+}
+function requestSignal(timeoutMs, signal) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([timeout, signal]) : timeout;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function isAbortException(err) {
+  return err instanceof DOMException && (err.name === "AbortError" || err.name === "TimeoutError");
+}
+function ssrfOptions(options) {
+  return {
+    ...options?.ssrf ?? loadSsrfConfig(),
+    ...options?.lookup ? { lookup: options.lookup } : {}
+  };
+}
+function firstHeadingTitle(markdown) {
+  return /^[ \t]*#[ \t]+(\S.*?)[ \t\r]*$/m.exec(markdown)?.[1] ?? "";
+}
+export function isCrawl4aiAvailable() {
+  return getBaseUrl() !== null;
+}
+export async function extractWithCrawl4ai(url, signal, options) {
+  const baseUrl = requireBaseUrl();
+  const ssrf = ssrfOptions(options);
+  await validateRemoteUrl(url, ssrf);
+  const token = await getApiToken(signal);
+  const headers = { "Content-Type": "application/json" };
+  if (token)
+    headers.Authorization = `Bearer ${token}`;
+  const requestUrl = new URL(`${baseUrl}/md`);
+  const init = {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ url, f: MARKDOWN_FILTER }),
+    signal: requestSignal(options?.timeoutMs ?? EXTRACT_TIMEOUT_MS, signal)
+  };
+  let seeOther = false;
+  const activityId = activityMonitor.logStart({ type: "fetch", url: requestUrl.toString() });
+  try {
+    const response = await fetchRemoteUrl(requestUrl, init, {
+      ...ssrf,
+      allowLoopback: isLoopbackHostname(requestUrl.hostname),
+      onRedirect: ({ to, init: redirectInit, response }) => {
+        if (to.origin !== requestUrl.origin) {
+          throw new Error(`Crawl4AI refused cross-origin redirect to ${to.origin}`);
+        }
+        if (response.status === 303)
+          seeOther = true;
+        const replayPost = !seeOther && (response.status === 301 || response.status === 302);
+        return replayPost ? init : redirectInit;
+      }
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(`Crawl4AI md error ${response.status}: ${redactCredential(text, token).slice(0, 300)}`);
+    }
+    let data;
+    try {
+      data = await response.json();
+    } catch {
+      throw new Error("Crawl4AI md returned invalid JSON");
+    }
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      throw new Error("Crawl4AI md returned an unexpected response shape");
+    }
+    const envelope = data;
+    if (envelope.success === false) {
+      const detail = typeof envelope.error === "string" ? envelope.error : typeof envelope.detail === "string" ? envelope.detail : "";
+      throw new Error(`Crawl4AI md unsuccessful: ${redactCredential(detail.trim() || "unknown error", token)}`);
+    }
+    if (envelope.success !== true) {
+      throw new Error("Crawl4AI md returned an unexpected response shape");
+    }
+    if (typeof envelope.markdown !== "string") {
+      throw new Error("Crawl4AI md returned markdown in an unexpected shape");
+    }
+    activityMonitor.logComplete(activityId, response.status);
+    const content = envelope.markdown.trim();
+    if (!content)
+      return null;
+    return { url, title: firstHeadingTitle(content), content, error: null };
+  } catch (err) {
+    if (signal?.aborted || isAbortException(err))
+      activityMonitor.logComplete(activityId, 0);
+    else
+      activityMonitor.logError(activityId, errorMessage(err));
+    throw err;
+  }
+}

package/extensions/dm-web-access/credential-source.js

@@ -9,6 +9,7 @@ const COMMAND_ENVIRONMENT_NAMES = [
   "HOME",
   "USER",
   "LOGNAME",
+  "OP_SERVICE_ACCOUNT_TOKEN",
   "PATH",
   "LANG",
   "LC_ALL",

package/extensions/dm-web-access/curator-page.js

@@ -28,9 +28,13 @@ function buildProviderButtons(available, selected, hasInitialQueries) {
     { value: "anysearch", label: "AnySearch", available: available.anysearch },
     { value: "xcrawl", label: "XCrawl", available: available.xcrawl },
     { value: "xai", label: "xAI", available: available.xai },
+    { value: "mistral", label: "Mistral", available: available.mistral },
     { value: "brightdata", label: "Bright Data", available: available.brightdata },
     { value: "serpbase", label: "SerpBase", available: available.serpbase },
+    { value: "serpapi", label: "SerpApi", available: available.serpapi },
     { value: "serper", label: "Serper", available: available.serper },
+    { value: "serply", label: "Serply", available: available.serply },
+    { value: "baizhi", label: "Baizhi", available: available.baizhi },
     { value: "valyu", label: "Valyu", available: available.valyu }
   ];
   return providers.filter((p) => p.available).map((p) => {
@@ -121,6 +125,7 @@ ${CSS}
 <button class="btn btn-secondary" id="btn-summary-regenerate">Regenerate</button>
 <button class="btn btn-secondary" id="btn-summary-preview" title="Preview rendered summary">Preview</button>
 <button class="btn btn-submit" id="btn-summary-approve">Approve</button>
+<button class="btn btn-submit" id="btn-summary-approve-remaining">Approve + auto-summary remaining searches for this prompt</button>
 </div>
 </section>
 </main>
@@ -1168,6 +1173,7 @@ main {
 }
 .summary-actions {
   display: flex;
+  flex-wrap: wrap;
   align-items: center;
   justify-content: flex-end;
   gap: 8px;
@@ -1439,7 +1445,7 @@ const SCRIPT = `(function() {
   var token = DATA.sessionToken;
   var timeoutSec = DATA.timeout;
   var queries = Array.isArray(DATA.queries) ? DATA.queries : [];
-  var providers = ["all", "openai", "exa", "brave", "parallel", "parallel-mcp", "tinyfish", "search1api", "searchinfinity", "querit", "tavily", "firecrawl", "jina", "serpdive", "kagi", "bocha", "ollama", "searxng", "duckduckgo", "perplexity", "gemini", "kimi", "anysearch", "xcrawl", "xai", "brightdata", "serpbase", "serper", "valyu"];
+  var providers = ["auto", "all", "openai", "exa", "brave", "parallel", "parallel-mcp", "tinyfish", "search1api", "searchinfinity", "querit", "tavily", "firecrawl", "jina", "serpdive", "kagi", "bocha", "ollama", "searxng", "duckduckgo", "perplexity", "gemini", "kimi", "anysearch", "xcrawl", "xai", "mistral", "brightdata", "serpbase", "serpapi", "serper", "serply", "valyu", "baizhi"];
   var availProviders = DATA.availableProviders && typeof DATA.availableProviders === "object" ? DATA.availableProviders : {};
   var workflow = "summary-review";
   var initialDefaultProvider = typeof DATA.defaultProvider === "string" ? DATA.defaultProvider : "exa";
@@ -1504,6 +1510,7 @@ const SCRIPT = `(function() {
   var btnSummaryRegenerate = document.getElementById("btn-summary-regenerate");
   var btnSummaryPreview = document.getElementById("btn-summary-preview");
   var btnSummaryApprove = document.getElementById("btn-summary-approve");
+  var btnSummaryApproveRemaining = document.getElementById("btn-summary-approve-remaining");
   var successOverlay = document.getElementById("success-overlay");
   var successText = document.getElementById("success-text");
   var expiredOverlay = document.getElementById("expired-overlay");
@@ -1642,6 +1649,7 @@ const SCRIPT = `(function() {
   }
 
   function providerLabel(provider) {
+    if (provider === "auto") return "Auto";
     if (provider === "all") return "All";
     if (provider === "openai") return "OpenAI";
     if (provider === "brave") return "Brave";
@@ -1666,8 +1674,14 @@ const SCRIPT = `(function() {
     if (provider === "anysearch") return "AnySearch";
     if (provider === "xcrawl") return "XCrawl";
     if (provider === "xai") return "xAI";
+    if (provider === "mistral") return "Mistral";
     if (provider === "brightdata") return "Bright Data";
     if (provider === "serpbase") return "SerpBase";
+    if (provider === "serpapi") return "SerpApi";
+    if (provider === "serper") return "Serper";
+    if (provider === "serply") return "Serply";
+    if (provider === "baizhi") return "Baizhi";
+    if (provider === "valyu") return "Valyu";
     return "Unknown";
   }
 
@@ -2083,6 +2097,9 @@ const SCRIPT = `(function() {
     if (btnSummaryApprove) {
       btnSummaryApprove.disabled = submitted || timerExpired || submitInFlight || stage === "generating-summary" || isRegenerating || !hasSelection || !hasDraft;
     }
+    if (btnSummaryApproveRemaining) {
+      btnSummaryApproveRemaining.disabled = submitted || timerExpired || submitInFlight || stage === "generating-summary" || isRegenerating || !hasSelection || !hasDraft;
+    }
 
     applyProviderInterlocks();
   }
@@ -3174,7 +3191,7 @@ const SCRIPT = `(function() {
     requestSummary(selected);
   }
 
-  function doApprove() {
+  function doApprove(autoApproveRemainingSearches) {
     if (submitted || timerExpired || submitInFlight || stage !== "summary-review") return;
 
     var selected = getSelectedIndices();
@@ -3186,6 +3203,7 @@ const SCRIPT = `(function() {
 
     var draft = getSummaryDraftText();
     var payload = { selected: selected };
+    if (autoApproveRemainingSearches === true) payload.autoApproveRemainingSearches = true;
     if (draft.length > 0) {
       payload.summary = draft;
       payload.summaryMeta = normalizeSummaryMeta(summaryMeta, summaryMeta && summaryMeta.edited === true);
@@ -3424,6 +3442,13 @@ const SCRIPT = `(function() {
     });
   }
 
+  if (btnSummaryApproveRemaining) {
+    btnSummaryApproveRemaining.addEventListener("click", function() {
+      doApprove(true);
+      resetTimer();
+    });
+  }
+
   if (summaryInput) {
     summaryInput.addEventListener("input", function() {
       if (!summaryMeta || typeof summaryMeta !== "object") {

package/extensions/dm-web-access/curator-run.js

@@ -0,0 +1,36 @@
+export function resolveWebSearchWorkflow(input, hasUI) {
+  const normalized = typeof input === "string" ? input.trim().toLowerCase() : "";
+  if (normalized === "auto-summary")
+    return "auto-summary";
+  if (!hasUI)
+    return "none";
+  if (normalized === "none")
+    return "none";
+  if (normalized === "summary-review")
+    return "summary-review";
+  return "none";
+}
+
+export class CuratorRunState {
+  autoApproveRemaining = false;
+  approveRemainingSearches() {
+    this.autoApproveRemaining = true;
+  }
+  reset() {
+    this.autoApproveRemaining = false;
+  }
+  resolve(requestedWorkflow, configuredWorkflow, hasUI) {
+    const inherited = requestedWorkflow === undefined;
+    const workflow = resolveWebSearchWorkflow(inherited ? configuredWorkflow : requestedWorkflow, hasUI);
+    return inherited && this.autoApproveRemaining && workflow === "summary-review" ? "auto-summary" : workflow;
+  }
+}
+export function registerCuratorRunLifecycle(pi) {
+  const state = new CuratorRunState;
+  pi.on("before_agent_start", () => state.reset());
+  pi.on("agent_end", () => state.reset());
+  pi.on("session_start", () => state.reset());
+  pi.on("session_tree", () => state.reset());
+  pi.on("session_shutdown", () => state.reset());
+  return state;
+}

package/extensions/dm-web-access/curator-server.js

@@ -114,6 +114,7 @@ function normalizeSummaryMeta(value) {
 export function startCuratorServer(options, callbacks) {
   const {
     queries,
+    initialResultIndexCapacity,
     sessionToken,
     timeout,
     availableProviders,
@@ -133,7 +134,7 @@ export function startCuratorServer(options, callbacks) {
   let sseResponse = null;
   const streamedEventsByResultIndex = new Map;
   let searchStreamDone = queries.length === 0;
-  let nextQueryIndex = queries.length;
+  let nextQueryIndex = Math.max(queries.length, initialResultIndexCapacity ?? queries.length);
   let summarizeAbortController = null;
   let summarizeRequestSeq = 0;
   let sseKeepalive = null;
@@ -234,12 +235,18 @@ export function startCuratorServer(options, callbacks) {
       return availableProviders.xcrawl;
     if (provider === "xai")
       return availableProviders.xai;
+    if (provider === "mistral")
+      return availableProviders.mistral;
     if (provider === "brightdata")
       return availableProviders.brightdata;
     if (provider === "serpbase")
       return availableProviders.serpbase;
     if (provider === "serper")
       return availableProviders.serper;
+    if (provider === "serply")
+      return availableProviders.serply;
+    if (provider === "baizhi")
+      return availableProviders.baizhi;
     if (provider === "valyu")
       return availableProviders.valyu;
     return false;
@@ -572,12 +579,14 @@ data: ${JSON.stringify(data)}
           return;
         }
         const rawResults = body.rawResults === true;
+        const autoApproveRemainingSearches = body.autoApproveRemainingSearches === true;
         sendJson(res, 200, { ok: true });
         setImmediate(() => callbacks.onSubmit({
           selectedQueryIndices: parsed.indices,
           ...summary !== undefined ? { summary } : {},
           ...summaryMeta !== undefined ? { summaryMeta } : {},
-          rawResults
+          rawResults,
+          ...autoApproveRemainingSearches ? { autoApproveRemainingSearches: true } : {}
         }));
         return;
       }

package/extensions/dm-web-access/domain-filter-normalization.js

@@ -0,0 +1,17 @@
+export function normalizeDomain(value) {
+  let input = value.trim().toLowerCase();
+  if (!input)
+    return null;
+  if (input.startsWith("-"))
+    input = input.slice(1).trim();
+  if (!input)
+    return null;
+  try {
+    const parsed = input.includes("://") ? new URL(input) : new URL(`https://${input}`);
+    input = parsed.hostname;
+  } catch {
+    input = input.split("/")[0]?.split(":")[0] ?? "";
+  }
+  input = input.replace(/^\.+|\.+$/g, "");
+  return /^[a-z0-9][a-z0-9.-]*\.[a-z]{2,}$/i.test(input) ? input : null;
+}