mulmoclaude 0.1.2 → 0.4.0

package/server/workspace/sources/fetchers/rss.ts

@@ -74,7 +74,7 @@ function entryToSourceItem(entry: ParsedFeedItem, source: Source, lastSeenTs: nu
   // Use the feed's own id as a hint, but always derive the
   // SourceItem.id from the normalized URL so cross-source dedup
   // (see #188 Q3) lines up regardless of feed conventions.
-  const id = stableItemId(normalizedUrl);
+  const itemId = stableItemId(normalizedUrl);
   const publishedAt =
     entry.publishedAt ??
     // Synthesize a fetch-time timestamp when the feed didn't
@@ -85,7 +85,7 @@ function entryToSourceItem(entry: ParsedFeedItem, source: Source, lastSeenTs: nu
   // carry `undefined` fields that break exactOptionalPropertyTypes
   // on the server tsconfig.
   return {
-    id,
+    id: itemId,
     title: entry.title,
     url: normalizedUrl,
     publishedAt,
@@ -107,9 +107,9 @@ export function updateCursor(current: Record<string, string>, feed: ParsedFeed):
   let newest: number | null = null;
   for (const entry of feed.items) {
     if (!entry.publishedAt) continue;
-    const ts = Date.parse(entry.publishedAt);
-    if (!Number.isFinite(ts)) continue;
-    if (newest === null || ts > newest) newest = ts;
+    const publishedMs = Date.parse(entry.publishedAt);
+    if (!Number.isFinite(publishedMs)) continue;
+    if (newest === null || publishedMs > newest) newest = publishedMs;
   }
   if (newest === null) return current;
   // Only advance forwards. A feed whose newest item is older

package/server/workspace/sources/fetchers/rssParser.ts

@@ -178,7 +178,7 @@ function parseAtom(feed: Record<string, unknown>): ParsedFeed | null {
 
 function parseAtomEntry(raw: Record<string, unknown>): ParsedFeedItem | null {
   const title = readString(raw.title);
-  const id = readString(raw.id);
+  const entryId = readString(raw.id);
   const link = resolveAtomLink(raw.link);
   const published = readString(raw.published) ?? readString(raw.updated) ?? null;
   const publishedAt = published ? normalizeDate(published) : null;
@@ -189,7 +189,7 @@ function parseAtomEntry(raw: Record<string, unknown>): ParsedFeedItem | null {
   const summary = readString(raw.summary) ?? content;
   if (!title) return null;
   return {
-    feedId: id ?? link ?? null,
+    feedId: entryId ?? link ?? null,
     title,
     link,
     publishedAt,
@@ -289,7 +289,7 @@ function stripBom(text: string): string {
 // date is more useful to the pipeline than a null.
 function normalizeDate(raw: string | null): string | null {
   if (!raw) return null;
-  const ts = Date.parse(raw);
-  if (Number.isFinite(ts)) return new Date(ts).toISOString();
+  const parsed = Date.parse(raw);
+  if (Number.isFinite(parsed)) return new Date(parsed).toISOString();
   return raw;
 }

package/server/workspace/sources/interests.ts

@@ -4,7 +4,7 @@
 // during conversation when it detects user interest in a topic.
 // The pipeline's notify phase uses it to score and filter articles.
 
-import fs from "fs";
+import { existsSync, readFileSync } from "fs";
 import path from "path";
 import { workspacePath } from "../paths.js";
 import { log } from "../../system/logger/index.js";
@@ -41,8 +41,8 @@ export function loadInterests(root?: string): InterestsProfile | null {
   const base = root ?? workspacePath;
   const filePath = path.join(base, CONFIG_FILE);
   try {
-    if (!fs.existsSync(filePath)) return null;
-    const raw = fs.readFileSync(filePath, "utf-8");
+    if (!existsSync(filePath)) return null;
+    const raw = readFileSync(filePath, "utf-8");
     const parsed: unknown = JSON.parse(raw);
     return validateInterests(parsed);
   } catch (err) {
@@ -58,9 +58,9 @@ function validateInterests(raw: unknown): InterestsProfile | null {
   const obj = raw as Record<string, unknown>;
 
   // Filter out blank/whitespace-only keywords — "" matches every title
-  const keywords = Array.isArray(obj.keywords) ? obj.keywords.filter((k): k is string => isNonEmptyString(k)) : [];
+  const keywords = Array.isArray(obj.keywords) ? obj.keywords.filter((keyword): keyword is string => isNonEmptyString(keyword)) : [];
 
-  const categories = Array.isArray(obj.categories) ? obj.categories.filter((c): c is CategorySlug => isCategorySlug(c)) : [];
+  const categories = Array.isArray(obj.categories) ? obj.categories.filter((category): category is CategorySlug => isCategorySlug(category)) : [];
 
   if (keywords.length === 0 && categories.length === 0) return null;
 
@@ -88,16 +88,16 @@ export function scoreItem(item: SourceItem, profile: InterestsProfile): number {
   const titleLower = item.title.toLowerCase();
   const summaryLower = (item.summary ?? "").toLowerCase();
 
-  for (const kw of profile.keywords) {
-    const kwLower = kw.toLowerCase();
-    if (titleLower.includes(kwLower)) {
+  for (const keyword of profile.keywords) {
+    const keywordLower = keyword.toLowerCase();
+    if (titleLower.includes(keywordLower)) {
       score += KEYWORD_TITLE_WEIGHT;
-    } else if (summaryLower.includes(kwLower)) {
+    } else if (summaryLower.includes(keywordLower)) {
       score += KEYWORD_SUMMARY_WEIGHT;
     }
   }
 
-  const hasCategory = item.categories.some((c) => profile.categories.includes(c));
+  const hasCategory = item.categories.some((category) => profile.categories.includes(category));
   if (hasCategory) {
     score += CATEGORY_MATCH_WEIGHT;
   }
@@ -114,7 +114,7 @@ export function scoreItem(item: SourceItem, profile: InterestsProfile): number {
 export function scoreAndFilter(items: readonly SourceItem[], profile: InterestsProfile): ScoredItem[] {
   return items
     .map((item) => ({ item, score: scoreItem(item, profile) }))
-    .filter((s) => s.score >= profile.minRelevance)
-    .sort((a, b) => b.score - a.score)
+    .filter((scoredItem) => scoredItem.score >= profile.minRelevance)
+    .sort((leftItem, rightItem) => rightItem.score - leftItem.score)
     .slice(0, profile.maxNotificationsPerRun);
 }

package/server/workspace/sources/paths.ts

@@ -71,11 +71,11 @@ export function newsRoot(workspaceRoot: string): string {
 export function dailyNewsPath(workspaceRoot: string, isoDate: string): string {
   // Validate shape at the boundary so an empty / bogus date can't
   // produce "undefined/undefined/undefined.md" downstream.
-  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(isoDate);
-  if (!m) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(isoDate);
+  if (!match) {
     throw new Error(`[sources] dailyNewsPath: expected YYYY-MM-DD, got "${isoDate}"`);
   }
-  const [, year, month, day] = m;
+  const [, year, month, day] = match;
   return path.join(newsRoot(workspaceRoot), DAILY_DIR, year, month, `${day}.md`);
 }
 
@@ -94,11 +94,11 @@ export function archiveDir(workspaceRoot: string, slug: string): string {
 // to split; we do the split here.
 export function archivePath(workspaceRoot: string, slug: string, yearMonth: string): string {
   assertValidSlug(slug);
-  const m = /^(\d{4})-(\d{2})$/.exec(yearMonth);
-  if (!m) {
+  const match = /^(\d{4})-(\d{2})$/.exec(yearMonth);
+  if (!match) {
     throw new Error(`[sources] archivePath: expected YYYY-MM, got "${yearMonth}"`);
   }
-  const [, year, month] = m;
+  const [, year, month] = match;
   return path.join(archiveDir(workspaceRoot, slug), year, `${month}.md`);
 }
 

package/server/workspace/sources/pipeline/fetch.ts

@@ -15,7 +15,7 @@ import type { FetcherDeps, FetchResult, SourceFetcher } from "../fetchers/index.
 import type { FetcherKind, Source, SourceState } from "../types.js";
 import { defaultSourceState } from "../types.js";
 import { errorMessage } from "../../../utils/errors.js";
-import { ONE_MINUTE_MS, ONE_DAY_MS } from "../../../utils/time.js";
+import { ONE_MINUTE_MS, ONE_HOUR_MS, ONE_DAY_MS } from "../../../utils/time.js";
 
 // Outcome of one source's fetch attempt.
 export type FetchOutcome =
@@ -98,31 +98,52 @@ export function backoffDelayMs(consecutiveFailures: number): number {
   if (consecutiveFailures <= 0) return 0;
   // 1m, 2m, 4m, 8m, 16m, ..., capped at 24h.
   const base = ONE_MINUTE_MS;
-  const ms = base * 2 ** Math.min(consecutiveFailures - 1, 20);
-  return Math.min(ms, BACKOFF_MAX_MS);
+  const delayMs = base * 2 ** Math.min(consecutiveFailures - 1, 20);
+  return Math.min(delayMs, BACKOFF_MAX_MS);
+}
+
+// Number of consecutive empty fetches before adaptive backoff kicks in.
+export const EMPTY_FETCH_THRESHOLD = 3;
+export const EMPTY_BACKOFF_MAX_MS = ONE_DAY_MS;
+
+// Exponential backoff (in ms) for Nth consecutive empty-success fetch.
+// Returns 0 when below the threshold so callers can use it as a guard.
+// Starts at 1h after threshold, doubling each time up to 24h.
+export function emptyBackoffDelayMs(consecutiveEmptyFetches: number): number {
+  if (consecutiveEmptyFetches < EMPTY_FETCH_THRESHOLD) return 0;
+  const steps = consecutiveEmptyFetches - EMPTY_FETCH_THRESHOLD;
+  const delayMs = ONE_HOUR_MS * 2 ** Math.min(steps, 10);
+  return Math.min(delayMs, EMPTY_BACKOFF_MAX_MS);
 }
 
 // Compute the next per-source state given the outcome. Pure.
 //
-// On success:
-//   - lastFetchedAt = now
-//   - cursor = outcome.cursor (replace wholesale — fetchers
-//     return the merged cursor map)
-//   - consecutiveFailures = 0
-//   - nextAttemptAt = null
+// On success with items:
+//   - lastFetchedAt = now, cursor updated
+//   - consecutiveFailures = 0, nextAttemptAt = null
+//   - consecutiveEmptyFetches = 0, emptyBackoffUntil = null
+// On success with 0 items:
+//   - lastFetchedAt = now, cursor updated
+//   - consecutiveFailures = 0, nextAttemptAt = null
+//   - consecutiveEmptyFetches += 1
+//   - emptyBackoffUntil = now + emptyBackoffDelayMs(newCount) if above threshold
 // On any non-success:
-//   - lastFetchedAt unchanged (we didn't successfully fetch)
-//   - cursor unchanged
-//   - consecutiveFailures += 1
-//   - nextAttemptAt = now + backoffDelayMs(newCount)
+//   - lastFetchedAt/cursor unchanged
+//   - consecutiveFailures += 1, nextAttemptAt = now + backoffDelayMs(newCount)
+//   - consecutiveEmptyFetches/emptyBackoffUntil unchanged
 export function computeNextState(prev: SourceState, outcome: FetchOutcome, nowMs: number): SourceState {
   if (outcome.kind === "success") {
+    const hasItems = outcome.items.length > 0;
+    const emptyCount = hasItems ? 0 : prev.consecutiveEmptyFetches + 1;
+    const emptyDelayMs = emptyBackoffDelayMs(emptyCount);
     return {
       slug: prev.slug,
       lastFetchedAt: new Date(nowMs).toISOString(),
       cursor: outcome.cursor,
       consecutiveFailures: 0,
       nextAttemptAt: null,
+      consecutiveEmptyFetches: emptyCount,
+      emptyBackoffUntil: emptyDelayMs > 0 ? new Date(nowMs + emptyDelayMs).toISOString() : null,
     };
   }
   const failures = prev.consecutiveFailures + 1;
@@ -132,5 +153,7 @@ export function computeNextState(prev: SourceState, outcome: FetchOutcome, nowMs
     cursor: prev.cursor,
     consecutiveFailures: failures,
     nextAttemptAt: new Date(nowMs + backoffDelayMs(failures)).toISOString(),
+    consecutiveEmptyFetches: prev.consecutiveEmptyFetches,
+    emptyBackoffUntil: prev.emptyBackoffUntil,
   };
 }

package/server/workspace/sources/pipeline/index.ts

@@ -34,6 +34,7 @@ import { listSources } from "../registry.js";
 import { readManyStates, writeManyStates } from "../sourceState.js";
 import { dailyNewsPath } from "../paths.js";
 import { getFetcher as registryGetFetcher, type FetcherDeps, type SourceFetcher } from "../fetchers/index.js";
+import { defaultSourceState } from "../types.js";
 import type { FetcherKind, Source, SourceItem, SourceState, SourceSchedule } from "../types.js";
 import { planEligibleSources } from "./plan.js";
 import { runFetchPhase, computeNextState, type FetchOutcome } from "./fetch.js";
@@ -92,11 +93,11 @@ export { toLocalIsoDate } from "../../../utils/date.js";
 // Convert a wall-clock millis value to the LOCAL year-month
 // key (YYYY-MM) used as the archive fallback for items without
 // a parseable publishedAt.
-export function toLocalYearMonth(ms: number): string {
-  const d = new Date(ms);
-  const y = d.getFullYear();
-  const m = String(d.getMonth() + 1).padStart(2, "0");
-  return `${y}-${m}`;
+export function toLocalYearMonth(millis: number): string {
+  const date = new Date(millis);
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  return `${year}-${month}`;
 }
 
 export async function runSourcesPipeline(input: RunPipelineInput): Promise<RunPipelineResult> {
@@ -125,7 +126,7 @@ export async function runSourcesPipeline(input: RunPipelineInput): Promise<RunPi
   const allSources = await listSources(workspaceRoot);
   const statesBySlug = await readManyStates(
     workspaceRoot,
-    allSources.map((s) => s.slug),
+    allSources.map((source) => source.slug),
   );
 
   // --- 2. Plan ------------------------------------------------------
@@ -234,13 +235,7 @@ function buildNextStates(
   }
   const nextStates: SourceState[] = [];
   for (const source of eligible) {
-    const prev = statesBySlug.get(source.slug) ?? {
-      slug: source.slug,
-      lastFetchedAt: null,
-      cursor: {},
-      consecutiveFailures: 0,
-      nextAttemptAt: null,
-    };
+    const prev = statesBySlug.get(source.slug) ?? defaultSourceState(source.slug);
     const outcome = outcomeBySlug.get(source.slug);
     if (!outcome) continue; // unreachable in practice; defensive
     nextStates.push(computeNextState(prev, outcome, nowMs));

package/server/workspace/sources/pipeline/notify.ts

@@ -30,7 +30,7 @@ export function runNotifyPhase(items: readonly SourceItem[], workspaceRoot?: str
 }
 
 function formatSingleBody(item: SourceItem): string {
-  const suffix = item.summary ? " \u2014 " + item.summary : "";
+  const suffix = item.summary ? " — " + item.summary : "";
   return "From " + item.sourceSlug + suffix;
 }
 
@@ -52,12 +52,12 @@ function publishBatchNotification(scored: readonly ScoredItem[]): void {
 
   const bullets = scored
     .slice(0, 5)
-    .map((s) => `\u2022 ${s.item.title} (${s.item.sourceSlug})`)
+    .map((row) => `• ${row.item.title} (${row.item.sourceSlug})`)
     .join("\n");
   const extra = scored.length > 5 ? `\n+${scored.length - 5} more` : "";
 
   // Preserve high priority if any item in the batch is critical
-  const hasCritical = scored.some((s) => s.item.severity === "critical");
+  const hasCritical = scored.some((row) => row.item.severity === "critical");
 
   publishNotification({
     kind: NOTIFICATION_KINDS.push,

package/server/workspace/sources/pipeline/plan.ts

@@ -31,8 +31,8 @@ export interface PlanInput {
 // Sort key: slug, ascending. Deterministic ordering keeps the
 // daily summary's item sequence stable across runs for the same
 // input, which makes markdown diffs readable.
-function bySlug(a: Source, b: Source): number {
-  return a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0;
+function bySlug(left: Source, right: Source): number {
+  return left.slug < right.slug ? -1 : left.slug > right.slug ? 1 : 0;
 }
 
 // Returns the subset of sources eligible for this cycle. Pure.
@@ -49,18 +49,20 @@ export function planEligibleSources(input: PlanInput): Source[] {
 }
 
 // True when the state indicates the source is STILL in backoff
-// (so we should SKIP it). False means eligible to run now.
+// (so we should SKIP it). Checks both error backoff (nextAttemptAt)
+// and empty-fetch adaptive backoff (emptyBackoffUntil). Either one
+// being in the future is enough to skip this cycle.
 //
-// - No state at all → run.
-// - No nextAttemptAt → run.
-// - nextAttemptAt unparseable → run (don't let a corrupt state
-//   file permanently lock out a source).
-// - nextAttemptAt in the future → skip.
-// - nextAttemptAt at or before now → run.
+// Corrupt / unparseable timestamps are ignored so a bad state file
+// never permanently locks out a source.
 function isWithinBackoff(state: SourceState | undefined, nowMs: number): boolean {
   if (!state) return false;
-  if (!state.nextAttemptAt) return false;
-  const ts = Date.parse(state.nextAttemptAt);
-  if (!Number.isFinite(ts)) return false;
-  return ts > nowMs;
+  return isFutureTimestamp(state.nextAttemptAt, nowMs) || isFutureTimestamp(state.emptyBackoffUntil, nowMs);
+}
+
+function isFutureTimestamp(timestamp: string | null | undefined, nowMs: number): boolean {
+  if (!timestamp) return false;
+  const parsed = Date.parse(timestamp);
+  if (!Number.isFinite(parsed)) return false;
+  return parsed > nowMs;
 }

package/server/workspace/sources/pipeline/write.ts

@@ -130,11 +130,11 @@ export function renderItemForArchive(item: SourceItem): string {
 // Malformed dates fall back to the caller-supplied default
 // (typically the current YYYY-MM) so we don't drop items.
 export function archiveMonthFor(isoPublishedAt: string, fallbackMonth: string): string {
-  const ts = Date.parse(isoPublishedAt);
-  if (!Number.isFinite(ts)) return fallbackMonth;
-  const d = new Date(ts);
-  const year = d.getUTCFullYear();
-  const month = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const parsed = Date.parse(isoPublishedAt);
+  if (!Number.isFinite(parsed)) return fallbackMonth;
+  const date = new Date(parsed);
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
   return `${year}-${String(month).padStart(2, "0")}`;
 }
 

package/server/workspace/sources/rateLimiter.ts

@@ -41,7 +41,7 @@ export interface RateLimiterDeps {
 export function defaultRateLimiterDeps(): RateLimiterDeps {
   return {
     now: () => Date.now(),
-    sleep: (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)),
+    sleep: (millis: number) => new Promise<void>((resolve) => setTimeout(resolve, millis)),
   };
 }
 

package/server/workspace/sources/registry.ts

@@ -100,43 +100,43 @@ function parseValue(raw: string): string | string[] {
   if (arrayMatch) {
     return arrayMatch[1]
       .split(",")
-      .map((s) => unquote(s.trim()))
-      .filter((s) => s.length > 0);
+      .map((segment) => unquote(segment.trim()))
+      .filter((segment) => segment.length > 0);
   }
   return unquote(raw);
 }
 
-function unquote(s: string): string {
+function unquote(input: string): string {
   // Double-quoted strings: yamlScalar writes JSON-compatible escape
   // sequences (\\ for \, \" for "), so JSON.parse reverses them in
   // one shot. Fall back to a plain strip if the string is
   // double-quoted but somehow malformed.
-  if (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) {
+  if (input.length >= 2 && input.startsWith('"') && input.endsWith('"')) {
     try {
-      return JSON.parse(s);
+      return JSON.parse(input);
     } catch {
-      return s.slice(1, -1);
+      return input.slice(1, -1);
     }
   }
   // Single-quoted scalars follow YAML's doubling convention: '' → '.
-  if (s.length >= 2 && s.startsWith("'") && s.endsWith("'")) {
-    return s.slice(1, -1).replace(/''/g, "'");
+  if (input.length >= 2 && input.startsWith("'") && input.endsWith("'")) {
+    return input.slice(1, -1).replace(/''/g, "'");
   }
-  return s;
+  return input;
 }
 
 // --- Source validation / construction -----------------------------------
 
 function stringField(fields: Map<string, string | string[]>, key: string): string | null {
-  const v = fields.get(key);
-  return isNonEmptyString(v) ? v : null;
+  const value = fields.get(key);
+  return isNonEmptyString(value) ? value : null;
 }
 
 function numberField(fields: Map<string, string | string[]>, key: string, defaultValue: number): number {
-  const v = fields.get(key);
-  if (typeof v !== "string") return defaultValue;
-  const n = Number(v);
-  return Number.isFinite(n) && n > 0 ? Math.floor(n) : defaultValue;
+  const value = fields.get(key);
+  if (typeof value !== "string") return defaultValue;
+  const parsedNumber = Number(value);
+  return Number.isFinite(parsedNumber) && parsedNumber > 0 ? Math.floor(parsedNumber) : defaultValue;
 }
 
 // Default per-fetch cap. Fetchers treat it as a hint — if the
@@ -302,7 +302,7 @@ export async function listSources(workspaceRoot: string): Promise<Source[]> {
     }
   }
   // Deterministic sort by slug so callers can rely on stable order.
-  out.sort((a, b) => (a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0));
+  out.sort((leftSource, rightSource) => (leftSource.slug < rightSource.slug ? -1 : leftSource.slug > rightSource.slug ? 1 : 0));
   return out;
 }
 

package/server/workspace/sources/robots.ts

@@ -105,8 +105,8 @@ function applyRule(group: RobotsGroup, name: string, value: string): void {
   } else if (name === "allow") {
     group.rules.push({ kind: "allow", pattern: value });
   } else if (name === "crawl-delay") {
-    const n = Number(value);
-    if (Number.isFinite(n) && n >= 0) group.crawlDelaySec = n;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0) group.crawlDelaySec = seconds;
   }
   // Any other directive: ignored.
 }
@@ -138,13 +138,13 @@ function parseDirective(line: string): { name: string; value: string } | null {
 // duplicate group get ignored, which could silently let a fetcher
 // hit a path the site explicitly blocked.
 export function selectGroup(robots: ParsedRobots, userAgent: string): RobotsGroup | null {
-  const ua = userAgent.toLowerCase();
+  const agent = userAgent.toLowerCase();
   const exacts: RobotsGroup[] = [];
   const stars: RobotsGroup[] = [];
   let bestPrefixScore = -1;
   let prefixMatches: RobotsGroup[] = [];
   for (const group of robots.groups) {
-    const outcome = scoreGroupAgainstAgent(group, ua);
+    const outcome = scoreGroupAgainstAgent(group, agent);
     if (outcome.kind === "exact") exacts.push(outcome.group);
     else if (outcome.kind === "star") stars.push(outcome.group);
     else if (outcome.kind === "prefix") {
@@ -170,11 +170,11 @@ function mergeGroups(groups: readonly RobotsGroup[]): RobotsGroup {
   const rules: RobotsRule[] = [];
   const userAgents: string[] = [];
   let crawlDelaySec: number | null = null;
-  for (const g of groups) {
-    rules.push(...g.rules);
-    userAgents.push(...g.userAgents);
-    if (g.crawlDelaySec !== null) {
-      crawlDelaySec = crawlDelaySec === null ? g.crawlDelaySec : Math.min(crawlDelaySec, g.crawlDelaySec);
+  for (const group of groups) {
+    rules.push(...group.rules);
+    userAgents.push(...group.userAgents);
+    if (group.crawlDelaySec !== null) {
+      crawlDelaySec = crawlDelaySec === null ? group.crawlDelaySec : Math.min(crawlDelaySec, group.crawlDelaySec);
     }
   }
   return { userAgents, rules, crawlDelaySec };
@@ -186,7 +186,7 @@ type AgentMatch =
   | { kind: "star"; group: RobotsGroup }
   | { kind: "none" };
 
-function scoreGroupAgainstAgent(group: RobotsGroup, ua: string): AgentMatch {
+function scoreGroupAgainstAgent(group: RobotsGroup, agent: string): AgentMatch {
   let bestPrefix = -1;
   let hasStar = false;
   for (const listed of group.userAgents) {
@@ -194,8 +194,8 @@ function scoreGroupAgainstAgent(group: RobotsGroup, ua: string): AgentMatch {
       hasStar = true;
       continue;
     }
-    if (listed === ua) return { kind: "exact", group };
-    if (ua.startsWith(listed) && listed.length > bestPrefix) {
+    if (listed === agent) return { kind: "exact", group };
+    if (agent.startsWith(listed) && listed.length > bestPrefix) {
       bestPrefix = listed.length;
     }
   }
@@ -266,6 +266,6 @@ export function matchesPattern(pattern: string, path: string): number {
     .split("*")
     .map((chunk) => chunk.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
     .join(".*");
-  const re = new RegExp("^" + regexBody + (endAnchored ? "$" : ""));
-  return re.test(path) ? pattern.length : -1;
+  const regex = new RegExp("^" + regexBody + (endAnchored ? "$" : ""));
+  return regex.test(path) ? pattern.length : -1;
 }

package/server/workspace/sources/sourceState.ts

@@ -47,21 +47,28 @@ export function validateSourceState(raw: unknown, slug: string): SourceState {
   if (!isRecord(raw)) {
     return defaultSourceState(slug);
   }
-  const o = raw as Record<string, unknown>;
-  const lastFetchedAt = typeof o.lastFetchedAt === "string" ? o.lastFetchedAt : null;
-  const nextAttemptAt = typeof o.nextAttemptAt === "string" ? o.nextAttemptAt : null;
-  const consecutiveFailures =
-    typeof o.consecutiveFailures === "number" && Number.isFinite(o.consecutiveFailures) && o.consecutiveFailures >= 0 ? Math.floor(o.consecutiveFailures) : 0;
-  const cursor = validateCursor(o.cursor);
+  const record = raw as Record<string, unknown>;
+  const lastFetchedAt = typeof record.lastFetchedAt === "string" ? record.lastFetchedAt : null;
+  const nextAttemptAt = typeof record.nextAttemptAt === "string" ? record.nextAttemptAt : null;
+  const emptyBackoffUntil = typeof record.emptyBackoffUntil === "string" ? record.emptyBackoffUntil : null;
+  const consecutiveFailures = toNonNegativeInt(record.consecutiveFailures);
+  const consecutiveEmptyFetches = toNonNegativeInt(record.consecutiveEmptyFetches);
+  const cursor = validateCursor(record.cursor);
   return {
     slug,
     lastFetchedAt,
     cursor,
     consecutiveFailures,
     nextAttemptAt,
+    consecutiveEmptyFetches,
+    emptyBackoffUntil,
   };
 }
 
+function toNonNegativeInt(value: unknown): number {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : 0;
+}
+
 function validateCursor(raw: unknown): Record<string, string> {
   if (!isRecord(raw)) {
     return {};
@@ -127,9 +134,9 @@ export async function deleteSourceState(workspaceRoot: string, slug: string): Pr
 // deterministic regardless of which fetcher finished first.
 // Used by reporting / logging code.
 export function sortBySlug<T extends { sourceSlug?: string; slug?: string }>(items: readonly T[]): T[] {
-  return [...items].sort((a, b) => {
-    const ak = a.sourceSlug ?? a.slug ?? "";
-    const bk = b.sourceSlug ?? b.slug ?? "";
-    return ak < bk ? -1 : ak > bk ? 1 : 0;
+  return [...items].sort((left, right) => {
+    const leftKey = left.sourceSlug ?? left.slug ?? "";
+    const rightKey = right.sourceSlug ?? right.slug ?? "";
+    return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
   });
 }

package/server/workspace/sources/types.ts

@@ -131,6 +131,13 @@ export interface SourceState {
   // Timestamp after which the next attempt is allowed, so backoff
   // survives server restarts.
   nextAttemptAt: string | null;
+  // Consecutive empty-success count (fetcher returned 0 items).
+  // Reset to 0 when items are found. Drives adaptive empty backoff.
+  consecutiveEmptyFetches: number;
+  // Timestamp after which the next attempt is allowed following
+  // repeated empty fetches. Separate from nextAttemptAt (error
+  // backoff) so the two policies don't interfere.
+  emptyBackoffUntil: string | null;
 }
 
 export function defaultSourceState(slug: string): SourceState {
@@ -140,5 +147,7 @@ export function defaultSourceState(slug: string): SourceState {
     cursor: {},
     consecutiveFailures: 0,
     nextAttemptAt: null,
+    consecutiveEmptyFetches: 0,
+    emptyBackoffUntil: null,
   };
 }

package/server/workspace/sources/urls.ts

@@ -80,7 +80,7 @@ export function normalizeUrl(raw: string): string | null {
   // Sort remaining params for deterministic ordering. Preserve
   // multi-value params by iterating all entries.
   const entries = Array.from(url.searchParams.entries());
-  entries.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+  entries.sort(([leftKey], [rightKey]) => (leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0));
   // Clear and reinsert.
   for (const name of Array.from(url.searchParams.keys())) {
     url.searchParams.delete(name);

package/server/workspace/tool-trace/classify.ts

@@ -96,10 +96,10 @@ function imagePointerFromContent(content: string): string | null {
 // regardless of how the tool happened to quote it. Leave "../"
 // prefixes alone — a relative escape is a bug and we want it visible
 // rather than silently fixed up.
-function normalizeWorkspacePath(p: string): string {
-  if (p.startsWith("./")) return p.slice(2);
-  if (p.startsWith("/")) return p.slice(1);
-  return p;
+function normalizeWorkspacePath(candidatePath: string): string {
+  if (candidatePath.startsWith("./")) return candidatePath.slice(2);
+  if (candidatePath.startsWith("/")) return candidatePath.slice(1);
+  return candidatePath;
 }
 
 function inlineWithTruncation(content: string): Classification {

package/server/workspace/tool-trace/index.ts

@@ -225,7 +225,7 @@ async function maybeWriteSearch(inputs: MaybeWriteSearchInputs): Promise<string
       workspaceRoot: inputs.workspaceRoot,
       query,
       sessionId: inputs.chatSessionId,
-      ts: inputs.now,
+      timestamp: inputs.now,
       resultBody: inputs.content,
     });
   } catch (err) {