mulmoclaude 0.1.0

package/server/workspace/sources/paths.ts

@@ -0,0 +1,110 @@
+// Path helpers for the source registry's on-disk layout.
+//
+//   workspace/
+//     sources/
+//       <slug>.md                    ← source config
+//       _index.md                    ← auto-generated category index
+//       _state/
+//         <slug>.json                ← runtime state per source
+//         robots/<host>.txt          ← cached robots.txt
+//     news/
+//       daily/YYYY/MM/DD.md          ← daily aggregated summary
+//       archive/<slug>/YYYY-MM.md    ← per-source rolling archive
+//
+// Everything is derived from a single `workspaceRoot` argument so
+// tests can target a `mkdtempSync` directory.
+
+import path from "node:path";
+import { isValidSlug } from "../../utils/slug.js";
+
+export const SOURCES_DIR = "sources";
+export const SOURCE_STATE_DIR = "_state";
+export const ROBOTS_CACHE_DIR = "robots";
+export const NEWS_DIR = "news";
+export const DAILY_DIR = "daily";
+export const ARCHIVE_DIR = "archive";
+
+export function sourcesRoot(workspaceRoot: string): string {
+  return path.join(workspaceRoot, SOURCES_DIR);
+}
+
+// Enforced by every slug-accepting path builder so a caller can't
+// accidentally pass `../other-source` (which path.join would
+// happily resolve outside workspaceRoot).
+function assertValidSlug(slug: string): void {
+  if (!isValidSlug(slug)) {
+    throw new Error(`[sources] invalid slug: "${slug}"`);
+  }
+}
+
+export function sourceFilePath(workspaceRoot: string, slug: string): string {
+  assertValidSlug(slug);
+  return path.join(sourcesRoot(workspaceRoot), `${slug}.md`);
+}
+
+export function sourceStateDir(workspaceRoot: string): string {
+  return path.join(sourcesRoot(workspaceRoot), SOURCE_STATE_DIR);
+}
+
+export function sourceStatePath(workspaceRoot: string, slug: string): string {
+  assertValidSlug(slug);
+  return path.join(sourceStateDir(workspaceRoot), `${slug}.json`);
+}
+
+export function robotsCacheDir(workspaceRoot: string): string {
+  return path.join(sourceStateDir(workspaceRoot), ROBOTS_CACHE_DIR);
+}
+
+export function robotsCachePath(workspaceRoot: string, host: string): string {
+  // Hosts can contain `:` (for explicit ports) which breaks on some
+  // filesystems. Colons → underscore. Other characters are ASCII
+  // letters, digits, dots, and hyphens per DNS rules so they're
+  // safe as-is.
+  const safe = host.replace(/:/g, "_");
+  return path.join(robotsCacheDir(workspaceRoot), `${safe}.txt`);
+}
+
+export function newsRoot(workspaceRoot: string): string {
+  return path.join(workspaceRoot, NEWS_DIR);
+}
+
+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) {
+    throw new Error(`[sources] dailyNewsPath: expected YYYY-MM-DD, got "${isoDate}"`);
+  }
+  const [, year, month, day] = m;
+  return path.join(newsRoot(workspaceRoot), DAILY_DIR, year, month, `${day}.md`);
+}
+
+export function archiveDir(workspaceRoot: string, slug: string): string {
+  assertValidSlug(slug);
+  return path.join(newsRoot(workspaceRoot), ARCHIVE_DIR, slug);
+}
+
+// Archive file path. Written as `<slug>/YYYY/MM.md` (year and
+// month as nested directories) so long-running workspaces don't
+// end up with 60+ files in a single source's archive dir —
+// browsing a given year is one `cd YYYY/` away. Matches the
+// daily-news layout (`daily/YYYY/MM/DD.md`).
+//
+// Input stays `YYYY-MM` so callers don't need to remember whether
+// 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) {
+    throw new Error(`[sources] archivePath: expected YYYY-MM, got "${yearMonth}"`);
+  }
+  const [, year, month] = m;
+  return path.join(archiveDir(workspaceRoot, slug), year, `${month}.md`);
+}
+
+// Very conservative slug validator. The slug doubles as a filename
+// and appears in URLs (via the manageSource plugin), so reject
+// anything that could surprise the filesystem or the URL parser.
+// Letters, digits, hyphens only. 1-64 chars. No leading / trailing
+// hyphen. No consecutive hyphens.
+// isValidSlug moved to server/utils/slug.ts — import from there.

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

