mulmoclaude 0.1.2 → 0.3.0

package/server/workspace/sources/arxivDiscovery.ts

@@ -33,8 +33,8 @@ const DEFAULT_MAX_ITEMS = 20;
  * Example: ["transformer", "attention"] → 'ti:"transformer" OR abs:"transformer" OR ti:"attention" OR abs:"attention"'
  */
 export function buildArxivQuery(keywords: readonly string[]): string {
-  const terms = keywords.flatMap((kw) => {
-    const stripped = kw.replace(/"/g, "");
+  const terms = keywords.flatMap((keyword) => {
+    const stripped = keyword.replace(/"/g, "");
     return [`ti:"${stripped}"`, `abs:"${stripped}"`];
   });
   return terms.join(" OR ");
@@ -48,8 +48,8 @@ export function buildArxivQuery(keywords: readonly string[]): string {
  */
 export function keywordsToSlug(keywords: readonly string[]): string {
   const latin = keywords
-    .map((kw) => slugify(kw, ""))
-    .filter((s) => s.length > 0)
+    .map((keyword) => slugify(keyword, ""))
+    .filter((slugPart) => slugPart.length > 0)
     .slice(0, 3)
     .join("-");
   // Short hash of ALL keywords ensures uniqueness even when the
@@ -91,7 +91,7 @@ export async function discoverAndRegister(root?: string): Promise<DiscoveryResul
   fs.mkdirSync(dir, { recursive: true });
 
   const existing = await listSources(base);
-  const existingSlugs = new Set(existing.map((s) => s.slug));
+  const existingSlugs = new Set(existing.map((source) => source.slug));
 
   const registered: string[] = [];
   const skipped: string[] = [];
@@ -158,17 +158,17 @@ export async function pruneStaleAutoSources(root?: string): Promise<string[]> {
   const base = root ?? workspacePath;
   const profile = loadInterests(base);
   const existing = await listSources(base);
-  const autoSources = existing.filter((s) => s.slug.startsWith(ARXIV_SLUG_PREFIX));
+  const autoSources = existing.filter((source) => source.slug.startsWith(ARXIV_SLUG_PREFIX));
 
   if (autoSources.length === 0) return [];
 
   // If no profile at all, prune everything auto-registered
-  const currentKeywords = profile ? new Set(profile.keywords.map((k) => k.toLowerCase())) : new Set<string>();
+  const currentKeywords = profile ? new Set(profile.keywords.map((keyword) => keyword.toLowerCase())) : new Set<string>();
 
   const pruned: string[] = [];
   for (const source of autoSources) {
     const notes = (source.notes ?? "").toLowerCase();
-    const hasMatch = [...currentKeywords].some((kw) => notes.includes(kw));
+    const hasMatch = [...currentKeywords].some((keyword) => notes.includes(keyword));
     if (!hasMatch && currentKeywords.size > 0) {
       // Keywords changed — this source is stale but don't delete,
       // just log. User can manually remove via manageSource.

package/server/workspace/sources/classifier.ts

@@ -115,18 +115,18 @@ export function buildClassifyPrompt(input: ClassifyInput): string {
   if (titles.length > 0) {
     lines.push("");
     lines.push("RECENT ITEM TITLES:");
-    for (const t of titles.slice(0, 5)) {
-      lines.push(`- ${t}`);
+    for (const title of titles.slice(0, 5)) {
+      lines.push(`- ${title}`);
     }
   }
   const summaries = input.sampleSummaries ?? [];
   if (summaries.length > 0) {
     lines.push("");
     lines.push("RECENT ITEM SUMMARIES:");
-    for (const s of summaries.slice(0, 3)) {
+    for (const summary of summaries.slice(0, 3)) {
       // One-line truncation so a single long abstract doesn't
       // dominate the prompt budget.
-      lines.push(`- ${s.replace(/\s+/g, " ").slice(0, 200)}`);
+      lines.push(`- ${summary.replace(/\s+/g, " ").slice(0, 200)}`);
     }
   }
   return lines.join("\n");
@@ -167,8 +167,8 @@ export function validateClassifyResult(obj: unknown): ClassifyResult {
   if (!isRecord(obj)) {
     throw new Error("[sources/classifier] output is not an object");
   }
-  const o = obj as Record<string, unknown>;
-  const categories = normalizeCategories(o.categories);
+  const record = obj as Record<string, unknown>;
+  const categories = normalizeCategories(record.categories);
   if (categories.length === 0) {
     // The model is required to pick at least one (min_items=1 in
     // the schema). If we end up here, something went wrong upstream
@@ -178,7 +178,7 @@ export function validateClassifyResult(obj: unknown): ClassifyResult {
     // with no categories.
     throw new Error("[sources/classifier] output has no valid categories from the taxonomy");
   }
-  const rationale = typeof o.rationale === "string" ? o.rationale.slice(0, 400) : "";
+  const rationale = typeof record.rationale === "string" ? record.rationale.slice(0, 400) : "";
   return { categories, rationale };
 }
 

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

@@ -90,8 +90,8 @@ export function normalizeArxivFeed(feed: ParsedFeed, source: Source, cursor: Rec
 function parseCursorTs(cursor: Record<string, string>): number | null {
   const raw = cursor[ARXIV_CURSOR_KEY];
   if (!raw) return null;
-  const ts = Date.parse(raw);
-  return Number.isFinite(ts) ? ts : null;
+  const parsed = Date.parse(raw);
+  return Number.isFinite(parsed) ? parsed : null;
 }
 
 // Decide whether one ParsedFeedItem produces a SourceItem given
@@ -104,8 +104,8 @@ function feedItemToSourceItem(entry: ParsedFeed["items"][number], source: Source
   const normalizedUrl = normalizeUrl(entry.link);
   if (!normalizedUrl) return null;
   if (entry.publishedAt && lastSeenTs !== null) {
-    const ts = Date.parse(entry.publishedAt);
-    if (Number.isFinite(ts) && ts <= lastSeenTs) return null;
+    const publishedMs = Date.parse(entry.publishedAt);
+    if (Number.isFinite(publishedMs) && publishedMs <= lastSeenTs) return null;
   }
   const publishedAt = entry.publishedAt ?? new Date().toISOString();
   return {
@@ -128,9 +128,9 @@ export function updateArxivCursor(current: Record<string, string>, feed: ParsedF
   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;
   const currentTs = current[ARXIV_CURSOR_KEY] ? Date.parse(current[ARXIV_CURSOR_KEY]) : -Infinity;

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

@@ -69,7 +69,7 @@ interface ParsedIssue {
 // signal.
 export function parseGithubIssue(raw: unknown): ParsedIssue | null {
   if (!isRecord(raw)) return null;
-  const id = typeof raw.id === "number" && Number.isFinite(raw.id) ? raw.id : null;
+  const issueId = typeof raw.id === "number" && Number.isFinite(raw.id) ? raw.id : null;
   const issueNumber = typeof raw.number === "number" && Number.isFinite(raw.number) ? raw.number : null;
   const title = typeof raw.title === "string" ? raw.title : null;
   const htmlUrl = typeof raw.html_url === "string" ? raw.html_url : null;
@@ -81,7 +81,7 @@ export function parseGithubIssue(raw: unknown): ParsedIssue | null {
   // object) means this is a PR. Absence means it's an issue.
   const isPr = "pull_request" in raw && raw.pull_request !== undefined && raw.pull_request !== null;
   return {
-    id,
+    id: issueId,
     number: issueNumber,
     title,
     htmlUrl,
@@ -110,7 +110,7 @@ export function issueToSourceItem(issue: ParsedIssue, source: Source, params: Is
 
   const normalizedUrl = normalizeUrl(issue.htmlUrl);
   if (!normalizedUrl) return null;
-  const id = stableItemId(normalizedUrl);
+  const itemId = stableItemId(normalizedUrl);
 
   // Title annotations: `[PR]` for pulls, `[closed]` for closed
   // state so the daily summary makes state visible at a glance.
@@ -123,7 +123,7 @@ export function issueToSourceItem(issue: ParsedIssue, source: Source, params: Is
   const summary = issue.body ? firstParagraph(issue.body) : null;
 
   return {
-    id,
+    id: itemId,
     title,
     url: normalizedUrl,
     publishedAt: new Date(updatedTs).toISOString(),
@@ -139,9 +139,9 @@ export function updateIssuesCursor(current: Record<string, string>, issues: read
   for (const issue of issues) {
     if (issue.isPr && !params.includePrs) continue;
     if (!issue.updatedAt) continue;
-    const ts = Date.parse(issue.updatedAt);
-    if (!Number.isFinite(ts)) continue;
-    if (newest === null || ts > newest) newest = ts;
+    const updatedMs = Date.parse(issue.updatedAt);
+    if (!Number.isFinite(updatedMs)) continue;
+    if (newest === null || updatedMs > newest) newest = updatedMs;
   }
   if (newest === null) return current;
   const currentTs = current[ISSUES_CURSOR_KEY] ? Date.parse(current[ISSUES_CURSOR_KEY]) : -Infinity;

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

@@ -52,7 +52,7 @@ interface ParsedRelease {
 // hitting the network.
 export function parseGithubRelease(raw: unknown): ParsedRelease | null {
   if (!isRecord(raw)) return null;
-  const id = typeof raw.id === "number" && Number.isFinite(raw.id) ? raw.id : null;
+  const releaseId = typeof raw.id === "number" && Number.isFinite(raw.id) ? raw.id : null;
   const name = typeof raw.name === "string" ? raw.name : null;
   const tagName = typeof raw.tag_name === "string" ? raw.tag_name : null;
   const htmlUrl = typeof raw.html_url === "string" ? raw.html_url : null;
@@ -60,7 +60,7 @@ export function parseGithubRelease(raw: unknown): ParsedRelease | null {
   const publishedAt = typeof raw.published_at === "string" ? raw.published_at : null;
   const draft = raw.draft === true;
   const prerelease = raw.prerelease === true;
-  return { id, name, tagName, htmlUrl, body, publishedAt, draft, prerelease };
+  return { id: releaseId, name, tagName, htmlUrl, body, publishedAt, draft, prerelease };
 }
 
 // Build a SourceItem from a parsed release + the parent Source.
@@ -82,7 +82,7 @@ export function releaseToSourceItem(release: ParsedRelease, source: Source, last
 
   const normalizedUrl = normalizeUrl(release.htmlUrl);
   if (!normalizedUrl) return null;
-  const id = stableItemId(normalizedUrl);
+  const itemId = stableItemId(normalizedUrl);
 
   // Title resolution: prefer <name> (release display name), fall
   // back to <tag_name> (e.g. "v1.2.3"). Annotate pre-releases so
@@ -92,7 +92,7 @@ export function releaseToSourceItem(release: ParsedRelease, source: Source, last
   const summary = release.body ? firstParagraph(release.body) : null;
 
   return {
-    id,
+    id: itemId,
     title,
     url: normalizedUrl,
     publishedAt: new Date(publishedTs).toISOString(),
@@ -128,9 +128,9 @@ export function updateReleasesCursor(current: Record<string, string>, releases:
   for (const release of releases) {
     if (release.draft) continue;
     if (!release.publishedAt) continue;
-    const ts = Date.parse(release.publishedAt);
-    if (!Number.isFinite(ts)) continue;
-    if (newest === null || ts > newest) newest = ts;
+    const publishedMs = Date.parse(release.publishedAt);
+    if (!Number.isFinite(publishedMs)) continue;
+    if (newest === null || publishedMs > newest) newest = publishedMs;
   }
   if (newest === null) return current;
   const currentTs = current[RELEASES_CURSOR_KEY] ? Date.parse(current[RELEASES_CURSOR_KEY]) : -Infinity;

package/server/workspace/sources/interests.ts

@@ -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/pipeline/index.ts

@@ -92,11 +92,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 +125,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 ------------------------------------------------------

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.
@@ -60,7 +60,7 @@ export function planEligibleSources(input: PlanInput): 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;
+  const parsed = Date.parse(state.nextAttemptAt);
+  if (!Number.isFinite(parsed)) return false;
+  return parsed > nowMs;
 }

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,12 +47,14 @@ 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 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 consecutiveFailures =
-    typeof o.consecutiveFailures === "number" && Number.isFinite(o.consecutiveFailures) && o.consecutiveFailures >= 0 ? Math.floor(o.consecutiveFailures) : 0;
-  const cursor = validateCursor(o.cursor);
+    typeof record.consecutiveFailures === "number" && Number.isFinite(record.consecutiveFailures) && record.consecutiveFailures >= 0
+      ? Math.floor(record.consecutiveFailures)
+      : 0;
+  const cursor = validateCursor(record.cursor);
   return {
     slug,
     lastFetchedAt,
@@ -127,9 +129,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/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) {

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

@@ -21,29 +21,29 @@ const MAX_QUERY_SLUG_CHARS = 40;
 // from this module. The function is now in utils/date.ts.
 export { toUtcIsoDate as formatSearchDateDir } from "../../utils/date.js";
 
-export function computeSearchHash(query: string, sessionId: string, ts: Date): string {
-  return createHash("sha256").update(`${query}\n${sessionId}\n${ts.toISOString()}`, "utf-8").digest("base64url").slice(0, SEARCH_HASH_LEN);
+export function computeSearchHash(query: string, sessionId: string, timestamp: Date): string {
+  return createHash("sha256").update(`${query}\n${sessionId}\n${timestamp.toISOString()}`, "utf-8").digest("base64url").slice(0, SEARCH_HASH_LEN);
 }
 
 export interface SearchPathInputs {
   query: string;
   sessionId: string;
-  ts: Date;
+  timestamp: Date;
 }
 
 // Returns the workspace-relative path (POSIX slashes) where the search
 // file should live, e.g. "conversations/searches/2026-04-13/foo-abc12345.md".
 export function computeSearchRelPath(inputs: SearchPathInputs): string {
   const slug = slugify(inputs.query, "search", MAX_QUERY_SLUG_CHARS);
-  const hash = computeSearchHash(inputs.query, inputs.sessionId, inputs.ts);
-  const dateDir = toUtcIsoDate(inputs.ts);
+  const hash = computeSearchHash(inputs.query, inputs.sessionId, inputs.timestamp);
+  const dateDir = toUtcIsoDate(inputs.timestamp);
   return path.posix.join(SEARCHES_DIR, dateDir, `${slug}-${hash}.md`);
 }
 
 export interface SearchContentInputs {
   query: string;
   sessionId: string;
-  ts: Date;
+  timestamp: Date;
   resultBody: string;
 }
 
@@ -51,17 +51,27 @@ export interface SearchContentInputs {
 // machine-readable metadata, then a human-readable heading, then the
 // raw search result body verbatim.
 export function buildSearchMarkdown(inputs: SearchContentInputs): string {
-  const { query, sessionId, ts, resultBody } = inputs;
+  const { query, sessionId, timestamp, resultBody } = inputs;
   const body = resultBody.endsWith("\n") ? resultBody : `${resultBody}\n`;
-  return ["---", `query: ${jsonStringSafe(query)}`, `sessionId: ${sessionId}`, `ts: ${ts.toISOString()}`, "---", "", `# Search: ${query}`, "", body].join("\n");
+  return [
+    "---",
+    `query: ${jsonStringSafe(query)}`,
+    `sessionId: ${sessionId}`,
+    `ts: ${timestamp.toISOString()}`,
+    "---",
+    "",
+    `# Search: ${query}`,
+    "",
+    body,
+  ].join("\n");
 }
 
 // Quote a string for YAML only when it could otherwise be
 // misinterpreted (contains a colon, hash, or leading/trailing space).
 // Cheap and good enough for a machine-authored frontmatter.
-function jsonStringSafe(s: string): string {
-  const needsQuote = /[:#\n]/.test(s) || s !== s.trim();
-  return needsQuote ? JSON.stringify(s) : s;
+function jsonStringSafe(input: string): string {
+  const needsQuote = /[:#\n]/.test(input) || input !== input.trim();
+  return needsQuote ? JSON.stringify(input) : input;
 }
 
 export interface WriteSearchInputs extends SearchContentInputs {
@@ -77,7 +87,7 @@ const defaultDeps: WriteSearchDeps = {
   mkdir: async (dir) => {
     await fsp.mkdir(dir, { recursive: true });
   },
-  writeFile: (p, content) => fsp.writeFile(p, content, "utf-8"),
+  writeFile: (filePath, content) => fsp.writeFile(filePath, content, "utf-8"),
 };
 
 /**
@@ -85,14 +95,14 @@ const defaultDeps: WriteSearchDeps = {
  * path that should be used as the jsonl `contentRef`.
  */
 export async function writeSearchResult(inputs: WriteSearchInputs, deps: Partial<WriteSearchDeps> = {}): Promise<string> {
-  const d: WriteSearchDeps = { ...defaultDeps, ...deps };
   const relPath = computeSearchRelPath({
     query: inputs.query,
     sessionId: inputs.sessionId,
-    ts: inputs.ts,
+    timestamp: inputs.timestamp,
   });
   const absPath = path.join(inputs.workspaceRoot, relPath);
-  await d.mkdir(path.dirname(absPath));
-  await d.writeFile(absPath, buildSearchMarkdown(inputs));
+  const activeDeps: WriteSearchDeps = { ...defaultDeps, ...deps };
+  await activeDeps.mkdir(path.dirname(absPath));
+  await activeDeps.writeFile(absPath, buildSearchMarkdown(inputs));
   return relPath;
 }

package/server/workspace/wiki-backlinks/index.ts

@@ -30,16 +30,16 @@ const MTIME_TOLERANCE_MS = ONE_SECOND_MS;
 
 export interface WikiBacklinksDeps {
   readdir: (dir: string) => Promise<string[]>;
-  stat: (p: string) => Promise<{ mtimeMs: number }>;
-  readFile: (p: string) => Promise<string>;
-  writeFile: (p: string, content: string) => Promise<void>;
+  stat: (filePath: string) => Promise<{ mtimeMs: number }>;
+  readFile: (filePath: string) => Promise<string>;
+  writeFile: (filePath: string, content: string) => Promise<void>;
 }
 
 const defaultDeps: WikiBacklinksDeps = {
   readdir: (dir) => fsp.readdir(dir),
-  stat: (p) => fsp.stat(p),
-  readFile: (p) => fsp.readFile(p, "utf-8"),
-  writeFile: (p, content) => fsp.writeFile(p, content, "utf-8"),
+  stat: (filePath) => fsp.stat(filePath),
+  readFile: (filePath) => fsp.readFile(filePath, "utf-8"),
+  writeFile: (filePath, content) => fsp.writeFile(filePath, content, "utf-8"),
 };
 
 export interface MaybeAppendWikiBacklinksOptions {
@@ -78,8 +78,8 @@ async function listPageFiles(pagesDir: string, deps: WikiBacklinksDeps): Promise
 async function processOneFile(pagesDir: string, fileName: string, sessionId: string, mtimeThreshold: number, deps: WikiBacklinksDeps): Promise<void> {
   const fullPath = path.join(pagesDir, fileName);
   try {
-    const st = await deps.stat(fullPath);
-    if (st.mtimeMs < mtimeThreshold) return;
+    const stats = await deps.stat(fullPath);
+    if (stats.mtimeMs < mtimeThreshold) return;
 
     const content = await deps.readFile(fullPath);
     // Compute the relative path from the wiki page's directory to