mulmoclaude 0.3.0 → 0.4.0

package/server/utils/request.ts

@@ -3,11 +3,17 @@
 // Centralizes patterns that were duplicated across route handlers
 // (3+ different ways to read `req.query.session`).
 
-// Use a minimal interface so the helpers work with any Express
-// Request generic (Request<object, ...>, Request<Params, ...>, etc.)
-// without type incompatibility.
+// `query: object` so the helpers work with any Express Request
+// generic — `Request<Params, ResBody, ReqBody, Query>`. A narrow
+// `Query` generic like `{ path?: string }` isn't assignable to
+// `Record<string, unknown>` (no index signature), so we widen to
+// `object` and cast internally when reading a key.
 interface HasQuery {
-  query: Record<string, unknown>;
+  query: object;
+}
+
+function readQueryKey(queryObj: object, key: string): unknown {
+  return (queryObj as Record<string, unknown>)[key];
 }
 
 /**
@@ -15,7 +21,7 @@ interface HasQuery {
  * Returns the string value, or "" if missing/non-string.
  */
 export function getSessionQuery(req: HasQuery): string {
-  const raw = req.query.session;
+  const raw = readQueryKey(req.query, "session");
   return typeof raw === "string" ? raw : "";
 }
 
@@ -24,6 +30,6 @@ export function getSessionQuery(req: HasQuery): string {
  * Returns the string value, or undefined if missing/non-string.
  */
 export function getOptionalStringQuery(req: HasQuery, key: string): string | undefined {
-  const raw = req.query[key];
+  const raw = readQueryKey(req.query, key);
   return typeof raw === "string" ? raw : undefined;
 }

package/server/utils/spawn.ts

@@ -28,7 +28,7 @@ export function extractClaudeErrorMessage(stdout: string): string | null {
   if (!isRecord(parsed)) return null;
   if (parsed.is_error !== true) return null;
   if (Array.isArray(parsed.errors) && parsed.errors.length > 0) {
-    const joined = parsed.errors.filter((e): e is string => typeof e === "string").join("; ");
+    const joined = parsed.errors.filter((err): err is string => typeof err === "string").join("; ");
     if (joined.length > 0) return joined;
   }
   const subtype = typeof parsed.subtype === "string" ? parsed.subtype : "";

package/server/utils/types.ts

@@ -23,12 +23,12 @@ export function isNonEmptyString(value: unknown): value is string {
 /** Record whose values are all strings. */
 export function isStringRecord(value: unknown): value is Record<string, string> {
   if (!isRecord(value)) return false;
-  return Object.values(value).every((v) => typeof v === "string");
+  return Object.values(value).every((val) => typeof val === "string");
 }
 
 /** String array (every element is a string). */
 export function isStringArray(value: unknown): value is string[] {
-  return Array.isArray(value) && value.every((v) => typeof v === "string");
+  return Array.isArray(value) && value.every((val) => typeof val === "string");
 }
 
 /** Error-like object with a `code` property (e.g. Node.js fs errors). */

package/server/workspace/chat-index/summarizer.ts

@@ -152,10 +152,10 @@ export function validateSummaryResult(obj: unknown): SummaryResult {
   if (!isRecord(obj)) {
     throw new Error("[chat-index] summary result is not an object");
   }
-  const o = obj as Record<string, unknown>;
-  const title = typeof o.title === "string" ? o.title : "";
-  const summary = typeof o.summary === "string" ? o.summary : "";
-  const keywords = Array.isArray(o.keywords) ? o.keywords.filter((k): k is string => typeof k === "string") : [];
+  const record = obj as Record<string, unknown>;
+  const title = typeof record.title === "string" ? record.title : "";
+  const summary = typeof record.summary === "string" ? record.summary : "";
+  const keywords = Array.isArray(record.keywords) ? record.keywords.filter((keyword): keyword is string => typeof keyword === "string") : [];
   return { title, summary, keywords };
 }
 

package/server/workspace/custom-dirs.ts

@@ -4,7 +4,7 @@
 // directories under `data/` and `artifacts/` for organizing files.
 // Claude sees these in the system prompt and routes saves accordingly.
 
-import fs from "fs";
+import { existsSync, mkdirSync, readFileSync } from "fs";
 import path from "path";
 import { workspacePath, WORKSPACE_DIRS } from "./paths.js";
 import { log } from "../system/logger/index.js";
@@ -102,8 +102,8 @@ export function loadCustomDirs(root?: string): CustomDirEntry[] {
   const base = root ?? workspacePath;
   const filePath = path.join(base, CONFIG_FILE);
   try {
-    if (!fs.existsSync(filePath)) return [];
-    const raw = fs.readFileSync(filePath, "utf-8");
+    if (!existsSync(filePath)) return [];
+    const raw = readFileSync(filePath, "utf-8");
     const parsed: unknown = JSON.parse(raw);
     if (!Array.isArray(parsed)) {
       log.warn("custom-dirs", "workspace-dirs.json is not an array");
@@ -132,7 +132,7 @@ export function loadCustomDirs(root?: string): CustomDirEntry[] {
 export function saveCustomDirs(entries: readonly CustomDirEntry[], root?: string): void {
   const base = root ?? workspacePath;
   const filePath = path.join(base, CONFIG_FILE);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  mkdirSync(path.dirname(filePath), { recursive: true });
   writeFileAtomicSync(filePath, JSON.stringify(entries, null, 2));
   invalidateCache();
 }
@@ -186,7 +186,7 @@ export function ensureCustomDirs(entries: readonly CustomDirEntry[], root?: stri
   const base = root ?? workspacePath;
   for (const entry of entries) {
     const dirPath = path.join(base, entry.path);
-    fs.mkdirSync(dirPath, { recursive: true });
+    mkdirSync(dirPath, { recursive: true });
   }
 }
 

package/server/workspace/journal/diff.ts

@@ -52,8 +52,8 @@ export function findDirtySessions(current: readonly SessionFileMeta[], processed
   }
 
   const missing: string[] = [];
-  for (const id of Object.keys(processed)) {
-    if (!seenNow.has(id)) missing.push(id);
+  for (const sessionId of Object.keys(processed)) {
+    if (!seenNow.has(sessionId)) missing.push(sessionId);
   }
 
   return { dirty, missing };

package/server/workspace/journal/index.ts

@@ -150,17 +150,17 @@ async function runJournalPass(opts: MaybeRunJournalOptions): Promise<void> {
 async function rebuildIndex(workspaceRoot: string): Promise<void> {
   const topics = await walkTopics(workspaceRoot);
   const dailyEntries = await listDailyFilesIO(workspaceRoot);
-  const days: IndexDailyEntry[] = dailyEntries.map((e) => ({
-    date: `${e.year}-${e.month}-${e.day}`,
+  const days: IndexDailyEntry[] = dailyEntries.map((entry) => ({
+    date: `${entry.year}-${entry.month}-${entry.day}`,
   }));
   const archivedCount = await countArchivedIO(workspaceRoot);
-  const md = buildIndexMarkdown({
+  const markdown = buildIndexMarkdown({
     topics,
     days,
     archivedTopicCount: archivedCount,
     builtAtIso: new Date().toISOString(),
   });
-  await writeJournalIndex(md, workspaceRoot);
+  await writeJournalIndex(markdown, workspaceRoot);
 }
 
 async function walkTopics(workspaceRoot: string): Promise<IndexTopicEntry[]> {

package/server/workspace/journal/optimizationPass.ts

@@ -54,7 +54,7 @@ export function planMerges(merges: readonly RawMerge[]): MergePlanItem[] {
   const plans: MergePlanItem[] = [];
   for (const merge of merges) {
     const intoSlug = slugify(merge.into);
-    const fromSlugs = merge.from.map(slugify).filter((s) => s !== intoSlug);
+    const fromSlugs = merge.from.map(slugify).filter((slug) => slug !== intoSlug);
     if (fromSlugs.length === 0) continue;
     plans.push({ intoSlug, fromSlugs, newContent: merge.newContent });
   }
@@ -66,7 +66,7 @@ export function planMerges(merges: readonly RawMerge[]): MergePlanItem[] {
 export function applyRemovedTopics(state: JournalState, removed: ReadonlySet<string>): JournalState {
   return {
     ...state,
-    knownTopics: state.knownTopics.filter((t) => !removed.has(t)),
+    knownTopics: state.knownTopics.filter((topic) => !removed.has(topic)),
   };
 }
 

package/server/workspace/journal/state.ts

@@ -65,27 +65,27 @@ export function parseState(raw: unknown): JournalState {
   // Version mismatch → throw it all out. Cheap to rebuild.
   if (obj.version !== JOURNAL_STATE_VERSION) return defaultState();
 
-  const d = defaultState();
+  const fallback = defaultState();
   return {
     version: JOURNAL_STATE_VERSION,
     lastDailyRunAt: typeof obj.lastDailyRunAt === "string" ? obj.lastDailyRunAt : null,
     lastOptimizationRunAt: typeof obj.lastOptimizationRunAt === "string" ? obj.lastOptimizationRunAt : null,
-    dailyIntervalHours: typeof obj.dailyIntervalHours === "number" && obj.dailyIntervalHours > 0 ? obj.dailyIntervalHours : d.dailyIntervalHours,
+    dailyIntervalHours: typeof obj.dailyIntervalHours === "number" && obj.dailyIntervalHours > 0 ? obj.dailyIntervalHours : fallback.dailyIntervalHours,
     optimizationIntervalDays:
-      typeof obj.optimizationIntervalDays === "number" && obj.optimizationIntervalDays > 0 ? obj.optimizationIntervalDays : d.optimizationIntervalDays,
+      typeof obj.optimizationIntervalDays === "number" && obj.optimizationIntervalDays > 0 ? obj.optimizationIntervalDays : fallback.optimizationIntervalDays,
     processedSessions: parseProcessedSessions(obj.processedSessions),
-    knownTopics: Array.isArray(obj.knownTopics) ? obj.knownTopics.filter((t): t is string => typeof t === "string") : [],
+    knownTopics: Array.isArray(obj.knownTopics) ? obj.knownTopics.filter((topic): topic is string => typeof topic === "string") : [],
   };
 }
 
 function parseProcessedSessions(raw: unknown): Record<string, ProcessedSessionRecord> {
   if (!isRecord(raw)) return {};
   const out: Record<string, ProcessedSessionRecord> = {};
-  for (const [id, rec] of Object.entries(raw as Record<string, unknown>)) {
+  for (const [sessionId, rec] of Object.entries(raw as Record<string, unknown>)) {
     if (!isRecord(rec)) continue;
     const mtime = (rec as Record<string, unknown>).lastMtimeMs;
     if (typeof mtime === "number" && mtime >= 0) {
-      out[id] = { lastMtimeMs: mtime };
+      out[sessionId] = { lastMtimeMs: mtime };
     }
   }
   return out;

package/server/workspace/paths.ts

@@ -21,7 +21,7 @@
 // `WORKSPACE_DIRS` record below. The absolute path is derived
 // automatically via `WORKSPACE_PATHS`.
 
-import os from "os";
+import { homedir } from "os";
 import path from "path";
 
 // Workspace root. Hard-coded to `~/mulmoclaude` — there is no
@@ -29,7 +29,7 @@ import path from "path";
 // requires a code edit or a symlink. Re-exported by
 // `server/workspace.ts` for backwards compatibility of existing
 // callers that `import { workspacePath } from "./workspace.js"`.
-export const workspacePath = path.join(os.homedir(), "mulmoclaude");
+export const workspacePath = path.join(homedir(), "mulmoclaude");
 
 // Workspace-relative paths. Keys are the stable code-side identifiers
 // (e.g. `markdowns` — unchanged for call-site compatibility); values
@@ -90,7 +90,7 @@ import { WORKSPACE_FILES } from "../../src/config/workspacePaths.js";
 export { WORKSPACE_FILES };
 
 // Absolute paths, built once at module load from `workspacePath`.
-// The `workspacePath` const is itself fixed (reads `os.homedir()`
+// The `workspacePath` const is itself fixed (reads `homedir()`
 // at process start — no env override, see `server/workspace.ts`),
 // so freezing these paths is safe.
 export const WORKSPACE_PATHS = {

package/server/workspace/reference-dirs.ts

@@ -8,7 +8,7 @@
 
 import { createHash } from "crypto";
 import path from "path";
-import os from "os";
+import { homedir } from "os";
 import { log } from "../system/logger/index.js";
 import { readReferenceDirsJson, writeReferenceDirsJson, isExistingDirectory } from "../utils/files/reference-dirs-io.js";
 import { isRecord } from "../utils/types.js";
@@ -41,7 +41,7 @@ const CONTROL_CHAR_RE_G = /[\x00-\x1f]/g;
 
 function expandHome(inputPath: string): string {
   if (inputPath.startsWith("~/")) {
-    return path.join(os.homedir(), inputPath.slice(2));
+    return path.join(homedir(), inputPath.slice(2));
   }
   return inputPath;
 }
@@ -52,7 +52,7 @@ function isSensitivePath(absPath: string): boolean {
   // Reject filesystem root
   if (normalized === path.parse(normalized).root) return true;
 
-  const home = os.homedir();
+  const home = homedir();
 
   // Block $HOME itself (transitively exposes .ssh etc.)
   if (normalized === home) return true;

package/server/workspace/skills/parser.ts

@@ -56,9 +56,9 @@ function parseScheduleValue(raw: string): SkillSchedule["parsed"] {
   // daily HH:MM — validate range: HH 00-23, MM 00-59
   const dailyMatch = trimmed.match(/^daily\s+(\d{2}):(\d{2})$/);
   if (dailyMatch) {
-    const hh = Number(dailyMatch[1]);
-    const mm = Number(dailyMatch[2]);
-    if (hh > 23 || mm > 59) return null;
+    const hours = Number(dailyMatch[1]);
+    const minutes = Number(dailyMatch[2]);
+    if (hours > 23 || minutes > 59) return null;
     return {
       type: SCHEDULE_TYPES.daily,
       time: `${dailyMatch[1]}:${dailyMatch[2]}`,
@@ -70,9 +70,9 @@ function parseScheduleValue(raw: string): SkillSchedule["parsed"] {
   if (intervalMatch) {
     const value = Number(intervalMatch[1]);
     const unit = intervalMatch[2];
-    const ms = TIME_UNIT_MS[unit];
-    if (!ms) return null;
-    const intervalMs = value * ms;
+    const unitMs = TIME_UNIT_MS[unit];
+    if (!unitMs) return null;
+    const intervalMs = value * unitMs;
     if (intervalMs < MIN_INTERVAL_MS) return null;
     return { type: SCHEDULE_TYPES.interval, intervalMs };
   }

package/server/workspace/skills/scheduler.ts

@@ -137,10 +137,10 @@ function readSkillScheduleInfo(skill: Skill): SkillScheduleInfo | null {
   try {
     const raw = readFileSync(skill.path, "utf-8");
     const parsed = parseSkillFrontmatter(raw);
-    const s = parsed?.schedule?.parsed;
-    if (!s) return null;
+    const schedule = parsed?.schedule?.parsed;
+    if (!schedule) return null;
     return {
-      schedule: s,
+      schedule,
       roleId: parsed?.roleId ?? DEFAULT_ROLE_ID,
     };
   } catch {

package/server/workspace/skills/writer.ts

@@ -54,7 +54,7 @@ export async function saveProjectSkill(input: SaveSkillInput): Promise<SaveResul
   // user-scope skill with the same name (project would silently
   // override it via the precedence rule).
   const existing = await discoverSkills({ workspaceRoot });
-  if (existing.some((s) => s.name === name)) {
+  if (existing.some((skill) => skill.name === name)) {
     return { kind: "exists", name };
   }
 
@@ -98,7 +98,7 @@ export async function updateProjectSkill(input: SaveSkillInput): Promise<UpdateR
   }
 
   const existing = await discoverSkills({ workspaceRoot });
-  const skill = existing.find((s) => s.name === name);
+  const skill = existing.find((candidate) => candidate.name === name);
   if (!skill) return { kind: "not-found", name };
   if (skill.source === "user") return { kind: "user-scope", name };
 
@@ -139,7 +139,7 @@ export async function deleteProjectSkill(input: DeleteSkillInput): Promise<Delet
   // Look up the skill's effective source via discovery — if the
   // matching name is user-scope, we refuse.
   const all = await discoverSkills({ workspaceRoot });
-  const skill = all.find((s) => s.name === name);
+  const skill = all.find((candidate) => candidate.name === name);
   if (!skill) return { kind: "not-found", name };
   if (skill.source === "user") return { kind: "user-scope", name };
 

package/server/workspace/sources/arxivDiscovery.ts

@@ -16,7 +16,7 @@ import { workspacePath } from "../paths.js";
 import { log } from "../../system/logger/index.js";
 import { slugify } from "../../utils/slug.js";
 import type { Source } from "./types.js";
-import fs from "fs";
+import { mkdirSync } from "fs";
 
 // ── Constants ───────────────────────────────────────────────────
 
@@ -88,7 +88,7 @@ export async function discoverAndRegister(root?: string): Promise<DiscoveryResul
 
   // Ensure sources directory exists
   const dir = sourcesRoot(base);
-  fs.mkdirSync(dir, { recursive: true });
+  mkdirSync(dir, { recursive: true });
 
   const existing = await listSources(base);
   const existingSlugs = new Set(existing.map((source) => source.slug));

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) {

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";
@@ -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

@@ -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 parsed = Date.parse(state.nextAttemptAt);
+  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")}`;
 }