@@ -0,0 +1,60 @@
+// Cross-source dedup — pure.
+//
+// Per #188 Q3: per-source archives keep every item, but the daily
+// summary step dedupes across sources so a single article that
+// lands in three RSS feeds only appears once in the summary.
+//
+// Dedup key: `stableItemId` (SHA-256 prefix of the normalized URL,
+// see server/sources/urls.ts — the item shape already carries this
+// as `item.id`). Items retain the first-seen occurrence and drop
+// subsequent ones. Order is preserved so the caller's sort (e.g.
+// newest-first across all sources) survives dedup.
+
+import type { SourceItem } from "../types.js";
+
+export interface DedupStats {
+  uniqueCount: number;
+  duplicateCount: number;
+  // The winning sourceSlug per duplicate id — useful for the
+  // daily summary footer ("N duplicates across sources A, B"
+  // without naming item titles).
+  duplicateSlugsById: Map<string, string[]>;
+}
+
+export interface DedupResult {
+  items: SourceItem[];
+  stats: DedupStats;
+}
+
+// Dedup an item list by `id` (stableItemId from urls.ts). Keeps
+// the first occurrence; stats record which OTHER source slugs
+// had duplicates of each kept item so the summary footer can
+// credit them if needed.
+export function dedupAcrossSources(items: readonly SourceItem[]): DedupResult {
+  const seen = new Set<string>();
+  const kept: SourceItem[] = [];
+  const duplicateSlugsById = new Map<string, string[]>();
+  let duplicateCount = 0;
+  for (const item of items) {
+    if (!seen.has(item.id)) {
+      seen.add(item.id);
+      kept.push(item);
+      continue;
+    }
+    duplicateCount++;
+    const dupSlugs = duplicateSlugsById.get(item.id) ?? [];
+    // Keep the slug list unique: a single source that emits the
+    // same item twice (e.g. feed pagination overlap) shouldn't
+    // inflate the "across sources" footer stat.
+    if (!dupSlugs.includes(item.sourceSlug)) dupSlugs.push(item.sourceSlug);
+    duplicateSlugsById.set(item.id, dupSlugs);
+  }
+  return {
+    items: kept,
+    stats: {
+      uniqueCount: kept.length,
+      duplicateCount,
+      duplicateSlugsById,
+    },
+  };
+}

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

