mulmoclaude 0.1.2 → 0.4.0

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";
@@ -39,11 +39,11 @@ const CONTROL_CHAR_RE_G = /[\x00-\x1f]/g;
 
 // ── Validation ──────────────────────────────────────────────────
 
-function expandHome(p: string): string {
-  if (p.startsWith("~/")) {
-    return path.join(os.homedir(), p.slice(2));
+function expandHome(inputPath: string): string {
+  if (inputPath.startsWith("~/")) {
+    return path.join(homedir(), inputPath.slice(2));
   }
-  return p;
+  return inputPath;
 }
 
 function isSensitivePath(absPath: string): boolean {
@@ -52,15 +52,15 @@ 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;
 
   // Block home-relative sensitive dirs
   if (
-    HOME_RELATIVE_BLOCKED.some((bp) => {
-      const full = path.join(home, bp);
+    HOME_RELATIVE_BLOCKED.some((blockedPath) => {
+      const full = path.join(home, blockedPath);
       return normalized === full || normalized.startsWith(full + path.sep);
     })
   ) {
@@ -68,7 +68,7 @@ function isSensitivePath(absPath: string): boolean {
   }
 
   // Block system directories
-  return SYSTEM_BLOCKED_PREFIXES.some((p) => normalized === p || normalized.startsWith(p + path.sep));
+  return SYSTEM_BLOCKED_PREFIXES.some((blockedPrefix) => normalized === blockedPrefix || normalized.startsWith(blockedPrefix + path.sep));
 }
 
 function sanitizeLabel(raw: string): string {
@@ -76,8 +76,8 @@ function sanitizeLabel(raw: string): string {
   return raw.replace(CONTROL_CHAR_RE_G, " ").trim().slice(0, MAX_LABEL_LENGTH);
 }
 
-function hasTraversalSegment(p: string): boolean {
-  return p.split(path.sep).some((seg) => seg === "..");
+function hasTraversalSegment(inputPath: string): boolean {
+  return inputPath.split(path.sep).some((segment) => segment === "..");
 }
 
 function validateEntry(raw: unknown): ReferenceDirEntry | null {
@@ -117,11 +117,11 @@ export function loadReferenceDirs(root?: string): ReferenceDirEntry[] {
   const entries = parsed
     .slice(0, MAX_ENTRIES)
     .map(validateEntry)
-    .filter((e): e is ReferenceDirEntry => {
-      if (!e) return false;
+    .filter((entry): entry is ReferenceDirEntry => {
+      if (!entry) return false;
       // Deduplicate labels — first entry wins
-      if (seenLabels.has(e.label)) return false;
-      seenLabels.add(e.label);
+      if (seenLabels.has(entry.label)) return false;
+      seenLabels.add(entry.label);
       return true;
     });
 
@@ -155,8 +155,8 @@ export function validateReferenceDirs(raw: unknown): { entries: ReferenceDirEntr
     if (entry) {
       entries.push(entry);
     } else {
-      const p = isRecord(item) ? String((item as Record<string, unknown>).hostPath ?? "") : "";
-      errors.push(`entry ${i}: invalid or blocked path "${p}"`);
+      const hostPath = isRecord(item) ? String((item as Record<string, unknown>).hostPath ?? "") : "";
+      errors.push(`entry ${i}: invalid or blocked path "${hostPath}"`);
     }
   });
   if (errors.length > 0) {
@@ -233,9 +233,9 @@ export function buildReferenceDirsPrompt(entries: readonly ReferenceDirEntry[],
     "",
   ];
 
-  for (const e of entries) {
-    const mountPath = useDocker ? containerPath(e) : e.hostPath;
-    lines.push(`- \`${mountPath}\` — ${e.label}`);
+  for (const entry of entries) {
+    const mountPath = useDocker ? containerPath(entry) : entry.hostPath;
+    lines.push(`- \`${mountPath}\` — ${entry.label}`);
   }
 
   if (!useDocker) {

package/server/workspace/roles.ts

@@ -14,10 +14,10 @@ function withSwitchRole(role: Role): Role {
 
 export function loadCustomRoles(): Role[] {
   return readdirUnderSync(workspacePath, WORKSPACE_DIRS.roles)
-    .filter((f) => f.endsWith(".json"))
-    .flatMap((f) => {
+    .filter((fileName) => fileName.endsWith(".json"))
+    .flatMap((fileName) => {
       try {
-        const raw = readTextUnderSync(workspacePath, path.posix.join(WORKSPACE_DIRS.roles, f));
+        const raw = readTextUnderSync(workspacePath, path.posix.join(WORKSPACE_DIRS.roles, fileName));
         if (!raw) return [];
         return [withSwitchRole(RoleSchema.parse(JSON.parse(raw)))];
       } catch {
@@ -28,10 +28,10 @@ export function loadCustomRoles(): Role[] {
 
 export function loadAllRoles(): Role[] {
   const custom = loadCustomRoles();
-  const builtIn = BUILTIN_ROLES.filter((r) => !custom.find((c) => c.id === r.id));
+  const builtIn = BUILTIN_ROLES.filter((role) => !custom.find((customRole) => customRole.id === role.id));
   return [...builtIn, ...custom];
 }
 
-export function getRole(id: string): Role {
-  return loadAllRoles().find((r) => r.id === id) ?? BUILTIN_ROLES[0];
+export function getRole(roleId: string): Role {
+  return loadAllRoles().find((role) => role.id === roleId) ?? BUILTIN_ROLES[0];
 }

package/server/workspace/skills/discovery.ts

@@ -90,7 +90,7 @@ export async function collectSkillsFromDir(root: string, source: SkillSource): P
     if (skill) results.push(skill);
   }
   // Stable alphabetical order for the UI.
-  results.sort((a, b) => a.name.localeCompare(b.name));
+  results.sort((leftSkill, rightSkill) => leftSkill.name.localeCompare(rightSkill.name));
   return results;
 }
 
@@ -118,8 +118,8 @@ export async function discoverSkills(opts: DiscoverSkillsOptions = {}): Promise<
   // Project overrides user on name collision. Merge by building a
   // map keyed by name, starting with user, overwriting with project.
   const merged = new Map<string, Skill>();
-  for (const s of userSkills) merged.set(s.name, s);
-  for (const s of projectSkills) merged.set(s.name, s);
+  for (const skill of userSkills) merged.set(skill.name, skill);
+  for (const skill of projectSkills) merged.set(skill.name, skill);
 
-  return [...merged.values()].sort((a, b) => a.name.localeCompare(b.name));
+  return [...merged.values()].sort((leftSkill, rightSkill) => leftSkill.name.localeCompare(rightSkill.name));
 }

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/user-tasks.ts

@@ -32,8 +32,8 @@ export interface PersistedUserTask {
   updatedAt: string;
 }
 
-export function loadUserTasks(r?: string): PersistedUserTask[] {
-  return loadRaw<PersistedUserTask>(r);
+export function loadUserTasks(workspaceRoot?: string): PersistedUserTask[] {
+  return loadRaw<PersistedUserTask>(workspaceRoot);
 }
 
 // ── Validation ──────────────────────────────────────────────────
@@ -42,20 +42,20 @@ function isValidDailyTime(value: string): boolean {
   return /^([01]\d|2[0-3]):([0-5]\d)$/.test(value);
 }
 
-function isValidSchedule(s: unknown): s is LocalTaskSchedule {
-  if (!isRecord(s)) return false;
-  const obj = s as Record<string, unknown>;
-  if (obj.type === SCHEDULE_TYPES.interval) {
-    return typeof obj.intervalMs === "number" && obj.intervalMs > 0;
+function isValidSchedule(scheduleValue: unknown): scheduleValue is LocalTaskSchedule {
+  if (!isRecord(scheduleValue)) return false;
+  const scheduleRecord = scheduleValue as Record<string, unknown>;
+  if (scheduleRecord.type === SCHEDULE_TYPES.interval) {
+    return typeof scheduleRecord.intervalMs === "number" && scheduleRecord.intervalMs > 0;
   }
-  if (obj.type === SCHEDULE_TYPES.daily) {
-    return typeof obj.time === "string" && isValidDailyTime(obj.time);
+  if (scheduleRecord.type === SCHEDULE_TYPES.daily) {
+    return typeof scheduleRecord.time === "string" && isValidDailyTime(scheduleRecord.time);
   }
   return false;
 }
 
-function isValidMissedRunPolicy(p: unknown): p is MissedRunPolicy {
-  return p === MISSED_RUN_POLICIES.skip || p === MISSED_RUN_POLICIES.runOnce || p === MISSED_RUN_POLICIES.runAll;
+function isValidMissedRunPolicy(policy: unknown): policy is MissedRunPolicy {
+  return policy === MISSED_RUN_POLICIES.skip || policy === MISSED_RUN_POLICIES.runOnce || policy === MISSED_RUN_POLICIES.runAll;
 }
 
 export type ValidateResult = { kind: "ok"; task: PersistedUserTask } | { kind: "error"; error: string };
@@ -96,44 +96,44 @@ export function validateAndCreate(input: unknown): ValidateResult {
 
 export type UpdateResult = { kind: "ok"; tasks: PersistedUserTask[] } | { kind: "error"; error: string };
 
-export function applyUpdate(tasks: PersistedUserTask[], id: string, patch: unknown): UpdateResult {
+export function applyUpdate(tasks: PersistedUserTask[], taskId: string, patch: unknown): UpdateResult {
   if (!isRecord(patch)) {
     return { kind: "error", error: "request body required" };
   }
-  const idx = tasks.findIndex((t) => t.id === id);
-  if (idx === -1) {
-    return { kind: "error", error: `task not found: ${id}` };
+  const index = tasks.findIndex((task) => task.id === taskId);
+  if (index === -1) {
+    return { kind: "error", error: `task not found: ${taskId}` };
   }
-  const existing = tasks[idx];
+  const existing = tasks[index];
   const updated: PersistedUserTask = { ...existing };
   // patch is validated as non-null object above; spread into Record
-  const p: Record<string, unknown> = { ...patch };
+  const patchRecord: Record<string, unknown> = { ...patch };
 
-  if (typeof p.name === "string" && p.name.trim().length > 0) {
-    updated.name = p.name.trim();
+  if (typeof patchRecord.name === "string" && patchRecord.name.trim().length > 0) {
+    updated.name = patchRecord.name.trim();
   }
-  if (typeof p.description === "string") {
-    updated.description = p.description.trim();
+  if (typeof patchRecord.description === "string") {
+    updated.description = patchRecord.description.trim();
   }
-  if (isValidSchedule(p.schedule)) {
-    updated.schedule = p.schedule;
+  if (isValidSchedule(patchRecord.schedule)) {
+    updated.schedule = patchRecord.schedule;
   }
-  if (isValidMissedRunPolicy(p.missedRunPolicy)) {
-    updated.missedRunPolicy = p.missedRunPolicy;
+  if (isValidMissedRunPolicy(patchRecord.missedRunPolicy)) {
+    updated.missedRunPolicy = patchRecord.missedRunPolicy;
   }
-  if (typeof p.enabled === "boolean") {
-    updated.enabled = p.enabled;
+  if (typeof patchRecord.enabled === "boolean") {
+    updated.enabled = patchRecord.enabled;
   }
-  if (typeof p.roleId === "string") {
-    updated.roleId = p.roleId;
+  if (typeof patchRecord.roleId === "string") {
+    updated.roleId = patchRecord.roleId;
   }
-  if (typeof p.prompt === "string" && p.prompt.trim().length > 0) {
-    updated.prompt = p.prompt.trim();
+  if (typeof patchRecord.prompt === "string" && patchRecord.prompt.trim().length > 0) {
+    updated.prompt = patchRecord.prompt.trim();
   }
   updated.updatedAt = new Date().toISOString();
 
   const next = [...tasks];
-  next[idx] = updated;
+  next[index] = updated;
   return { kind: "ok", tasks: next };
 }
 
@@ -144,7 +144,7 @@ export function applyUpdate(tasks: PersistedUserTask[], id: string, patch: unkno
 let crudMutex: Promise<void> = Promise.resolve();
 
 export async function withUserTaskLock<T>(
-  fn: (tasks: PersistedUserTask[]) => Promise<{
+  lockFn: (tasks: PersistedUserTask[]) => Promise<{
     tasks: PersistedUserTask[];
     result: T;
   }>,
@@ -157,7 +157,7 @@ export async function withUserTaskLock<T>(
   try {
     await prev;
     const current = loadUserTasks();
-    const { tasks: next, result } = await fn(current);
+    const { tasks: next, result } = await lockFn(current);
     await saveUserTasks(next);
     await refreshUserTasks();
     return result;

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 ───────────────────────────────────────────────────
 
@@ -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
@@ -88,10 +88,10 @@ 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((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;