@duckmind/dm-windows-x64 0.63.0 → 0.63.6

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

@@ -0,0 +1,238 @@
+import { existsSync, readFileSync } from "node:fs";
+import { activityMonitor } from "./activity.js";
+import { hasCredentialSource, redactCredential, resolveCredential } from "./credential-source.js";
+import { getWebSearchConfigPath } from "./utils.js";
+const SERPDIVE_API_URL = "https://api.serpdive.com/v1/search";
+const CONFIG_PATH = getWebSearchConfigPath();
+const SEARCH_TIMEOUT_MS = 60000;
+const MODELS = ["krill", "mako", "moby"];
+const DEFAULT_MODEL = "krill";
+let cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH)) {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+  const raw = readFileSync(CONFIG_PATH, "utf-8");
+  try {
+    cachedConfig = JSON.parse(raw);
+    return cachedConfig;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+  }
+}
+async function getApiKey(signal) {
+  return resolveCredential({
+    provider: "SERPdive",
+    configuredValue: loadConfig().serpdiveApiKey,
+    environmentValue: process.env.SERPDIVE_API_KEY,
+    signal
+  });
+}
+async function requireApiKey(signal) {
+  const apiKey = await getApiKey(signal);
+  if (!apiKey) {
+    throw new Error(`SERPdive API key not found. Either:
+` + `  1. Create ${CONFIG_PATH} with { "serpdiveApiKey": "your-key" }
+` + `  2. Set SERPDIVE_API_KEY environment variable
+` + "Get a key at https://serpdive.com/dashboard/keys");
+  }
+  return apiKey;
+}
+function resolveModel() {
+  const raw = process.env.SERPDIVE_MODEL ?? loadConfig().serpdiveModel;
+  if (typeof raw !== "string")
+    return DEFAULT_MODEL;
+  const value = raw.trim().toLowerCase();
+  return MODELS.includes(value) ? value : DEFAULT_MODEL;
+}
+function normalizeCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return 5;
+  return Math.max(1, Math.min(Math.floor(value), 20));
+}
+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;
+}
+function parseDomainFilter(domainFilter) {
+  const filters = { include: [], exclude: [] };
+  if (!domainFilter?.length)
+    return filters;
+  for (const raw of domainFilter) {
+    const domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    const target = raw.trim().startsWith("-") ? filters.exclude : filters.include;
+    if (!target.includes(domain))
+      target.push(domain);
+  }
+  return filters;
+}
+function domainMatches(hostname, domain) {
+  return hostname === domain || hostname.endsWith(`.${domain}`);
+}
+function passesDomainFilters(url, filters) {
+  if (filters.include.length === 0 && filters.exclude.length === 0)
+    return true;
+  let hostname;
+  try {
+    hostname = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (filters.exclude.some((domain) => domainMatches(hostname, domain)))
+    return false;
+  if (filters.include.length === 0)
+    return true;
+  return filters.include.some((domain) => domainMatches(hostname, domain));
+}
+function applyRecencyHint(query, recencyFilter) {
+  if (!recencyFilter)
+    return query;
+  const hints = {
+    day: "past 24 hours",
+    week: "past week",
+    month: "past month",
+    year: "past year"
+  };
+  const hint = hints[recencyFilter];
+  return hint ? `${query} ${hint}` : query;
+}
+function requestSignal(signal) {
+  const timeout = AbortSignal.timeout(SEARCH_TIMEOUT_MS);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function mapResults(results, numResults, filters) {
+  if (!Array.isArray(results))
+    return [];
+  const mapped = [];
+  for (const item of results) {
+    if (!item?.url || !passesDomainFilters(item.url, filters))
+      continue;
+    mapped.push({
+      title: item.title || `Source ${mapped.length + 1}`,
+      url: item.url,
+      snippet: typeof item.content === "string" ? item.content.replace(/\s+/g, " ").trim() : ""
+    });
+    if (mapped.length >= numResults)
+      break;
+  }
+  return mapped;
+}
+function mapInlineContent(results, filters) {
+  if (!Array.isArray(results))
+    return [];
+  return results.flatMap((item) => {
+    if (!item?.url || !passesDomainFilters(item.url, filters))
+      return [];
+    if (typeof item.content !== "string" || item.content.trim().length === 0)
+      return [];
+    return [{
+      url: item.url,
+      title: item.title || "",
+      content: item.content,
+      error: null
+    }];
+  });
+}
+function buildAnswer(apiAnswer, results) {
+  if (typeof apiAnswer === "string" && apiAnswer.trim().length > 0)
+    return apiAnswer;
+  return results.map((result) => {
+    if (result.snippet)
+      return `${result.snippet}
+Source: ${result.title} (${result.url})`;
+    return `Source: ${result.title} (${result.url})`;
+  }).join(`
+
+`);
+}
+export function isSerpdiveAvailable() {
+  return hasCredentialSource({
+    provider: "SERPdive",
+    configuredValue: loadConfig().serpdiveApiKey,
+    environmentValue: process.env.SERPDIVE_API_KEY
+  });
+}
+export async function searchWithSerpdive(query, options = {}) {
+  const apiKey = await requireApiKey(options.signal);
+  const numResults = normalizeCount(options.numResults);
+  const filters = parseDomainFilter(options.domainFilter);
+  const model = resolveModel();
+  const body = {
+    query: applyRecencyHint(query, options.recencyFilter),
+    model,
+    max_results: Math.min(numResults, 10),
+    ...model === "krill" ? {} : { answer: true }
+  };
+  const activityId = activityMonitor.logStart({ type: "api", query });
+  let response;
+  try {
+    response = await fetch(SERPDIVE_API_URL, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: requestSignal(options.signal)
+    });
+  } catch (err) {
+    const message = errorMessage(err);
+    const redactedMessage = redactCredential(message, apiKey);
+    if (redactedMessage.toLowerCase().includes("abort"))
+      activityMonitor.logComplete(activityId, 0);
+    else
+      activityMonitor.logError(activityId, redactedMessage);
+    if (redactedMessage === message)
+      throw err;
+    const redactedError = new Error(redactedMessage);
+    if (err instanceof Error)
+      redactedError.name = err.name;
+    throw redactedError;
+  }
+  if (!response.ok) {
+    activityMonitor.logComplete(activityId, response.status);
+    const errorText = redactCredential(await response.text(), apiKey);
+    throw new Error(`SERPdive API error ${response.status}: ${errorText.slice(0, 300)}`);
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch (err) {
+    activityMonitor.logComplete(activityId, response.status);
+    throw new Error(`SERPdive API returned invalid JSON: ${errorMessage(err)}`);
+  }
+  activityMonitor.logComplete(activityId, response.status);
+  const results = mapResults(data.results, numResults, filters);
+  const result = {
+    answer: buildAnswer(data.answer, results),
+    results
+  };
+  if (options.includeContent) {
+    const inlineContent = mapInlineContent(data.results, filters);
+    if (inlineContent.length > 0)
+      result.inlineContent = inlineContent;
+  }
+  return result;
+}

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

@@ -0,0 +1,200 @@
+import { existsSync, readFileSync } from "node:fs";
+import { activityMonitor } from "./activity.js";
+import { hasCredentialSource, redactCredential, resolveCredential } from "./credential-source.js";
+import { getWebSearchConfigPath } from "./utils.js";
+const SERPER_SEARCH_URL = "https://google.serper.dev/search";
+const CONFIG_PATH = getWebSearchConfigPath();
+const SEARCH_TIMEOUT_MS = 60000;
+const RECENCY_TBS = {
+  day: "qdr:d",
+  week: "qdr:w",
+  month: "qdr:m",
+  year: "qdr:y"
+};
+let cachedConfig = null;
+function loadConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  if (!existsSync(CONFIG_PATH)) {
+    cachedConfig = {};
+    return cachedConfig;
+  }
+  const raw = readFileSync(CONFIG_PATH, "utf-8");
+  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;
+}
+async function getApiKey(signal) {
+  return resolveCredential({
+    provider: "Serper",
+    configuredValue: loadConfig().serperApiKey,
+    environmentValue: process.env.SERPER_API_KEY,
+    signal
+  });
+}
+async function requireApiKey(signal) {
+  const apiKey = await getApiKey(signal);
+  if (!apiKey) {
+    throw new Error(`Serper API key not found. Either:
+` + `  1. Create ${CONFIG_PATH} with { "serperApiKey": "your-key" }
+` + `  2. Set SERPER_API_KEY environment variable
+` + "Get a key at https://serper.dev");
+  }
+  return apiKey;
+}
+function normalizeCount(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    return 5;
+  return Math.max(1, Math.min(Math.floor(value), 20));
+}
+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;
+}
+function parseDomainFilter(domainFilter) {
+  const filters = { include: [], exclude: [] };
+  for (const raw of domainFilter ?? []) {
+    const domain = normalizeDomain(raw);
+    if (!domain)
+      continue;
+    const target = raw.trim().startsWith("-") ? filters.exclude : filters.include;
+    if (!target.includes(domain))
+      target.push(domain);
+  }
+  return filters;
+}
+function passesDomainFilters(url, filters) {
+  if (filters.include.length === 0 && filters.exclude.length === 0)
+    return true;
+  let hostname;
+  try {
+    hostname = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  const matches = (domain) => hostname === domain || hostname.endsWith(`.${domain}`);
+  if (filters.exclude.some(matches))
+    return false;
+  return filters.include.length === 0 || filters.include.some(matches);
+}
+function buildQuery(query, filters) {
+  const parts = [query];
+  if (filters.include.length === 1)
+    parts.push(`site:${filters.include[0]}`);
+  if (filters.include.length > 1)
+    parts.push(`(${filters.include.map((domain) => `site:${domain}`).join(" OR ")})`);
+  for (const domain of filters.exclude)
+    parts.push(`-site:${domain}`);
+  return parts.join(" ");
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function invalidResponse(message) {
+  return new Error(`Serper API returned invalid response: ${message}`);
+}
+function parseResponse(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw invalidResponse("expected an object envelope");
+  const envelope = value;
+  if (!Array.isArray(envelope.organic))
+    throw invalidResponse("expected organic array");
+  return envelope.organic;
+}
+function buildAnswer(results) {
+  return results.map((result) => result.snippet ? `${result.snippet}
+Source: ${result.title} (${result.url})` : `Source: ${result.title} (${result.url})`).join(`
+
+`);
+}
+export function isSerperAvailable() {
+  return hasCredentialSource({ provider: "Serper", configuredValue: loadConfig().serperApiKey, environmentValue: process.env.SERPER_API_KEY });
+}
+export async function searchWithSerper(query, options = {}) {
+  const apiKey = await requireApiKey(options.signal);
+  const numResults = normalizeCount(options.numResults);
+  const filters = parseDomainFilter(options.domainFilter);
+  const requestCount = options.domainFilter?.length ? Math.min(20, numResults + 5) : numResults;
+  const activityId = activityMonitor.logStart({ type: "api", query });
+  let response;
+  try {
+    response = await fetch(SERPER_SEARCH_URL, {
+      method: "POST",
+      headers: { "X-API-KEY": apiKey, "Content-Type": "application/json", Accept: "application/json" },
+      body: JSON.stringify({ q: buildQuery(query, filters), num: requestCount, ...options.recencyFilter ? { tbs: RECENCY_TBS[options.recencyFilter] } : {} }),
+      signal: options.signal ? AbortSignal.any([AbortSignal.timeout(SEARCH_TIMEOUT_MS), options.signal]) : AbortSignal.timeout(SEARCH_TIMEOUT_MS)
+    });
+  } catch (err) {
+    const message = errorMessage(err);
+    const redactedMessage = redactCredential(message, apiKey);
+    if (redactedMessage.toLowerCase().includes("abort"))
+      activityMonitor.logComplete(activityId, 0);
+    else
+      activityMonitor.logError(activityId, redactedMessage);
+    if (redactedMessage === message)
+      throw err;
+    const redactedError = new Error(redactedMessage);
+    if (err instanceof Error)
+      redactedError.name = err.name;
+    throw redactedError;
+  }
+  if (!response.ok) {
+    activityMonitor.logComplete(activityId, response.status);
+    const errorText = redactCredential(await response.text(), apiKey);
+    throw new Error(`Serper API error ${response.status}: ${errorText.slice(0, 300)}`);
+  }
+  let rawData;
+  try {
+    rawData = await response.json();
+  } catch (err) {
+    activityMonitor.logComplete(activityId, response.status);
+    throw new Error(`Serper API returned invalid JSON: ${errorMessage(err)}`);
+  }
+  let entries;
+  try {
+    entries = parseResponse(rawData);
+  } catch (err) {
+    activityMonitor.logComplete(activityId, response.status);
+    throw err;
+  }
+  activityMonitor.logComplete(activityId, response.status);
+  const results = [];
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object")
+      continue;
+    if (typeof entry.link !== "string" || !entry.link)
+      continue;
+    if (!passesDomainFilters(entry.link, filters))
+      continue;
+    results.push({
+      title: typeof entry.title === "string" && entry.title.trim() ? entry.title.trim() : `Source ${results.length + 1}`,
+      url: entry.link,
+      snippet: typeof entry.snippet === "string" ? entry.snippet : ""
+    });
+    if (results.length >= numResults)
+      break;
+  }
+  return { answer: buildAnswer(results), results };
+}

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

@@ -0,0 +1,198 @@
+import { createHash } from "node:crypto";
+import { generateId, getResult, storeResult } from "./storage.js";
+const OFFICIAL_DOCS_HOSTS = /^(developers\.|docs\.|learn\.|reference\.)|\.github\.io$/i;
+const OFFICIAL_DOCS_PATHS = /\/(docs?|reference)(\/|\b)/i;
+const VENDOR_DOCS_PATHS = /\/(documentation|docs?)\//i;
+const REPO_ISSUE_PATHS = /\/(issues|pull|pulls)\//i;
+const BLOG_HOSTS = /(medium\.com|substack\.com|dev\.to|hashnode\.)/i;
+const BLOG_PATHS = /\/blogs?\//i;
+const FORUM_HOSTS = /(stackoverflow\.com|serverfault\.com|superuser\.com|discourse\.|community\.)/i;
+const FORUM_PATHS = /\/(forum|forums|threads)\//i;
+const NEWS_HOSTS = /(reuters\.com|bloomberg\.com|techcrunch\.com|theverge\.com|arstechnica\.com|wired\.com|cnet\.com|zdnet\.com)/i;
+const NEWS_PATHS = /\/news(\/|$)/i;
+export function classifySource(url) {
+  let host = "";
+  let path = "";
+  try {
+    const parsed = new URL(url);
+    host = parsed.hostname;
+    path = parsed.pathname;
+  } catch {
+    return "unknown";
+  }
+  if (REPO_ISSUE_PATHS.test(path))
+    return "repo_issue";
+  if (OFFICIAL_DOCS_HOSTS.test(host) || OFFICIAL_DOCS_PATHS.test(path))
+    return "official_docs";
+  if (VENDOR_DOCS_PATHS.test(path))
+    return "vendor_docs";
+  if (NEWS_HOSTS.test(host) || NEWS_PATHS.test(path))
+    return "news";
+  if (FORUM_HOSTS.test(host) || FORUM_PATHS.test(path))
+    return "forum";
+  if (BLOG_HOSTS.test(host) || BLOG_PATHS.test(path))
+    return "blog";
+  return "unknown";
+}
+export function hashContent(text) {
+  return `sha256:${createHash("sha256").update(text, "utf8").digest("hex")}`;
+}
+function tokenize(value) {
+  return [...new Set(value.toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 3))];
+}
+function extractRelevantSpans(content, hint) {
+  const sentences = [];
+  const sentencePattern = /[^.!?]+(?:[.!?]+(?=\s|$)|$)/g;
+  for (const match of content.matchAll(sentencePattern)) {
+    const raw = match[0];
+    const text = raw.trim();
+    if (text.length > 0 && text.length <= 400) {
+      const start = (match.index ?? 0) + raw.indexOf(text);
+      sentences.push({ text, start, end: start + text.length });
+    }
+  }
+  const terms = tokenize(hint);
+  if (terms.length === 0)
+    return [];
+  return sentences.map((sentence, index) => ({ sentence, index, score: terms.filter((term) => sentence.text.toLowerCase().includes(term)).length })).filter((item) => item.score > 0).sort((a, b) => b.score - a.score || a.index - b.index).slice(0, 3).map(({ sentence }) => sentence);
+}
+function passageId(sourceRank, index) {
+  return `p-${sourceRank}-${index}`;
+}
+export function buildPassages(sources, fetched = [], hint = "") {
+  const passages = [];
+  const fetchedByUrl = new Map(fetched.map((item) => [item.url, item]));
+  for (const source of sources) {
+    if (source.snippet) {
+      passages.push({
+        passage_id: passageId(source.rank, 0),
+        source_url: source.url,
+        source_rank: source.rank,
+        text: source.snippet,
+        content_hash: hashContent(source.snippet)
+      });
+    }
+    const page = fetchedByUrl.get(source.url);
+    if (page && !page.error && page.content) {
+      const passageHint = source.snippet?.trim() || hint;
+      for (const [index, span] of extractRelevantSpans(page.content, passageHint).entries()) {
+        passages.push({
+          passage_id: passageId(source.rank, index + 1),
+          source_url: source.url,
+          source_rank: source.rank,
+          text: span.text,
+          extraction_span: { start: span.start, end: span.end },
+          content_hash: hashContent(span.text)
+        });
+      }
+    }
+  }
+  return passages;
+}
+const CONTRADICTION_MARKERS = ["not true", "false", "incorrect", "debunked", "retracted", "no longer", "never", "denied", "contrary", "misleading"];
+const SUPPORT_MARKERS = ["yes", "true", "correct", "confirmed", "according to", "shows that", "demonstrates", "reported", "verified", "established"];
+function containsPhrase(value, phrase) {
+  const escaped = phrase.trim().toLowerCase().split(/\s+/).map((term) => term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s+");
+  return new RegExp(`(?:^|[^a-z0-9])${escaped}(?=$|[^a-z0-9])`, "i").test(value);
+}
+function markerIsNegated(value, marker) {
+  const escaped = marker.trim().toLowerCase().split(/\s+/).map((term) => term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s+");
+  const markerPattern = new RegExp(`(?:^|[^a-z0-9])${escaped}(?=$|[^a-z0-9])`, "i");
+  const match = markerPattern.exec(value);
+  if (!match || match.index === undefined)
+    return false;
+  const matchedMarker = match[0].replace(/^[^a-z0-9]+/i, "");
+  const beforeMarker = value.slice(0, match.index + match[0].length - matchedMarker.length);
+  return /(?:^|[^a-z0-9])(?:not|no|never|without)\s+$/i.test(beforeMarker);
+}
+function hasPolarityMarker(value, markers, allowNegated = false) {
+  return markers.some((marker) => containsPhrase(value, marker) && (allowNegated || !markerIsNegated(value, marker)));
+}
+export function assessClaim(claim, passages) {
+  const terms = tokenize(claim);
+  if (terms.length === 0 || passages.length === 0) {
+    return { claim, status: "missing-evidence", supporting_passages: [], contradicting_passages: [], rationale: "No passages available that discuss the claim's terms.", confidence: 0.2 };
+  }
+  const supporting = [];
+  const contradicting = [];
+  for (const passage of passages) {
+    const lower = passage.text.toLowerCase();
+    const overlap = terms.filter((term) => containsPhrase(lower, term)).length;
+    if (overlap < Math.max(2, Math.ceil(terms.length / 4)))
+      continue;
+    const contra = hasPolarityMarker(lower, CONTRADICTION_MARKERS);
+    const support = hasPolarityMarker(lower, SUPPORT_MARKERS);
+    if (contra && !support)
+      contradicting.push(passage.passage_id);
+    else if (support && !contra)
+      supporting.push(passage.passage_id);
+  }
+  if (contradicting.length > 0 && supporting.length === 0) {
+    return { claim, status: "contradicted", supporting_passages: [], contradicting_passages: contradicting, rationale: `${contradicting.length} passage(s) contradict the claim; none support it.`, confidence: Math.min(0.85, 0.5 + contradicting.length * 0.1) };
+  }
+  if (supporting.length > 0 && contradicting.length === 0) {
+    return { claim, status: "supported", supporting_passages: supporting, contradicting_passages: [], rationale: `${supporting.length} passage(s) support the claim; none contradict it.`, confidence: Math.min(0.85, 0.5 + supporting.length * 0.1) };
+  }
+  if (supporting.length > 0 || contradicting.length > 0) {
+    return { claim, status: "unclear", supporting_passages: supporting, contradicting_passages: contradicting, rationale: `${supporting.length} supporting and ${contradicting.length} contradicting passage(s); evidence is mixed.`, confidence: 0.4 };
+  }
+  return { claim, status: "unclear", supporting_passages: [], contradicting_passages: [], rationale: "Passages mention the claim's terms but contain no clear support or contradiction markers.", confidence: 0.3 };
+}
+export function buildResearchArtifact(input) {
+  const filters = input.domainFilter ?? [];
+  const fetchedByUrl = new Map((input.fetched ?? []).map((page) => [page.url, page]));
+  const sources = [];
+  const seen = new Set;
+  for (const [index, result] of input.results.entries()) {
+    if (seen.has(result.url))
+      continue;
+    seen.add(result.url);
+    const page = fetchedByUrl.get(result.url);
+    const fetched = Boolean(page && !page.error);
+    sources.push({
+      rank: result.rank ?? index + 1,
+      url: result.url,
+      title: result.title,
+      snippet: result.snippet,
+      quality: classifySource(result.url),
+      fetched,
+      ...page ? { fetch_timestamp: Date.now() } : {},
+      ...page && !page.error ? { content_hash: hashContent(page.content) } : {},
+      ...page?.error ? { fetch_error: page.error } : {}
+    });
+  }
+  const passages = buildPassages(sources, input.fetched, input.query);
+  const domainInclude = filters.filter((domain) => !domain.startsWith("-"));
+  const domainExclude = filters.filter((domain) => domain.startsWith("-")).map((domain) => domain.slice(1));
+  return {
+    id: generateId(),
+    type: "research",
+    timestamp: Date.now(),
+    query: input.query,
+    sources,
+    passages,
+    ...input.provider !== undefined ? { provider: input.provider } : {},
+    ...input.summary !== undefined ? { summary: input.summary } : {},
+    ...passages.length > 0 ? { content_hash: hashContent(passages.map((passage) => passage.text).join(`
+`)) } : {},
+    filters: {
+      ...input.recency !== undefined ? { recency: input.recency } : {},
+      domain_include: domainInclude,
+      domain_exclude: domainExclude
+    }
+  };
+}
+export function withClaimAssessment(artifact, claims) {
+  return { ...artifact, claims: claims.map((claim) => assessClaim(claim, artifact.passages)) };
+}
+export function storeResearchArtifact(artifact) {
+  if (!artifact.id)
+    throw new Error("Research artifact id must not be empty");
+  storeResult(artifact.id, { id: artifact.id, type: "research", timestamp: artifact.timestamp, artifact });
+}
+export function getResearchArtifact(id) {
+  const data = getResult(id);
+  if (!data || data.type !== "research" || !data.artifact || typeof data.artifact !== "object")
+    return null;
+  return data.artifact;
+}