@@ -0,0 +1,136 @@
+// Fetch-phase orchestrator.
+//
+// Given a planned list of eligible sources, runs each through
+// its registered fetcher concurrently (Q7: parallel across
+// hosts; same-host serialization happens inside HostRateLimiter
+// at the HTTP layer). Failures are isolated per-source (Q8) —
+// one bad fetch never aborts the pass.
+//
+// Each source produces a `FetchOutcome` summarizing success or
+// failure. The next-state computation (backoff, failure counter,
+// cursor persistence) is factored into `computeNextState` so the
+// state-update policy is unit-testable without touching HTTP.
+
+import type { FetcherDeps, FetchResult, SourceFetcher } from "../fetchers/index.js";
+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";
+
+// Outcome of one source's fetch attempt.
+export type FetchOutcome =
+  | {
+      kind: "success";
+      sourceSlug: string;
+      items: FetchResult["items"];
+      cursor: FetchResult["cursor"];
+    }
+  | { kind: "no-fetcher"; sourceSlug: string; error: string }
+  | { kind: "error"; sourceSlug: string; error: string };
+
+export interface FetchPhaseInput {
+  sources: readonly Source[];
+  statesBySlug: ReadonlyMap<string, SourceState>;
+  deps: FetcherDeps;
+  // Injected so tests don't depend on the module-level registry.
+  // Production passes `getFetcher` from fetchers/index.
+  getFetcher: (kind: FetcherKind) => SourceFetcher | null;
+}
+
+export interface FetchPhaseResult {
+  // In the original order of `input.sources` for caller
+  // ergonomics; the per-outcome `sourceSlug` is the authoritative
+  // key.
+  outcomes: FetchOutcome[];
+}
+
+// Run the fetch phase. All fetchers run in parallel
+// (Promise.all) — same-host serialization is enforced deeper,
+// inside `HostRateLimiter` via the fetchers' `fetchPolite`
+// calls. A single-source error never throws out of here;
+// failures are captured in `FetchOutcome.kind === "error"`.
+export async function runFetchPhase(input: FetchPhaseInput): Promise<FetchPhaseResult> {
+  const outcomes = await Promise.all(
+    input.sources.map((source) => fetchOneSource(source, input.statesBySlug.get(source.slug) ?? defaultSourceState(source.slug), input.deps, input.getFetcher)),
+  );
+  return { outcomes };
+}
+
+async function fetchOneSource(
+  source: Source,
+  state: SourceState,
+  deps: FetcherDeps,
+  getFetcher: (kind: FetcherKind) => SourceFetcher | null,
+): Promise<FetchOutcome> {
+  const fetcher = getFetcher(source.fetcherKind);
+  if (!fetcher) {
+    return {
+      kind: "no-fetcher",
+      sourceSlug: source.slug,
+      error: `no fetcher registered for kind "${source.fetcherKind}"`,
+    };
+  }
+  try {
+    const result = await fetcher.fetch(source, state, deps);
+    return {
+      kind: "success",
+      sourceSlug: source.slug,
+      items: result.items,
+      cursor: result.cursor,
+    };
+  } catch (err) {
+    return {
+      kind: "error",
+      sourceSlug: source.slug,
+      error: errorMessage(err),
+    };
+  }
+}
+
+// --- per-source state update --------------------------------------------
+
+// Exponential backoff (in ms) for the Nth consecutive failure.
+// Bounded at BACKOFF_MAX so even a permanently-broken source
+// gets retried eventually.
+export const BACKOFF_MAX_MS = ONE_DAY_MS;
+
+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);
+}
+
+// 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 any non-success:
+//   - lastFetchedAt unchanged (we didn't successfully fetch)
+//   - cursor unchanged
+//   - consecutiveFailures += 1
+//   - nextAttemptAt = now + backoffDelayMs(newCount)
+export function computeNextState(prev: SourceState, outcome: FetchOutcome, nowMs: number): SourceState {
+  if (outcome.kind === "success") {
+    return {
+      slug: prev.slug,
+      lastFetchedAt: new Date(nowMs).toISOString(),
+      cursor: outcome.cursor,
+      consecutiveFailures: 0,
+      nextAttemptAt: null,
+    };
+  }
+  const failures = prev.consecutiveFailures + 1;
+  return {
+    slug: prev.slug,
+    lastFetchedAt: prev.lastFetchedAt,
+    cursor: prev.cursor,
+    consecutiveFailures: failures,
+    nextAttemptAt: new Date(nowMs + backoffDelayMs(failures)).toISOString(),
+  };
+}

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

