turbollm 1.8.1 → 1.8.2

package/dist/cli.js

@@ -3677,7 +3677,7 @@ function enumWindowsGpus() {
 var DISPLAY_CLASS_GUID = "{4d36e968-e325-11ce-bfc1-08002be10318}";
 function readWindowsVramRegistry() {
   try {
-    const ps = `Get-ChildItem 'HKLM:\\SYSTEM\\CurrentControlSet\\Control\\Class\\${DISPLAY_CLASS_GUID}' -ErrorAction SilentlyContinue | ForEach-Object { $p = Get-ItemProperty -Path $_.PSPath -ErrorAction SilentlyContinue; if ($p.'HardwareInformation.qwMemorySize') { "$($p.DriverDesc)|$($p.'HardwareInformation.qwMemorySize')" } }`;
+    const ps = `Get-ChildItem 'HKLM:\\SYSTEM\\CurrentControlSet\\Control\\Class\\${DISPLAY_CLASS_GUID}' -ErrorAction SilentlyContinue | Where-Object { $_.PSChildName -match '^\\d{4}$' } | ForEach-Object { try { $p = Get-ItemProperty -Path $_.PSPath -ErrorAction Stop; if ($p.'HardwareInformation.qwMemorySize') { "$($p.DriverDesc)|$($p.'HardwareInformation.qwMemorySize')" } } catch { } }; exit 0`;
     const out = execFileSync2("powershell", ["-NoProfile", "-NonInteractive", "-Command", ps], {
       timeout: 8e3,
       windowsHide: true
@@ -4134,18 +4134,37 @@ function skipValue(r, t) {
   }
   r.skip(scalarSize(t));
 }
-function readNumberOrMax(r, t) {
+function readNumberList(r, t) {
   if (t === T_ARRAY) {
     const elemType = r.u32();
     const count = r.u64();
-    let max = 0;
-    for (let i = 0; i < count; i++) {
-      const v = Number(readScalar(r, elemType));
-      if (v > max) max = v;
-    }
-    return max;
+    const values = [];
+    for (let i = 0; i < count; i++) values.push(Number(readScalar(r, elemType)));
+    return { values, isArray: true };
   }
-  return Number(readScalar(r, t));
+  return { values: [Number(readScalar(r, t))], isArray: false };
+}
+function readNumberOrMax(r, t) {
+  return maxOf(readNumberList(r, t).values);
+}
+function maxOf(values) {
+  let max = 0;
+  for (const v of values) if (v > max) max = v;
+  return max;
+}
+function readBoolArray(r, t) {
+  if (t !== T_ARRAY) {
+    skipValue(r, t);
+    return [];
+  }
+  const elemType = r.u32();
+  const count = r.u64();
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    const v = readScalar(r, elemType);
+    out.push(typeof v === "string" ? v.toLowerCase() === "true" : Boolean(v));
+  }
+  return out;
 }
 function parseGguf(path) {
   const fd = openSync2(path, "r");
@@ -4159,6 +4178,8 @@ function parseGguf(path) {
     const m = { hasChatTemplate: false };
     let keyLength;
     let valueLength;
+    let keyLengthSwa;
+    let valueLengthSwa;
     for (let i = 0; i < kvCount; i++) {
       const key = r.str();
       const t = r.u32();
@@ -4169,9 +4190,20 @@ function parseGguf(path) {
       else if (key.endsWith(".context_length")) m.nativeCtx = readNumberOrMax(r, t);
       else if (key.endsWith(".block_count")) m.blockCount = readNumberOrMax(r, t);
       else if (key.endsWith(".embedding_length")) m.embedLen = readNumberOrMax(r, t);
-      else if (key.endsWith(".attention.head_count_kv")) m.headCountKv = readNumberOrMax(r, t);
-      else if (key.endsWith(".attention.key_length")) keyLength = readNumberOrMax(r, t);
+      else if (key.endsWith(".attention.head_count_kv")) {
+        const kv = readNumberList(r, t);
+        m.headCountKv = maxOf(kv.values);
+        if (kv.isArray) m.headCountKvPerLayer = kv.values;
+      } else if (key.endsWith(".attention.key_length")) keyLength = readNumberOrMax(r, t);
       else if (key.endsWith(".attention.value_length")) valueLength = readNumberOrMax(r, t);
+      else if (key.endsWith(".attention.key_length_swa")) keyLengthSwa = readNumberOrMax(r, t);
+      else if (key.endsWith(".attention.value_length_swa")) valueLengthSwa = readNumberOrMax(r, t);
+      else if (key.endsWith(".attention.sliding_window")) m.slidingWindow = readNumberOrMax(r, t);
+      else if (key.endsWith(".attention.sliding_window_pattern")) m.slidingWindowPattern = readBoolArray(r, t);
+      else if (key.endsWith(".full_attention_interval")) m.fullAttentionInterval = readNumberOrMax(r, t);
+      else if (key.endsWith(".ssm.inner_size")) m.ssmInnerSize = readNumberOrMax(r, t);
+      else if (key.endsWith(".ssm.state_size")) m.ssmStateSize = readNumberOrMax(r, t);
+      else if (key.endsWith(".ssm.conv_kernel")) m.ssmConvKernel = readNumberOrMax(r, t);
       else if (key.endsWith(".expert_count")) m.expertCount = readNumberOrMax(r, t);
       else if (key.endsWith(".nextn_predict_layers")) m.nextnLayers = readNumberOrMax(r, t);
       else if (key === "tokenizer.chat_template") {
@@ -4193,7 +4225,15 @@ function parseGguf(path) {
       headDim: keyLength ?? valueLength ?? 0,
       expertCount: m.expertCount ?? 0,
       nextnLayers: m.nextnLayers ?? 0,
-      hasChatTemplate: m.hasChatTemplate ?? false
+      hasChatTemplate: m.hasChatTemplate ?? false,
+      slidingWindow: m.slidingWindow ?? 0,
+      slidingWindowPattern: m.slidingWindowPattern ?? [],
+      headDimSwa: keyLengthSwa ?? valueLengthSwa ?? 0,
+      headCountKvPerLayer: m.headCountKvPerLayer ?? [],
+      fullAttentionInterval: m.fullAttentionInterval ?? 0,
+      ssmInnerSize: m.ssmInnerSize ?? 0,
+      ssmStateSize: m.ssmStateSize ?? 0,
+      ssmConvKernel: m.ssmConvKernel ?? 0
     };
   } finally {
     closeSync2(fd);
@@ -4205,7 +4245,20 @@ function quantFromName(filename) {
 }
 
 // src/models/scanner.ts
-var CACHE_VERSION = 3;
+var CACHE_VERSION = 4;
+function attentionLayoutOf(meta) {
+  const a = meta ?? {};
+  const out = {};
+  if (a.slidingWindow) out.slidingWindow = a.slidingWindow;
+  if (a.slidingWindowPattern?.length) out.slidingWindowPattern = a.slidingWindowPattern;
+  if (a.headDimSwa) out.headDimSwa = a.headDimSwa;
+  if (a.headCountKvPerLayer?.length) out.headCountKvPerLayer = a.headCountKvPerLayer;
+  if (a.fullAttentionInterval) out.fullAttentionInterval = a.fullAttentionInterval;
+  if (a.ssmInnerSize) out.ssmInnerSize = a.ssmInnerSize;
+  if (a.ssmStateSize) out.ssmStateSize = a.ssmStateSize;
+  if (a.ssmConvKernel) out.ssmConvKernel = a.ssmConvKernel;
+  return out;
+}
 var SPLIT_RE = /^(.*)-(\d{5})-of-(\d{5})\.gguf$/i;
 var EMBED_ARCHS = /* @__PURE__ */ new Set([
   "bert",
@@ -4392,6 +4445,9 @@ var Scanner = class {
       blockCount: meta?.blockCount ?? 0,
       headCountKv: meta?.headCountKv ?? 0,
       headDim: meta?.headDim ?? 0,
+      // Only present on the handful of models that declare a non-uniform attention
+      // layout; everything else keeps the shape (and the KV estimate) it had before.
+      ...attentionLayoutOf(meta),
       moe: (meta?.expertCount ?? 0) > 0,
       expertCount: meta?.expertCount ?? 0,
       nextnLayers: meta?.nextnLayers ?? 0,
@@ -4689,6 +4745,52 @@ function kvBytesPerElem(t) {
 function defaultSampling() {
   return { temp: 0.8, topP: 0.95, topK: 40, minP: 0.05, repeatPenalty: 1, presencePenalty: 0, frequencyPenalty: 0, stop: [] };
 }
+function isFullAttentionLayer(i, interval) {
+  return (i + 1) % interval === 0;
+}
+function hybridInterval(m, blocks) {
+  const interval = m.fullAttentionInterval ?? 0;
+  if (!Number.isInteger(interval) || interval <= 1 || interval > blocks) return 0;
+  return interval;
+}
+function linearLayerCount(m) {
+  const blocks = m.blockCount || 1;
+  const interval = hybridInterval(m, blocks);
+  if (interval === 0) return 0;
+  let n = 0;
+  for (let i = 0; i < blocks; i++) if (!isFullAttentionLayer(i, interval)) n++;
+  return n;
+}
+function kvCacheElems(m, ctx) {
+  const blocks = m.blockCount || 1;
+  const kvHeads = m.headCountKv || 8;
+  const headDim = m.headDim || HEAD_DIM;
+  const perLayerHeads = m.headCountKvPerLayer?.length === blocks ? m.headCountKvPerLayer : void 0;
+  const window = m.slidingWindow ?? 0;
+  const swaPattern = window > 0 && m.slidingWindowPattern?.length === blocks ? m.slidingWindowPattern : void 0;
+  const swaHeadDim = (m.headDimSwa ?? 0) > 0 ? m.headDimSwa : headDim;
+  const interval = hybridInterval(m, blocks);
+  const hybrid = interval > 0 && swaPattern === void 0;
+  if (swaPattern === void 0 && !hybrid) return 2 * blocks * ctx * kvHeads * headDim;
+  let elems = 0;
+  for (let i = 0; i < blocks; i++) {
+    if (hybrid && !isFullAttentionLayer(i, interval)) continue;
+    const sliding = swaPattern?.[i] === true;
+    const tokens = sliding ? Math.min(ctx, window) : ctx;
+    const heads = perLayerHeads?.[i] || kvHeads;
+    const dim = sliding ? swaHeadDim : headDim;
+    elems += 2 * tokens * heads * dim;
+  }
+  return elems;
+}
+function ssmStateElems(m) {
+  const layers = linearLayerCount(m);
+  const inner = m.ssmInnerSize ?? 0;
+  const state = m.ssmStateSize ?? 0;
+  if (layers === 0 || inner <= 0 || state <= 0) return 0;
+  const conv = Math.max(1, m.ssmConvKernel ?? 1);
+  return layers * inner * (state + conv - 1);
+}
 function gpuBudgetMb(sys, p) {
   if (sys.gpus.length === 0) return 0;
   if (p?.gpu?.splitMode === "none") {
@@ -4704,10 +4806,9 @@ function estimateVram(p, m, sys) {
   const blocks = m.blockCount || 1;
   const gpuFrac = m.moe ? 1 - 0.85 * (p.nCpuMoe / blocks) : Math.min(p.ngl, blocks) / blocks;
   const weightsMb = sizeMb * Math.max(0, Math.min(1, gpuFrac));
-  const kvHeads = m.headCountKv || 8;
-  const headDim = m.headDim || HEAD_DIM;
-  const kvElems = 2 * blocks * p.ctx * kvHeads * headDim;
-  const kvMb = p.kvOffload === false ? 0 : kvElems * kvBytesPerElem(p.kvTypeK) / 1e6 * (p.kvUnified ? 1 : Math.max(1, p.parallel));
+  const kvElems = kvCacheElems(m, p.ctx);
+  const ssmMb = ssmStateElems(m) * 4 / 1e6;
+  const kvMb = p.kvOffload === false ? 0 : (kvElems * kvBytesPerElem(p.kvTypeK) / 1e6 + ssmMb) * (p.kvUnified ? 1 : Math.max(1, p.parallel));
   const mmprojMb = p.useMmproj && p.mmprojGpu && m.mmprojPath ? m.mmprojSizeBytes / 1e6 * 1.15 : 0;
   const estMb = Math.round(weightsMb + kvMb + 800 + mmprojMb);
   const pct = estMb / totalVramMb;
@@ -8291,6 +8392,18 @@ async function checkSsrf(url) {
 
 // src/tools/search-providers.ts
 var SEARCH_TIMEOUT_MS = 2e4;
+var FUTURE_SKEW_MS = 2 * 24 * 60 * 60 * 1e3;
+function normalizePublishedDate(raw) {
+  if (typeof raw !== "string") return void 0;
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  const ms = Date.parse(trimmed);
+  if (!Number.isFinite(ms)) return void 0;
+  if (ms > Date.now() + FUTURE_SKEW_MS) return void 0;
+  const iso = new Date(ms).toISOString();
+  if (Number(iso.slice(0, 4)) < 1990) return void 0;
+  return iso.slice(0, 10);
+}
 function searchConfigured(cfg2) {
   if (!cfg2) return false;
   switch (cfg2.provider) {
@@ -8325,7 +8438,11 @@ var TavilyClient = class {
   key;
   fetchImpl;
   provider = "tavily";
-  async search(query, maxResults) {
+  // `time_range` is honoured on the default (general) topic and meaningfully shifts the
+  // mix toward recent pages. It does NOT make Tavily return `published_date` — only
+  // `topic:'news'` does that, and that collapses results to news articles, so we don't
+  // send it. Tavily therefore filters by recency but rarely supplies a date here.
+  async search(query, maxResults, opts) {
     const resp = await this.fetchImpl("https://api.tavily.com/search", {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -8333,18 +8450,23 @@ var TavilyClient = class {
         api_key: this.key,
         query,
         max_results: maxResults,
-        search_depth: "advanced"
+        search_depth: "advanced",
+        ...opts?.recent ? { time_range: "month" } : {}
       }),
       signal: AbortSignal.timeout(SEARCH_TIMEOUT_MS)
     });
     if (!resp.ok) throw new Error(await httpError("Tavily", resp));
     const data = await resp.json();
-    return (data.results ?? []).map((r) => ({
-      title: r.title ?? "",
-      url: r.url ?? "",
-      content: r.content ?? "",
-      score: r.score
-    }));
+    return (data.results ?? []).map((r) => {
+      const publishedDate = normalizePublishedDate(r.published_date);
+      return {
+        title: r.title ?? "",
+        url: r.url ?? "",
+        content: r.content ?? "",
+        score: r.score,
+        ...publishedDate ? { publishedDate } : {}
+      };
+    });
   }
 };
 var KagiClient = class {
@@ -8355,6 +8477,10 @@ var KagiClient = class {
   key;
   fetchImpl;
   provider = "kagi";
+  // No `opts` arg: the v0 search endpoint this adapter targets documents only `q` and
+  // `limit` — it has no recency parameter, so `recent` cannot be honoured here.
+  // (Kagi's newer POST /search endpoint does support recency via lens/filters, but it
+  // has a different request and response shape and would need a full adapter rewrite.)
   async search(query, maxResults) {
     const url = `https://kagi.com/api/v0/search?q=${encodeURIComponent(query)}&limit=${maxResults}`;
     const resp = await this.fetchImpl(url, {
@@ -8364,11 +8490,15 @@ var KagiClient = class {
     });
     if (!resp.ok) throw new Error(await httpError("Kagi", resp));
     const data = await resp.json();
-    return (data.data ?? []).filter((r) => r.t === 0 && r.url).map((r) => ({
-      title: r.title ?? "",
-      url: r.url ?? "",
-      content: r.snippet ?? ""
-    }));
+    return (data.data ?? []).filter((r) => r.t === 0 && r.url).map((r) => {
+      const publishedDate = normalizePublishedDate(r.published);
+      return {
+        title: r.title ?? "",
+        url: r.url ?? "",
+        content: r.snippet ?? "",
+        ...publishedDate ? { publishedDate } : {}
+      };
+    });
   }
 };
 var SearxngClient = class {
@@ -8379,21 +8509,26 @@ var SearxngClient = class {
   baseUrl;
   fetchImpl;
   provider = "searxng";
-  async search(query, maxResults) {
+  async search(query, maxResults, opts) {
     const base2 = this.baseUrl.replace(/\/+$/, "");
-    const url = `${base2}/search?q=${encodeURIComponent(query)}&format=json&categories=general`;
+    let url = `${base2}/search?q=${encodeURIComponent(query)}&format=json&categories=general`;
+    if (opts?.recent) url += "&time_range=month";
     const resp = await this.fetchImpl(url, {
       method: "GET",
       signal: AbortSignal.timeout(SEARCH_TIMEOUT_MS)
     });
     if (!resp.ok) throw new Error(await httpError("SearXNG", resp));
     const data = await resp.json();
-    return (data.results ?? []).slice(0, maxResults).map((r) => ({
-      title: r.title ?? "",
-      url: r.url ?? "",
-      content: r.content ?? "",
-      score: r.score
-    }));
+    return (data.results ?? []).slice(0, maxResults).map((r) => {
+      const publishedDate = normalizePublishedDate(r.publishedDate);
+      return {
+        title: r.title ?? "",
+        url: r.url ?? "",
+        content: r.content ?? "",
+        score: r.score,
+        ...publishedDate ? { publishedDate } : {}
+      };
+    });
   }
 };
 async function httpError(name, resp) {
@@ -8403,8 +8538,10 @@ async function httpError(name, resp) {
 
 // src/tools/research-service.ts
 var MIN_RELEVANCE_SCORE = 0.4;
-var MAX_RESULTS = 5;
+var MAX_RESULTS = 8;
 var MAX_SEARCH_RESULTS = 10;
+var FRESH_MAX_AGE_DAYS = 90;
+var DATED_MIN_AGE_DAYS = 3 * 365;
 var TRUSTED_DOMAINS = [
   [/\.(edu|ac\.[a-z]{2})$/, 0.9],
   [/\.gov(\.[a-z]{2})?$/, 0.9],
@@ -8511,58 +8648,385 @@ function keywordOverlap(query, text) {
   const bigramScore = bigramTotal > 0 ? bigramHits / bigramTotal : 0;
   return Math.min(1, unigramScore * 0.7 + bigramScore * 0.3);
 }
+function clamp(n, lo, hi) {
+  return Math.min(hi, Math.max(lo, n));
+}
+var GENERIC_URL_LABELS = /* @__PURE__ */ new Set([
+  "best",
+  "top",
+  "guide",
+  "guides",
+  "review",
+  "reviews",
+  "news",
+  "blog",
+  "blogs",
+  "shop",
+  "store",
+  "buy",
+  "price",
+  "prices",
+  "deal",
+  "deals",
+  "compare",
+  "ranking",
+  "rankings",
+  "list",
+  "lists",
+  "info",
+  "online",
+  "free",
+  "home",
+  "site",
+  "daily",
+  "today",
+  "live",
+  "tips",
+  "world",
+  "expert",
+  "experts",
+  "hub",
+  "zone",
+  "central",
+  "article",
+  "articles",
+  "post",
+  "posts",
+  "page",
+  "pages",
+  "category",
+  "tag",
+  "tags",
+  "search",
+  "wiki",
+  "forum",
+  "forums",
+  "topic",
+  "topics"
+]);
+var SUFFIX_LABELS = /* @__PURE__ */ new Set(["www", "co", "com", "org", "net", "ac", "gov", "edu"]);
+function entityStem(s) {
+  return s.replace(/\d+$/, "");
+}
+function entityTerms(query) {
+  const terms = new Set(
+    tokenize(query).filter((t) => t.length >= 4 && !GENERIC_URL_LABELS.has(t))
+  );
+  if (query !== query.toUpperCase()) {
+    for (const m of query.match(/\b[A-Z]{3,6}\b/g) ?? []) {
+      const lower = m.toLowerCase();
+      if (!GENERIC_URL_LABELS.has(lower)) terms.add(lower);
+    }
+  }
+  return terms;
+}
+function officialSourceBoost(query, url) {
+  let host2;
+  let segments;
+  try {
+    const u = new URL(url.startsWith("http") ? url : `https://${url}`);
+    host2 = u.hostname.toLowerCase();
+    segments = u.pathname.split("/").filter(Boolean).map((s) => s.toLowerCase().replace(/[^a-z0-9]/g, ""));
+  } catch {
+    return 0;
+  }
+  const terms = entityTerms(query);
+  if (terms.size === 0) return 0;
+  const matches = (candidate) => {
+    if (candidate.length < 3 || GENERIC_URL_LABELS.has(candidate)) return false;
+    const stem = entityStem(candidate);
+    for (const t of terms) {
+      if (t === candidate) return true;
+      if (stem.length >= 4 && entityStem(t) === stem) return true;
+    }
+    return false;
+  };
+  const isConcatenatedName = (candidate) => {
+    if (candidate.length < 8) return false;
+    let hits = 0;
+    let covered = 0;
+    for (const t of terms) {
+      if (t.length >= 4 && candidate.includes(t)) {
+        hits++;
+        covered += t.length;
+      }
+    }
+    return hits >= 2 && covered >= candidate.length * 0.6;
+  };
+  const labels = host2.split(".");
+  for (let i = 0; i < labels.length - 1; i++) {
+    if (SUFFIX_LABELS.has(labels[i])) continue;
+    if (matches(labels[i])) return 0.25;
+    if (isConcatenatedName(labels[i])) return 0.22;
+  }
+  if (segments.length !== 1) return 0;
+  if (labels.some((l) => GENERIC_URL_LABELS.has(l))) return 0;
+  return matches(segments[0]) ? 0.15 : 0;
+}
+function officialDocsBoost(url) {
+  try {
+    const host2 = new URL(url.startsWith("http") ? url : `https://${url}`).hostname.toLowerCase();
+    return /^(docs?|developers?|support|help)\./.test(host2) ? 0.1 : 0;
+  } catch {
+    return 0;
+  }
+}
+var AGGREGATOR_BAIT = [
+  /\bbest\b/,
+  /\btop\s+\d+\b/,
+  /\b\d+\s+(best|top|ways|reasons|tips|things|ideas|alternatives)\b/,
+  /\bultimate\s+guide\b/,
+  /\branked\b/,
+  /\breviews?\b|\breviewed\b/,
+  /\bround\s?up\b/,
+  /\b(vs|versus)\b/
+];
+var AGGREGATOR_PATTERNS = [
+  ...AGGREGATOR_BAIT,
+  /\bwhich\b[\s\S]*\bshould\s+you\b/
+];
+var AGGREGATOR_EXEMPTIONS = [
+  /\bbest\s+practices?\b/,
+  /\b(systematic|literature|scoping|narrative|meta)\b/,
+  /\bpeer\s+reviewed\b/
+];
+function aggregatorPenalty(title, url, intent) {
+  if (intent === "comparison") return 0;
+  let slug = "";
+  try {
+    slug = new URL(url.startsWith("http") ? url : `https://${url}`).pathname;
+  } catch {
+    slug = "";
+  }
+  const text = `${title} ${slug.replace(/[^a-zA-Z0-9]+/g, " ")}`.toLowerCase();
+  if (AGGREGATOR_EXEMPTIONS.some((re) => re.test(text))) return 0;
+  if (!AGGREGATOR_PATTERNS.some((re) => re.test(text))) return 0;
+  return /\b(19|20)\d{2}\b/.test(text) ? 0.2 : 0.15;
+}
+function substantiveTermCount(text) {
+  return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 2 && !STOP_WORDS.has(t)).length;
+}
+var QUERY_ONLY_BAIT = [
+  /\bwhich\b/gi,
+  /\bshould\s+(you|i|we)\b/gi,
+  /\b(19|20)\d{2}\b/g
+];
+function debaitQuery(query) {
+  if (typeof query !== "string" || !query.trim()) return null;
+  const lower = query.toLowerCase();
+  if (AGGREGATOR_EXEMPTIONS.some((re) => re.test(lower))) return null;
+  if (!AGGREGATOR_PATTERNS.some((re) => re.test(lower))) return null;
+  let out = query;
+  for (const re of AGGREGATOR_BAIT) {
+    out = out.replace(new RegExp(re.source, "gi"), " ");
+  }
+  for (const re of QUERY_ONLY_BAIT) out = out.replace(re, " ");
+  out = out.replace(/\s+/g, " ").trim().replace(/^[^\p{L}\p{N}]+|[^\p{L}\p{N}]+$/gu, "").trim();
+  if (!out || out.toLowerCase() === query.trim().toLowerCase()) return null;
+  if (substantiveTermCount(out) < 2) return null;
+  return out;
+}
+function sourceQuality(query, title, url, intent) {
+  let base2;
+  try {
+    base2 = domainScore(url);
+  } catch {
+    base2 = 0.5;
+  }
+  return clamp(
+    base2 + officialSourceBoost(query, url) + officialDocsBoost(url) - aggregatorPenalty(title, url, intent),
+    0.1,
+    1
+  );
+}
+function passagePriority(sentence) {
+  const s = sentence.trim();
+  let rank = 0;
+  if (/^#{1,6}\s/.test(s)) rank -= 2;
+  if (/\b(19|20)\d{2}\b/.test(s)) rank += 1;
+  return rank;
+}
+var MAX_PASSAGE_CHARS = 1200;
+var REFERENTIAL_OPENER = /^(in addition|as a result|for example|for instance|it|this|that|these|those|they|he|she|its|their|his|her|there|such|however|but|and|so|then|also|additionally|moreover|furthermore|instead|meanwhile|therefore|thus|yet|still)\b/i;
+function needsPrecedingContext(sentence) {
+  const s = sentence.trim();
+  return s.length < 120 || REFERENTIAL_OPENER.test(s) || /^[a-z]/.test(s);
+}
 function extractPassage(query, content) {
   if (!content) return "";
   const sentences = content.split(/(?<=[.?!])\s+/).filter((s) => s.trim().length > 0);
   if (sentences.length <= 1) {
-    return content.slice(0, 200);
+    return content.slice(0, MAX_PASSAGE_CHARS);
   }
-  let bestSentence = sentences[0];
+  let bestIdx = 0;
   let bestScore = keywordOverlap(query, sentences[0]);
   for (let i = 1; i < sentences.length; i++) {
     const s = keywordOverlap(query, sentences[i]);
-    if (s > bestScore) {
+    if (s > bestScore || s === bestScore && passagePriority(sentences[i]) > passagePriority(sentences[bestIdx])) {
       bestScore = s;
-      bestSentence = sentences[i];
-    }
+      bestIdx = i;
+    }
+  }
+  const best = sentences[bestIdx].trim();
+  if (best.length >= MAX_PASSAGE_CHARS) return best.slice(0, MAX_PASSAGE_CHARS);
+  let start = bestIdx;
+  let end = bestIdx;
+  let total = best.length;
+  const fits = (s) => total + s.length + 1 <= MAX_PASSAGE_CHARS;
+  if (bestIdx > 0 && needsPrecedingContext(best)) {
+    const prev = sentences[bestIdx - 1].trim();
+    if (fits(prev)) {
+      start = bestIdx - 1;
+      total += prev.length + 1;
+    }
+  }
+  while (end + 1 < sentences.length) {
+    const next = sentences[end + 1].trim();
+    if (!fits(next)) break;
+    end++;
+    total += next.length + 1;
+  }
+  while (start > 0) {
+    const prev = sentences[start - 1].trim();
+    if (!fits(prev)) break;
+    start--;
+    total += prev.length + 1;
+  }
+  return sentences.slice(start, end + 1).map((s) => s.trim()).join(" ");
+}
+function normalizePublishedDate2(raw) {
+  if (typeof raw !== "string") return void 0;
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(raw.trim());
+  if (!m) return void 0;
+  const [, y, mo, d] = m;
+  const ms = Date.UTC(Number(y), Number(mo) - 1, Number(d));
+  const dt = new Date(ms);
+  if (dt.getUTCFullYear() !== Number(y) || dt.getUTCMonth() !== Number(mo) - 1 || dt.getUTCDate() !== Number(d)) {
+    return void 0;
   }
-  return bestSentence.trim();
+  return `${y}-${mo}-${d}`;
 }
-function freshnessSignal(content, freshness) {
-  if (!freshness || freshness === "any") return "unknown";
-  const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+function ageInDays(isoDate, now = Date.now()) {
+  const normalized = normalizePublishedDate2(isoDate);
+  if (!normalized) return void 0;
+  const published = Date.parse(`${normalized}T00:00:00Z`);
+  if (Number.isNaN(published)) return void 0;
+  return Math.max(0, Math.floor((now - published) / 864e5));
+}
+function yearMentionHint(content) {
   const yearMatches = content.match(/\b(20\d{2})\b/g);
   if (!yearMatches) return "unknown";
-  const years = yearMatches.map(Number);
-  const maxYear = Math.max(...years);
+  const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+  const maxYear = Math.max(...yearMatches.map(Number));
   if (maxYear >= currentYear - 1) return "recent";
   if (maxYear <= currentYear - 3) return "dated";
   return "unknown";
 }
-function freshnessScore(signal, freshness) {
-  if (!freshness || freshness === "any") return 0.5;
-  if (signal === "recent") return 0.9;
-  if (signal === "dated") return 0.2;
+function currentnessMultiplier(ageDays) {
+  if (ageDays <= FRESH_MAX_AGE_DAYS) return 1;
+  if (ageDays <= 365) return 0.85;
+  if (ageDays <= DATED_MIN_AGE_DAYS) return 0.65;
+  return 0.45;
+}
+function freshnessSignal(ageDays) {
+  if (ageDays === void 0) return "unknown";
+  if (ageDays <= FRESH_MAX_AGE_DAYS) return "recent";
+  if (ageDays >= DATED_MIN_AGE_DAYS) return "dated";
+  return "unknown";
+}
+function freshnessScore(ageDays, content, freshness) {
+  if (freshness !== "current") return 0.5;
+  if (ageDays !== void 0) {
+    if (ageDays <= FRESH_MAX_AGE_DAYS) return 1;
+    if (ageDays <= 180) return 0.6;
+    if (ageDays <= 365) return 0.4;
+    if (ageDays < DATED_MIN_AGE_DAYS) return 0.2;
+    return 0.1;
+  }
+  const hint = yearMentionHint(content);
+  if (hint === "recent") return 0.6;
+  if (hint === "dated") return 0.45;
   return 0.5;
 }
+var TRACKING_PARAMS = /^(utm_[a-z0-9_]+|fbclid|gclid|dclid|msclkid|mc_cid|mc_eid|igshid|ref|referrer|source)$/i;
+function normalizeUrlIdentity(url) {
+  const raw = String(url ?? "").trim();
+  try {
+    const u = new URL(raw.startsWith("http") ? raw : `https://${raw}`);
+    for (const key of [...u.searchParams.keys()]) {
+      if (TRACKING_PARAMS.test(key)) u.searchParams.delete(key);
+    }
+    u.searchParams.sort();
+    const host2 = u.hostname.toLowerCase().replace(/^www\./, "");
+    const path = u.pathname.replace(/\/+$/, "");
+    const qs = u.searchParams.toString();
+    return `${host2}${path}${qs ? `?${qs}` : ""}`;
+  } catch {
+    return raw.toLowerCase();
+  }
+}
+function normalizeTitleIdentity(title) {
+  return String(title ?? "").trim().replace(/\s+/g, " ").toLowerCase();
+}
+function isBetterDuplicate(candidate, incumbent) {
+  const candidateDated = !!candidate.publishedDate;
+  const incumbentDated = !!incumbent.publishedDate;
+  if (candidateDated !== incumbentDated) return candidateDated;
+  return (candidate.content?.length ?? 0) > (incumbent.content?.length ?? 0);
+}
+function collapseBy(results, keyOf) {
+  const seenAt = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const r of results) {
+    const key = keyOf(r);
+    if (key === null) {
+      out.push(r);
+      continue;
+    }
+    const at = seenAt.get(key);
+    if (at === void 0) {
+      seenAt.set(key, out.length);
+      out.push(r);
+    } else if (isBetterDuplicate(r, out[at])) {
+      out[at] = r;
+    }
+  }
+  return out;
+}
+function dedupeSearchResults(results) {
+  const byUrl = collapseBy(results, (r) => r?.url ? normalizeUrlIdentity(r.url) : null);
+  return collapseBy(byUrl, (r) => {
+    const title = normalizeTitleIdentity(r?.title ?? "");
+    if (!title) return null;
+    return `${extractDomain(r.url ?? "")}\0${title}`;
+  });
+}
 async function research(q, cfg2, fetchImpl) {
   if (!searchConfigured(cfg2)) return [];
   const client = searchProviderClient(cfg2, fetchImpl);
   if (!client) return [];
-  let raw;
-  try {
-    raw = await client.search(q.query, MAX_SEARCH_RESULTS);
-  } catch {
-    return [];
-  }
+  const opts = q.freshness === "current" ? { recent: true } : void 0;
+  const debaited = debaitQuery(q.query);
+  const primaryCall = client.search(q.query, MAX_SEARCH_RESULTS, opts).then(
+    (r) => r,
+    () => null
+    // null distinguishes "the search failed" from "the search found nothing".
+  );
+  const extraCall = debaited ? client.search(debaited, MAX_SEARCH_RESULTS, opts).catch(() => []) : Promise.resolve([]);
+  const [primaryRaw, extraRaw] = await Promise.all([primaryCall, extraCall]);
+  if (primaryRaw === null) return [];
+  const raw = dedupeSearchResults([...primaryRaw, ...extraRaw]);
+  const now = Date.now();
   const scored = raw.map((r) => {
     const domain = extractDomain(r.url);
     const text = `${r.title} ${r.content}`;
     const kwScore = keywordOverlap(q.query, text);
-    const ds = domainScore(r.url);
-    const signal = freshnessSignal(r.content, q.freshness);
-    const fs2 = freshnessScore(signal, q.freshness);
-    const relevanceScore = 0.5 * kwScore + 0.3 * ds + 0.2 * fs2;
+    const sq = sourceQuality(q.query, r.title, r.url, q.intent);
+    const publishedDate = normalizePublishedDate2(r.publishedDate);
+    const ageDays = publishedDate ? ageInDays(publishedDate, now) : void 0;
+    const signal = freshnessSignal(ageDays);
+    const fs2 = freshnessScore(ageDays, r.content, q.freshness);
+    const relevanceScore = 0.35 * kwScore + 0.45 * sq + 0.2 * fs2;
     const passage = extractPassage(q.query, r.content);
     return {
       url: r.url,
@@ -8570,40 +9034,45 @@ async function research(q, cfg2, fetchImpl) {
       passage,
       relevanceScore: Math.round(relevanceScore * 1e3) / 1e3,
       freshnessSignal: signal,
-      domain
+      domain,
+      publishedDate,
+      ageDays
     };
   });
   return scored.filter((r) => r.relevanceScore >= MIN_RELEVANCE_SCORE).sort((a, b) => b.relevanceScore - a.relevanceScore).slice(0, MAX_RESULTS);
 }
 
 // src/tools/builtin.ts
-var WEB_SEARCH_TOOL = {
-  type: "function",
-  function: {
-    name: "web_search",
-    description: "Search the web for real-time information. Call this BEFORE answering any question that depends on current events, recent data, prices, specific facts, or anything your training data may not cover accurately. Formulate a precise, keyword-focused query \u2014 include names, dates, or version numbers when relevant. Run multiple focused searches rather than one broad one for complex questions. Results are pre-ranked by relevance \u2014 each entry includes a relevanceScore (0\u20131), a key passage, and a source URL.",
-    parameters: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description: 'A precise, specific search query. Use key terms and identifiers. Good: "Python 3.13 release date new features". Bad: "Python new stuff". Good: "NVIDIA RTX 5090 benchmark 2025". Bad: "new GPU benchmarks".'
-        },
-        intent: {
-          type: "string",
-          enum: ["factual", "recent_news", "comparison", "how_to"],
-          description: "Optional: the type of answer needed. Helps the retrieval service weight results appropriately."
+function webSearchTool(today = todayIso()) {
+  const year = today.slice(0, 4);
+  return {
+    type: "function",
+    function: {
+      name: "web_search",
+      description: `Search the web for real-time information. TODAY IS ${today}. Call this BEFORE answering any question that depends on current events, recent data, prices, specific facts, or anything your training data may not cover accurately. DISCOVERY BEFORE RECALL: when you need what is best/current/latest in some category, your FIRST search must NOT name a specific product, model, version, brand or person you are recalling from memory \u2014 what you remember may have been replaced, and a search only returns what you ask about. Search the category itself plus the current year (e.g. "<category> ${year}", "latest <category> released"), read which names actually exist now, and only THEN search those names. Run multiple focused searches rather than one broad one for complex questions. Returns up to 8 pre-ranked results. Each entry carries a substantial excerpt from the page \u2014 not a one-line snippet \u2014 plus a relevanceScore (0\u20131), a source URL, and the publication date when the source reports one. Judge sources by authority, not only by how closely their wording echoes the question: prefer primary and official sources \u2014 the organisation's own site, official documentation, the original announcement, report, filing, or paper \u2014 over roundups, listicles and "best of" articles, which are often re-titled stale content dressed up as current. When an excerpt reads as authoritative but is too thin to answer from, call fetch_url on that result to read the full page rather than filling the gap from memory.`,
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: `A precise, specific search query. Use key terms and identifiers. When recency matters use ${year} \u2014 never a year you recall from training, which is how a search silently returns correct answers about superseded things. Good: "Python 3.13 release date new features". Bad: "Python new stuff". Good: "NVIDIA RTX 5090 benchmark ${year}". Bad: "new GPU benchmarks".`
+          },
+          intent: {
+            type: "string",
+            enum: ["factual", "recent_news", "comparison", "how_to"],
+            description: "Optional: the type of answer needed. Helps the retrieval service weight results appropriately."
+          },
+          freshness: {
+            type: "string",
+            enum: ["current", "any"],
+            description: 'Optional: "current" asks the search provider for recent results and penalises sources published more than 90 days ago. Pass "current" whenever the answer can go stale: questions using latest/newest/current/right now/this year, software releases and version numbers, prices, benchmarks, rankings, ongoing events, and news. Omit it (or pass "any") for timeless background facts such as definitions, history, or how something works.'
+          }
         },
-        freshness: {
-          type: "string",
-          enum: ["current", "any"],
-          description: 'Optional: "current" penalises results older than 90 days. Use for breaking news or time-sensitive queries.'
-        }
-      },
-      required: ["query"]
+        required: ["query"]
+      }
     }
-  }
-};
+  };
+}
 var FETCH_URL_TOOL = {
   type: "function",
   function: {
@@ -8632,11 +9101,92 @@ var RUN_CODE_TOOL = {
     }
   }
 };
+function todayIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function normalizeIsoDate(raw) {
+  if (!raw) return void 0;
+  const match = /\d{4}-\d{2}-\d{2}/.exec(raw);
+  if (!match) return void 0;
+  const iso = match[0];
+  const ms = Date.parse(`${iso}T00:00:00Z`);
+  if (Number.isNaN(ms)) return void 0;
+  if (new Date(ms).toISOString().slice(0, 10) !== iso) return void 0;
+  const year = Number(iso.slice(0, 4));
+  if (year < 1990 || year > (/* @__PURE__ */ new Date()).getUTCFullYear() + 1) return void 0;
+  return iso;
+}
+function oneLine(s) {
+  return s.replace(/[\u200b\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, "").replace(/[\s\u0085]+/g, " ").trim();
+}
+function publishedLabel(r) {
+  const iso = normalizeIsoDate(r.publishedDate);
+  if (!iso) return "unknown";
+  const age = r.ageDays;
+  if (typeof age !== "number" || !Number.isFinite(age) || age < 0) return iso;
+  if (age === 0) return `${iso} (today)`;
+  return `${iso} (${age === 1 ? "1 day" : `${age} days`} ago)`;
+}
 function resolveSearchQuery(args) {
   if (typeof args.query === "string") return args.query;
   if (Array.isArray(args.queries) && typeof args.queries[0] === "string") return args.queries[0];
   return "";
 }
+var DATE_PROBE_MAX_BYTES = 96e3;
+var DATE_PROBE_TIMEOUT_MS = 4e3;
+function sourceAdvisory(query, results) {
+  if (results.length === 0) return null;
+  const roundups = results.filter((r) => aggregatorPenalty(r.title, r.url) > 0).length;
+  const primaries = results.filter(
+    (r) => officialSourceBoost(query, r.url) > 0 || officialDocsBoost(r.url) > 0
+  ).length;
+  if (primaries > 0 || roundups < Math.ceil(results.length / 2)) return null;
+  return `CAUTION: ${roundups} of these ${results.length} results are roundup/"best of" pages and none is a primary or official source. Pages like these are frequently re-published with a new date and stale contents, so they establish which names EXIST, not which is current or correct. Treat every name below as a CANDIDATE, not an answer: before recommending one, search that name against its own official source (the maker/organisation/authority behind it) and confirm the specifics there. If you cannot confirm a candidate that way, say so rather than repeating the roundup.`;
+}
+async function backfillPublishedDates(results) {
+  const missing = results.filter((r) => !r.publishedDate);
+  if (missing.length === 0) return;
+  await Promise.allSettled(
+    missing.map(async (r) => {
+      if (await checkSsrf(r.url)) return;
+      let resp;
+      try {
+        resp = await fetch(r.url, {
+          headers: { "User-Agent": "TurboLLM/0.7 (tool-fetch)" },
+          signal: AbortSignal.timeout(DATE_PROBE_TIMEOUT_MS)
+        });
+      } catch {
+        return;
+      }
+      if (!resp.ok || !resp.body) return;
+      let html = "";
+      try {
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let read = 0;
+        while (read < DATE_PROBE_MAX_BYTES) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          read += value.byteLength;
+          html += decoder.decode(value, { stream: true });
+        }
+        await reader.cancel().catch(() => {
+        });
+      } catch {
+        return;
+      }
+      const iso = extractPublishedDate(html);
+      if (!iso) return;
+      r.publishedDate = iso;
+      r.ageDays = ageInDays(iso);
+      r.freshnessSignal = freshnessSignal(r.ageDays);
+    })
+  );
+}
+function webSearchUnavailableMessage(reason) {
+  const cause = reason === "not_configured" ? "No web-search provider is configured (Settings \u2192 Tools)." : "Web search is not available in this conversation \u2014 the active engine did not receive the tool list.";
+  return `${cause} You CANNOT search the web on this turn, and no results will arrive however many times you ask. Answer from your own knowledge only, and say so plainly at the top of your reply: state that you could not search, that what follows is from training data which may be out of date, and flag anything that is likely to have changed since. Do not claim or imply that you searched, do not invent sources, citations, URLs or dates, and do not emit a confidence line.`;
+}
 async function execWebSearch(args, searchCfg) {
   const query = resolveSearchQuery(args);
   if (!query.trim()) return "Error: query is required.";
@@ -8649,16 +9199,75 @@ async function execWebSearch(args, searchCfg) {
     return `Error: could not reach the ${searchCfg.provider} search provider \u2014 ${e.message}`;
   }
   if (results.length === 0) return "No results found.";
-  const lines = [`RESEARCH RESULTS (${results.length} ranked results for "${query}"):`];
+  await backfillPublishedDates(results);
+  if (freshness === "current") {
+    for (const r of results) {
+      if (typeof r.ageDays === "number") {
+        r.relevanceScore = Math.round(r.relevanceScore * currentnessMultiplier(r.ageDays) * 1e3) / 1e3;
+      }
+    }
+    results.sort((a, b) => b.relevanceScore - a.relevanceScore);
+  }
+  const retrieved = todayIso();
+  const lines = [
+    `RESEARCH RESULTS (${results.length} ranked results for "${query.replace(/\s+/g, " ")}"):`,
+    `Retrieved: ${retrieved} \u2014 this search ran today, so treat ${retrieved} as the current date. Weigh each result against its Published date; "Published: unknown" means the source reported no date, not that it is current.`
+  ];
+  const advisory = sourceAdvisory(query, results);
+  if (advisory) lines.push(advisory);
   for (const [i, r] of results.entries()) {
     lines.push(`
-[${i + 1}] ${r.title}`);
+[${i + 1}] ${oneLine(r.title)}`);
     lines.push(`Source: ${r.url}`);
-    lines.push(`Domain: ${r.domain} | Relevance: ${r.relevanceScore.toFixed(2)} | Freshness: ${r.freshnessSignal}`);
-    lines.push(`Key passage: ${r.passage}`);
+    lines.push(`Domain: ${r.domain} | Relevance: ${r.relevanceScore.toFixed(2)} | Freshness: ${r.freshnessSignal} | Published: ${publishedLabel(r)} | Retrieved: ${retrieved}`);
+    lines.push(`Key passage: ${oneLine(r.passage)}`);
   }
   return lines.join("\n").trim();
 }
+var DATE_META_KEYS = /* @__PURE__ */ new Set([
+  "article:published_time",
+  "og:article:published_time",
+  "og:published_time",
+  "datepublished",
+  "date",
+  "dc.date",
+  "dc.date.issued",
+  "pubdate",
+  "publish-date"
+]);
+function extractPublishedDate(html) {
+  for (const block of html.matchAll(/<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi)) {
+    const iso = normalizeIsoDate(/"datePublished"\s*:\s*"([^"]{1,64})"/i.exec(block[1])?.[1]);
+    if (iso) return iso;
+  }
+  for (const tag of html.matchAll(/<meta\s[^>]*>/gi)) {
+    const key = /\b(?:property|name|itemprop)\s*=\s*["']([^"']{1,64})["']/i.exec(tag[0])?.[1];
+    if (!key || !DATE_META_KEYS.has(key.trim().toLowerCase())) continue;
+    const iso = normalizeIsoDate(/\bcontent\s*=\s*["']([^"']{1,64})["']/i.exec(tag[0])?.[1]);
+    if (iso) return iso;
+  }
+  for (const tag of html.matchAll(/<time\s[^>]*>/gi)) {
+    const iso = normalizeIsoDate(/\bdatetime\s*=\s*["']([^"']{1,64})["']/i.exec(tag[0])?.[1]);
+    if (iso) return iso;
+  }
+  return void 0;
+}
+var MODIFIED_META_KEYS = /* @__PURE__ */ new Set(["article:modified_time", "og:updated_time", "datemodified", "last-modified", "dc.date.modified"]);
+function extractModifiedDate(html) {
+  for (const block of html.matchAll(/<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi)) {
+    const iso = normalizeIsoDate(/"dateModified"\s*:\s*"([^"]{1,64})"/i.exec(block[1])?.[1]);
+    if (iso) return iso;
+  }
+  for (const tag of html.matchAll(/<meta\s[^>]*>/gi)) {
+    const key = /\b(?:property|name|itemprop)\s*=\s*["']([^"']{1,64})["']/i.exec(tag[0])?.[1];
+    if (!key || !MODIFIED_META_KEYS.has(key.trim().toLowerCase())) continue;
+    const iso = normalizeIsoDate(/\bcontent\s*=\s*["']([^"']{1,64})["']/i.exec(tag[0])?.[1]);
+    if (iso) return iso;
+  }
+  return void 0;
+}
+var FETCH_URL_MAX_CHARS = 2e4;
+var FETCH_URL_TRUNCATION_MARKER = "\n[truncated: this page was longer than the fetch limit and is cut off here. If the answer is not above, fetch a more specific URL on this site rather than assuming the page lacks it.]";
 async function execFetchUrl(args) {
   const url = String(args.url ?? "").trim();
   if (!url) return "Error: url is required.";
@@ -8677,13 +9286,20 @@ async function execFetchUrl(args) {
   const contentType2 = resp.headers.get("content-type") ?? "";
   const text = await resp.text().catch(() => "");
   let content;
+  let published;
+  let modified;
   if (contentType2.includes("text/html")) {
+    published = extractPublishedDate(text);
+    modified = extractModifiedDate(text);
     content = text.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/\s{2,}/g, " ").trim();
   } else {
     content = text.trim();
   }
-  if (content.length > 4e3) content = content.slice(0, 4e3) + "\n[truncated]";
-  return content || "(empty response)";
+  const header = modified && modified > (published ?? "") ? `Published: ${published ?? "unknown"} | Updated: ${modified} | Retrieved: ${todayIso()}` : `Published: ${published ?? "unknown"} | Retrieved: ${todayIso()}`;
+  const budget = FETCH_URL_MAX_CHARS - header.length - 1 - FETCH_URL_TRUNCATION_MARKER.length;
+  if (content.length > budget) content = content.slice(0, budget) + FETCH_URL_TRUNCATION_MARKER;
+  return `${header}
+${content || "(empty response)"}`;
 }
 function execRunCode(args) {
   const code = String(args.code ?? "").trim();
@@ -9007,7 +9623,7 @@ var ToolRegistry = class {
   /** Build the full tools array to send to the engine. Returns [] when no tools are available. */
   async buildToolDefinitions() {
     const defs = [];
-    if (searchConfigured(this.toolsCfg.search)) defs.push(WEB_SEARCH_TOOL);
+    if (searchConfigured(this.toolsCfg.search)) defs.push(webSearchTool());
     defs.push(FETCH_URL_TOOL);
     defs.push(RUN_CODE_TOOL);
     for (const client of this.mcpClients.values()) {
@@ -9034,7 +9650,7 @@ var ToolRegistry = class {
     const args = call.args;
     if (name === "web_search") {
       if (!searchConfigured(this.toolsCfg.search)) {
-        return "Error: no web-search provider configured. Add one in Settings \u2192 Tools.";
+        return `Error: ${webSearchUnavailableMessage("not_configured")}`;
       }
       return execWebSearch(args, this.toolsCfg.search);
     }
@@ -9058,6 +9674,13 @@ var ToolRegistry = class {
     }
     return `Error: unknown tool "${name}"`;
   }
+  /** Whether web_search can actually execute (a provider is configured). Distinct from whether
+   *  the model can REACH it — the tool list may still be suppressed downstream (see the
+   *  engine-kind gate in chat-routes.ts). Callers that need to explain a failed research turn
+   *  use this to pick between the 'not_configured' and 'tools_unreachable' reasons. */
+  searchAvailable() {
+    return searchConfigured(this.toolsCfg.search);
+  }
   /** Whether any tools are currently available (determines if tools should be sent to engine). */
   hasTools() {
     if (searchConfigured(this.toolsCfg.search)) return true;
@@ -10317,7 +10940,7 @@ var BUILTIN_SKILLS = [
   }
 ];
 function toSkillMd(skill) {
-  const fm = [`name: ${skill.name}`, `description: ${oneLine(skill.description)}`];
+  const fm = [`name: ${skill.name}`, `description: ${oneLine2(skill.description)}`];
   if (skill.tools.length) fm.push(`tools: ${skill.tools.join(", ")}`);
   return `---
 ${fm.join("\n")}
@@ -10345,7 +10968,7 @@ function fromSkillMd(id, raw) {
 function unquote(s) {
   return s.replace(/^["']|["']$/g, "").trim();
 }
-function oneLine(s) {
+function oneLine2(s) {
   return s.replace(/\s*\n\s*/g, " ").trim();
 }
 var SkillStore = class {
@@ -10628,6 +11251,19 @@ async function body(c) {
     return {};
   }
 }
+var BAKED_DATE_LINE = /^Today['’]s date is [^\n]{0,140}$\n?/gm;
+function currentDateLine(now) {
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  return `Today's date is ${y}-${m}-${d}. Use it only when the request depends on the current date; otherwise ignore it.`;
+}
+function withCurrentDate(systemPrompt, now = /* @__PURE__ */ new Date()) {
+  const base2 = systemPrompt.replace(BAKED_DATE_LINE, "").replace(/\n{3,}/g, "\n\n").trim();
+  return base2 ? `${base2}
+
+${currentDateLine(now)}` : currentDateLine(now);
+}
 function registerChatRoutes(app2, d) {
   const { db: db2 } = d;
   app2.get("/api/v1/folders", (c) => {
@@ -10775,7 +11411,7 @@ function registerChatRoutes(app2, d) {
       await stream.writeSSE({ event: "meta", data: JSON.stringify({ userMessageId: userMsg.id, assistantMessageId: assistantMsg.id }) });
       const allMsgs = (conv.messages ?? []).filter((m) => m.id !== assistantMsg.id);
       const engineMessages = [];
-      if (conv.systemPrompt) engineMessages.push({ role: "system", content: conv.systemPrompt });
+      if (conv.systemPrompt) engineMessages.push({ role: "system", content: withCurrentDate(conv.systemPrompt) });
       for (const m of allMsgs) {
         const content2 = conv.preserveThinking && m.role === "assistant" && m.reasoning?.trim() ? `<think>
 ${m.reasoning}
@@ -10821,7 +11457,7 @@ ${content}` : b.docContext : content;
       await stream.writeSSE({ event: "meta", data: JSON.stringify({ userMessageId: lastUser.id, assistantMessageId: assistantMsg.id }) });
       const allMsgs = (conv.messages ?? []).filter((m) => m.id !== assistantMsg.id);
       const engineMessages = [];
-      if (conv.systemPrompt) engineMessages.push({ role: "system", content: conv.systemPrompt });
+      if (conv.systemPrompt) engineMessages.push({ role: "system", content: withCurrentDate(conv.systemPrompt) });
       for (const m of allMsgs) {
         const content = conv.preserveThinking && m.role === "assistant" && m.reasoning?.trim() ? `<think>
 ${m.reasoning}
@@ -11065,7 +11701,11 @@ ${existing}`.trim() };
       }
     }
   }
-  const CONFIDENCE_INSTRUCTION = "\n\nAfter reviewing the search results, include a confidence assessment on a line by itself before your final answer: `[confidence: 0.XX]` where XX is your confidence (0.0\u20131.0) that your answer is accurate and current. If your confidence is below 0.8, call web_search again with a more specific query first. Maximum 3 search calls per response.";
+  const MAX_SEARCH_CALLS = 6;
+  const MAX_CONFIDENCE_RETRIES = 2;
+  const CONFIDENCE_INSTRUCTION = `
+
+After reviewing the search results, include a confidence assessment on a line by itself before your final answer: \`[confidence: 0.XX]\` where XX is your confidence (0.0\u20131.0) that your answer is accurate and current. If your confidence is below 0.8, call web_search again with a more specific query first. Maximum ${MAX_SEARCH_CALLS} search calls per response.`;
   if (conv.toolPolicy === "force_web_search") {
     const sysIdx = iterMessages.findIndex((m) => m.role === "system");
     if (sysIdx >= 0) {
@@ -11075,9 +11715,10 @@ ${existing}`.trim() };
       iterMessages.unshift({ role: "system", content: CONFIDENCE_INSTRUCTION.trim() });
     }
   }
-  const MAX_TOOL_ITER = 10;
+  const MAX_TOOL_ITER = 16;
   let toolIter = 0;
   let searchCallCount = 0;
+  let confidenceRetries = 0;
   const allResearchSources = [];
   let parsedConfidence;
   let fullContent = "";
@@ -11295,7 +11936,7 @@ ${existing}`.trim() };
           if (tc.name === "web_search" && !callError) {
             searchCallCount++;
             try {
-              const sourceMatches = [...result.matchAll(/\[(\d+)\] (.+?)\nSource: (\S+)\nDomain: (\S+) \| Relevance: ([\d.]+) \| Freshness: (\w+)\nKey passage: ([\s\S]+?)(?=\n\[|\s*$)/g)];
+              const sourceMatches = [...result.matchAll(/\[(\d+)\] (.+?)\nSource: (\S+)\nDomain: (\S+) \| Relevance: ([\d.]+) \| Freshness: (\w+)(?: \| Published: ([^|\n]*?))?(?: \| Retrieved: ([\d-]+))?\nKey passage: ([\s\S]+?)(?=\n\[|\s*$)/g)];
               for (const m of sourceMatches) {
                 allResearchSources.push({
                   title: m[2].trim(),
@@ -11303,7 +11944,7 @@ ${existing}`.trim() };
                   domain: m[4].trim(),
                   relevanceScore: parseFloat(m[5]),
                   freshnessSignal: m[6].trim(),
-                  passage: m[7].trim()
+                  passage: m[9].trim()
                 });
               }
             } catch {
@@ -11320,8 +11961,9 @@ ${existing}`.trim() };
           const conf = parseFloat(confMatch[1]);
           parsedConfidence = conf;
           fullContent = fullContent.replace(/\[confidence:\s*[\d.]+\]\s*/gi, "").trim();
-          if (conf < 0.8 && searchCallCount < 3) {
-            console.log(`[chat] F-021: confidence ${conf} < 0.8 (searches: ${searchCallCount}/3) \u2014 re-entering search loop`);
+          if (conf < 0.8 && searchCallCount < MAX_SEARCH_CALLS && confidenceRetries < MAX_CONFIDENCE_RETRIES) {
+            confidenceRetries++;
+            console.log(`[chat] F-021: confidence ${conf} < 0.8 (searches: ${searchCallCount}/${MAX_SEARCH_CALLS}, retry ${confidenceRetries}/${MAX_CONFIDENCE_RETRIES}) \u2014 re-entering search loop`);
             const toolDefs2 = await d.tools.buildToolDefinitions();
             if (toolDefs2.some((t) => t.function.name === "web_search")) {
               iterMessages.push({ role: "assistant", content: fullContent });
@@ -15208,6 +15850,33 @@ function keepRecentTokensFor(messages, baseKeepRecentTokens) {
 }
 var MUTATING_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "bash"]);
 var PATH_TOOLS = /* @__PURE__ */ new Set(["read", "edit", "write", "grep", "find", "ls"]);
+var LOOP_BREAK_AFTER = 3;
+function toolCallSignature(name, input) {
+  const stable = (v) => {
+    if (v === null || typeof v !== "object") return JSON.stringify(v) ?? "undefined";
+    if (Array.isArray(v)) return `[${v.map(stable).join(",")}]`;
+    const o = v;
+    return `{${Object.keys(o).sort().map((k) => `${JSON.stringify(k)}:${stable(o[k])}`).join(",")}}`;
+  };
+  return `${name}\0${stable(input)}`;
+}
+var ToolLoopTracker = class {
+  lastSig = null;
+  count = 0;
+  record(name, input) {
+    const sig = toolCallSignature(name, input);
+    if (sig === this.lastSig) this.count += 1;
+    else {
+      this.lastSig = sig;
+      this.count = 1;
+    }
+    return this.count;
+  }
+  reset() {
+    this.lastSig = null;
+    this.count = 0;
+  }
+};
 var DEPENDENCY_ADD_PATTERNS = [
   /\bnpm\s+(i|install|add)\s+\S/,
   /\byarn\s+add\s+\S/,
@@ -15291,6 +15960,7 @@ async function runCodeSession(params) {
   };
   let consecutiveToolFailures = 0;
   let hasSearchedWebThisTurn = false;
+  const toolLoop = new ToolLoopTracker();
   const getLspClient = (spec) => {
     let clients = lspClientsByConv.get(convId);
     if (!clients) {
@@ -15452,15 +16122,16 @@ async function runCodeSession(params) {
     pi.on("after_provider_response", () => {
       releaseGate();
     });
-    pi.on("turn_start", () => {
-      consecutiveToolFailures = 0;
-      hasSearchedWebThisTurn = false;
-    });
     pi.on("tool_call", async (event) => {
       const toolName = event.toolName;
       const toolCallId = event.toolCallId;
       const input = event.input;
       await sink({ event: "tool_call", data: { id: toolCallId, name: toolName, args: input, status: "pending" } });
+      if (toolLoop.record(toolName, input) > LOOP_BREAK_AFTER) {
+        const reason = `[SYSTEM: you have called \`${toolName}\` with identical arguments too many times in a row and it is not making progress \u2014 this call was NOT executed. Stop repeating it: take a different action, call it with different arguments, or, if you already have what you need, give your final answer now.]`;
+        await sink({ event: "tool_call", data: { id: toolCallId, name: toolName, args: input, status: "error", result: reason } });
+        return { block: true, reason };
+      }
       if (PATH_TOOLS.has(toolName)) {
         const p = input.path;
         const pathRequired = toolName === "read" || toolName === "edit" || toolName === "write";