@@ -0,0 +1,249 @@
+// Top-level pipeline entry point.
+//
+// `runSourcesPipeline({ workspaceRoot, scheduleType, ... })`
+// threads every phase in order:
+//
+//   1. Load sources from the registry
+//   2. Read per-source state from `_state/<slug>.json`
+//   3. Plan: filter by schedule + backoff
+//   4. Fetch: per-source, parallel, failure-isolated
+//   5. Dedup across sources (first occurrence wins)
+//   6. Summarize via claude CLI (skipped for 0 items)
+//   7. Write daily markdown + JSON block
+//   8. Append every item to its per-source monthly archive
+//   9. Persist updated per-source state back to disk
+//
+// Design follows #188 decisions: per-source try/catch (Q8),
+// cross-source dedup only at summary step (Q3), local timezone
+// (Q6), parallel across hosts (Q7 — enforced deeper by
+// HostRateLimiter inside fetchPolite).
+//
+// Fully DI-threaded: `getFetcher`, `summarizeFn`, `now` are all
+// parameters, and workspaceRoot is explicit. Tests can drive
+// the whole pipeline end-to-end against a mkdtempSync workspace
+// with stub fetchers and a fake summarize.
+
+// Side-effect import: registers every production fetcher so
+// `registryGetFetcher(kind)` below resolves. Without this the
+// pipeline would run, report `no-fetcher` for every source, and
+// write an empty daily file.
+import "../fetchers/registerAll.js";
+
+import { existsSync } from "fs";
+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 type { FetcherKind, Source, SourceItem, SourceState, SourceSchedule } from "../types.js";
+import { planEligibleSources } from "./plan.js";
+import { runFetchPhase, computeNextState, type FetchOutcome } from "./fetch.js";
+import { dedupAcrossSources, type DedupStats } from "./dedup.js";
+import { makeDefaultSummarize, type SummarizeFn } from "./summarize.js";
+import { writeDailyFile, appendItemsToArchives } from "./write.js";
+import { runNotifyPhase } from "./notify.js";
+import { discoverAndRegister } from "../arxivDiscovery.js";
+import { log } from "../../../system/logger/index.js";
+import { toLocalIsoDate } from "../../../utils/date.js";
+
+export interface RunPipelineInput {
+  workspaceRoot: string;
+  scheduleType: SourceSchedule;
+  // Shared across all fetchers in the run (rate limiter, robots
+  // provider, fetch impl, timeout — assembled by the caller).
+  fetcherDeps: FetcherDeps;
+  // Pipeline-run clock. Production passes `() => Date.now()`.
+  // Tests pass a fixed millis so isoDate / backoff math is
+  // deterministic.
+  nowMs: () => number;
+  // Injection hooks.
+  getFetcher?: (kind: FetcherKind) => SourceFetcher | null;
+  summarizeFn?: SummarizeFn;
+  // For test instrumentation; ignored in production.
+  onProgress?: (phase: string) => void;
+}
+
+export interface RunPipelineResult {
+  // Sources considered in this run.
+  plannedCount: number;
+  // Raw fetch outcomes (success / error / no-fetcher). In
+  // original plan order.
+  outcomes: FetchOutcome[];
+  // Items emitted after cross-source dedup, ready for
+  // summarization + archive append.
+  items: SourceItem[];
+  dedup: DedupStats;
+  // Absolute path of the daily markdown file written.
+  dailyPath: string;
+  archiveWrittenPaths: string[];
+  // Non-fatal errors from the archive append step.
+  archiveErrors: string[];
+  // Per-source post-run states, already persisted to disk.
+  nextStates: SourceState[];
+  // Local ISO date used for the daily header / filename.
+  isoDate: string;
+}
+
+// Convert a wall-clock millis value to YYYY-MM-DD in LOCAL
+// time, matching the #188 Q6 decision ("Local time, like the
+// journal"). The journal's `toIsoDate` in paths.ts uses the
+// Re-export for callers that imported from this module.
+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 async function runSourcesPipeline(input: RunPipelineInput): Promise<RunPipelineResult> {
+  const { workspaceRoot, scheduleType, fetcherDeps, nowMs, getFetcher = registryGetFetcher, onProgress = () => {} } = input;
+
+  const startMs = nowMs();
+  const isoDate = toLocalIsoDate(startMs);
+  const fallbackMonth = toLocalYearMonth(startMs);
+  const summarizeFn = input.summarizeFn ?? makeDefaultSummarize(isoDate);
+
+  // --- 0. Auto-discover arXiv sources from interests ------------------
+  // Best-effort: a bad interests.json or FS error must not abort the
+  // entire pipeline. The daily news fetch is more important than
+  // auto-registering arXiv sources.
+  onProgress("discover");
+  try {
+    await discoverAndRegister(workspaceRoot);
+  } catch (err) {
+    log.warn("pipeline", "arXiv auto-discovery failed (non-fatal)", {
+      error: String(err),
+    });
+  }
+
+  // --- 1. Load registry + state --------------------------------------
+  onProgress("load");
+  const allSources = await listSources(workspaceRoot);
+  const statesBySlug = await readManyStates(
+    workspaceRoot,
+    allSources.map((s) => s.slug),
+  );
+
+  // --- 2. Plan ------------------------------------------------------
+  onProgress("plan");
+  const eligible = planEligibleSources({
+    sources: allSources,
+    statesBySlug,
+    scheduleType,
+    nowMs: startMs,
+  });
+  if (eligible.length === 0) {
+    // Write an empty-day daily file so it's clear the pipeline
+    // ran. Archive append is a no-op. State untouched.
+    //
+    // But: if a previous pass today already produced a non-empty
+    // brief, don't clobber it. A same-day rerun with nothing due
+    // (all sources still in backoff / on "weekly" schedule) would
+    // otherwise wipe the morning's brief when re-triggered in the
+    // afternoon.
+    onProgress("write-empty");
+    const existingPath = dailyNewsPath(workspaceRoot, isoDate);
+    const dailyPath = existsSync(existingPath) ? existingPath : await writeDailyFile(workspaceRoot, isoDate, await summarizeFn([]), []);
+    return {
+      plannedCount: 0,
+      outcomes: [],
+      items: [],
+      dedup: {
+        uniqueCount: 0,
+        duplicateCount: 0,
+        duplicateSlugsById: new Map(),
+      },
+      dailyPath,
+      archiveWrittenPaths: [],
+      archiveErrors: [],
+      nextStates: [],
+      isoDate,
+    };
+  }
+
+  // --- 3. Fetch -----------------------------------------------------
+  onProgress("fetch");
+  const { outcomes } = await runFetchPhase({
+    sources: eligible,
+    statesBySlug,
+    deps: fetcherDeps,
+    getFetcher,
+  });
+
+  // --- 4. Dedup -----------------------------------------------------
+  onProgress("dedup");
+  const rawItems = flattenItems(outcomes);
+  const dedup = dedupAcrossSources(rawItems);
+
+  // --- 5. Notify (user interest matching) ----------------------------
+  onProgress("notify");
+  runNotifyPhase(dedup.items, workspaceRoot);
+
+  // --- 6. Summarize + write ----------------------------------------
+  onProgress("summarize");
+  const markdown = await summarizeFn(dedup.items);
+
+  onProgress("write"); // step 7
+  const dailyPath = await writeDailyFile(workspaceRoot, isoDate, markdown, dedup.items);
+  const archiveResult = await appendItemsToArchives(workspaceRoot, dedup.items, fallbackMonth);
+
+  // --- 8. Persist state ---------------------------------------------
+  onProgress("persist");
+  const nextStates = buildNextStates(eligible, statesBySlug, outcomes, nowMs());
+  await writeManyStates(workspaceRoot, nextStates);
+
+  onProgress("done");
+  return {
+    plannedCount: eligible.length,
+    outcomes,
+    items: dedup.items,
+    dedup: dedup.stats,
+    dailyPath,
+    archiveWrittenPaths: archiveResult.writtenPaths,
+    archiveErrors: archiveResult.errors,
+    nextStates,
+    isoDate,
+  };
+}
+
+// Flatten successful-outcome items into a single list for
+// dedup. Keeps the original source ordering (planned sort
+// order) so dedup preserves deterministic precedence.
+function flattenItems(outcomes: readonly FetchOutcome[]): SourceItem[] {
+  const out: SourceItem[] = [];
+  for (const outcome of outcomes) {
+    if (outcome.kind !== "success") continue;
+    for (const item of outcome.items) out.push(item);
+  }
+  return out;
+}
+
+function buildNextStates(
+  eligible: readonly Source[],
+  statesBySlug: ReadonlyMap<string, SourceState>,
+  outcomes: readonly FetchOutcome[],
+  nowMs: number,
+): SourceState[] {
+  const outcomeBySlug = new Map<string, FetchOutcome>();
+  for (const outcome of outcomes) {
+    outcomeBySlug.set(outcome.sourceSlug, outcome);
+  }
+  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 outcome = outcomeBySlug.get(source.slug);
+    if (!outcome) continue; // unreachable in practice; defensive
+    nextStates.push(computeNextState(prev, outcome, nowMs));
+  }
+  return nextStates;
+}

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

@@ -0,0 +1,72 @@
+// Notify phase — score items by user interests and publish
+// notifications for interesting findings (#466).
+//
+// Inserted between dedup and summarize in the pipeline.
+// Skipped entirely when config/interests.json doesn't exist.
+
+import { publishNotification } from "../../../events/notifications.js";
+import { NOTIFICATION_KINDS, NOTIFICATION_PRIORITIES, NOTIFICATION_ACTION_TYPES, NOTIFICATION_VIEWS } from "../../../../src/types/notification.js";
+import { loadInterests, scoreAndFilter, type ScoredItem } from "../interests.js";
+import type { SourceItem } from "../types.js";
+
+export interface NotifyPhaseResult {
+  notified: ScoredItem[];
+  skippedReason: string | null;
+}
+
+export function runNotifyPhase(items: readonly SourceItem[], workspaceRoot?: string): NotifyPhaseResult {
+  const profile = loadInterests(workspaceRoot);
+  if (!profile) {
+    return { notified: [], skippedReason: "no interests profile" };
+  }
+
+  const interesting = scoreAndFilter(items, profile);
+  if (interesting.length === 0) {
+    return { notified: [], skippedReason: "no items above threshold" };
+  }
+
+  publishBatchNotification(interesting);
+  return { notified: interesting, skippedReason: null };
+}
+
+function formatSingleBody(item: SourceItem): string {
+  const suffix = item.summary ? " \u2014 " + item.summary : "";
+  return "From " + item.sourceSlug + suffix;
+}
+
+function publishBatchNotification(scored: readonly ScoredItem[]): void {
+  if (scored.length === 1) {
+    const { item } = scored[0];
+    publishNotification({
+      kind: NOTIFICATION_KINDS.push,
+      title: item.title,
+      body: formatSingleBody(item),
+      priority: item.severity === "critical" ? NOTIFICATION_PRIORITIES.high : NOTIFICATION_PRIORITIES.normal,
+      action: {
+        type: NOTIFICATION_ACTION_TYPES.navigate,
+        view: NOTIFICATION_VIEWS.files,
+      },
+    });
+    return;
+  }
+
+  const bullets = scored
+    .slice(0, 5)
+    .map((s) => `\u2022 ${s.item.title} (${s.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");
+
+  publishNotification({
+    kind: NOTIFICATION_KINDS.push,
+    title: `${scored.length} interesting articles found`,
+    body: `${bullets}${extra}`,
+    priority: hasCritical ? NOTIFICATION_PRIORITIES.high : NOTIFICATION_PRIORITIES.normal,
+    action: {
+      type: NOTIFICATION_ACTION_TYPES.navigate,
+      view: NOTIFICATION_VIEWS.files,
+    },
+  });
+}