mulmoclaude 0.1.2 → 0.3.0

package/server/api/routes/sessions.ts

@@ -26,14 +26,14 @@ interface SessionMeta {
   origin?: SessionOrigin;
 }
 
-async function readSessionMeta(__chatDir: string, id: string): Promise<SessionMeta | null> {
+async function readSessionMeta(__chatDir: string, sessionId: string): Promise<SessionMeta | null> {
   // Try new-style .json meta first
-  const meta = await readSessionMetaIO(id);
+  const meta = await readSessionMetaIO(sessionId);
   if (meta?.roleId && meta?.startedAt) {
     return meta as SessionMeta;
   }
   // Legacy: read first line of .jsonl
-  const jsonl = await readSessionJsonl(id);
+  const jsonl = await readSessionJsonl(sessionId);
   if (jsonl) {
     const first = jsonl.split("\n").find(Boolean);
     if (first) {
@@ -102,19 +102,19 @@ const WINDOW_MS = env.sessionsListWindowDays * ONE_DAY_MS;
 export async function loadAllSessions(): Promise<{ summary: SessionSummary; changeMs: number }[]> {
   const chatDir = WORKSPACE_PATHS.chat;
   const manifest = await readManifest(workspacePath);
-  const indexById = new Map<string, ChatIndexEntry>(manifest.entries.map((e) => [e.id, e]));
+  const indexById = new Map<string, ChatIndexEntry>(manifest.entries.map((entry) => [entry.id, entry]));
   const cutoff = WINDOW_MS > 0 ? Date.now() - WINDOW_MS : 0;
 
-  const files = (await readdir(chatDir)).filter((f) => f.endsWith(".jsonl"));
+  const files = (await readdir(chatDir)).filter((fileName) => fileName.endsWith(".jsonl"));
   const rows = await Promise.all(
     files.map(async (file) => {
-      const id = file.replace(".jsonl", "");
+      const sessionId = file.replace(".jsonl", "");
       try {
         // stat only — no readFile on .jsonl content
-        const fileStat = await stat(sessionJsonlAbsPath(id));
+        const fileStat = await stat(sessionJsonlAbsPath(sessionId));
         if (cutoff > 0 && fileStat.mtimeMs < cutoff) return null;
 
-        const meta = await readSessionMeta(chatDir, id);
+        const meta = await readSessionMeta(chatDir, sessionId);
         if (!meta) return null;
 
         // The meta sidecar bumps its mtime on hasUnread / origin
@@ -122,20 +122,20 @@ export async function loadAllSessions(): Promise<{ summary: SessionSummary; chan
         // pick up drains of background generations (which only touch
         // meta, not the jsonl). Missing stat (brand-new session
         // before its first meta write) contributes 0.
-        const metaMtimeMs = await stat(sessionMetaAbsPath(id))
-          .then((s) => s.mtimeMs)
+        const metaMtimeMs = await stat(sessionMetaAbsPath(sessionId))
+          .then((stats) => stats.mtimeMs)
           .catch(() => 0);
 
-        const indexEntry = indexById.get(id);
+        const indexEntry = indexById.get(sessionId);
         // Prefer AI title → meta.firstUserMessage → empty.
         // `summary` and `keywords` are spread conditionally
         // to respect the server tsconfig's
         // exactOptionalPropertyTypes.
         const preview = indexEntry?.title ?? meta.firstUserMessage ?? "";
 
-        const live = getSession(id);
+        const live = getSession(sessionId);
         const summary: SessionSummary = {
-          id,
+          id: sessionId,
           roleId: meta.roleId,
           startedAt: meta.startedAt,
           updatedAt: new Date(fileStat.mtimeMs).toISOString(),
@@ -161,7 +161,7 @@ export async function loadAllSessions(): Promise<{ summary: SessionSummary; chan
       }
     }),
   );
-  return rows.filter((r): r is { summary: SessionSummary; changeMs: number } => r !== null);
+  return rows.filter((row): row is { summary: SessionSummary; changeMs: number } => row !== null);
 }
 
 router.get(API_ROUTES.sessions.list, async (req: Request<object, SessionsResponse, object, SessionsQuery>, res: Response<SessionsResponse>) => {
@@ -173,15 +173,15 @@ router.get(API_ROUTES.sessions.list, async (req: Request<object, SessionsRespons
     // of whether it's in the diff. Echoing the same cursor back on an
     // empty diff (nothing changed since `?since=`) is fine; the
     // client no-ops.
-    const maxChangeMs = rows.reduce((acc, r) => Math.max(acc, r.changeMs), 0);
+    const maxChangeMs = rows.reduce((acc, row) => Math.max(acc, row.changeMs), 0);
 
-    const filtered = sinceMs > 0 ? rows.filter((r) => r.changeMs > sinceMs) : rows;
+    const filtered = sinceMs > 0 ? rows.filter((row) => row.changeMs > sinceMs) : rows;
 
-    const sessions = filtered.map((r) => r.summary);
-    sessions.sort((a, b) => {
-      const byUpdated = new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime();
+    const sessions = filtered.map((row) => row.summary);
+    sessions.sort((leftSession, rightSession) => {
+      const byUpdated = new Date(rightSession.updatedAt).getTime() - new Date(leftSession.updatedAt).getTime();
       if (byUpdated !== 0) return byUpdated;
-      return new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime();
+      return new Date(rightSession.startedAt).getTime() - new Date(leftSession.startedAt).getTime();
     });
 
     res.json({
@@ -207,13 +207,13 @@ interface SessionErrorResponse {
 }
 
 router.get(API_ROUTES.sessions.detail, async (req: Request<SessionIdParams>, res: Response<unknown[] | SessionErrorResponse>) => {
-  const { id } = req.params;
+  const { id: sessionId } = req.params;
   const chatDir = WORKSPACE_PATHS.chat;
   try {
-    const meta = await readSessionMeta(chatDir, id);
-    const content = await readSessionJsonl(id);
+    const meta = await readSessionMeta(chatDir, sessionId);
+    const content = await readSessionJsonl(sessionId);
     if (!content) {
-      notFound(res, `Session ${id} not found`);
+      notFound(res, `Session ${sessionId} not found`);
       return;
     }
     const entries = (

package/server/api/routes/todosColumnsHandlers.ts

@@ -79,8 +79,8 @@ function uniqueId(base: string, existingIds: ReadonlySet<string>): string {
 
 // ── Validation helpers ────────────────────────────────────────────
 
-function findColumn(columns: StatusColumn[], id: string): StatusColumn | undefined {
-  return columns.find((column) => column.id === id);
+function findColumn(columns: StatusColumn[], columnId: string): StatusColumn | undefined {
+  return columns.find((column) => column.id === columnId);
 }
 
 function ensureColumnsValid(columns: StatusColumn[]): StatusColumn[] {
@@ -161,11 +161,11 @@ export function defaultStatusId(columns: StatusColumn[]): string {
 // to sync at that point.
 export function resyncDoneMembership(items: TodoItem[], newDoneId: string): { items: TodoItem[]; changed: boolean } {
   let changed = false;
-  const next = items.map((it): TodoItem => {
-    const shouldBeDone = it.status === newDoneId;
-    if (it.completed === shouldBeDone) return it;
+  const next = items.map((item): TodoItem => {
+    const shouldBeDone = item.status === newDoneId;
+    if (item.completed === shouldBeDone) return item;
     changed = true;
-    return { ...it, completed: shouldBeDone };
+    return { ...item, completed: shouldBeDone };
   });
   return { items: next, changed };
 }
@@ -178,7 +178,7 @@ export function resyncDoneMembership(items: TodoItem[], newDoneId: string): { it
 function rebuildColumnOrder(items: TodoItem[], columnId: string): TodoItem[] {
   const inColumn = items.filter((item) => item.status === columnId).sort((left, right) => (left.order ?? 0) - (right.order ?? 0));
   const newOrders = new Map<string, number>();
-  inColumn.forEach((item, i) => newOrders.set(item.id, (i + 1) * ORDER_STEP));
+  inColumn.forEach((item, index) => newOrders.set(item.id, (index + 1) * ORDER_STEP));
   return items.map((item): TodoItem => {
     const newOrder = newOrders.get(item.id);
     if (newOrder === undefined) return item;
@@ -200,23 +200,23 @@ export function handleAddColumn(columns: StatusColumn[], items: TodoItem[], inpu
     return { kind: "error", status: 400, error: "label required" };
   }
   const baseId = slugify(input.label);
-  const id = uniqueId(baseId, new Set(columns.map((column) => column.id)));
-  const col: StatusColumn = { id, label: input.label.trim() };
-  if (input.isDone === true) col.isDone = true;
+  const columnId = uniqueId(baseId, new Set(columns.map((column) => column.id)));
+  const columnToAdd: StatusColumn = { id: columnId, label: input.label.trim() };
+  if (input.isDone === true) columnToAdd.isDone = true;
   // If the new column is flagged done, demote any existing done
   // columns (only one is allowed at a time) and resync items so the
   // old done column's items are no longer marked completed. The new
   // column itself is empty so there's nothing on its side to sync.
   if (input.isDone === true) {
-    const nextColumns = [...columns.map((column) => ({ ...column, isDone: false })), col];
-    const { items: nextItems, changed } = resyncDoneMembership(items, id);
+    const nextColumns = [...columns.map((column) => ({ ...column, isDone: false })), columnToAdd];
+    const { items: nextItems, changed } = resyncDoneMembership(items, columnId);
     return {
       kind: "success",
       columns: nextColumns,
       ...(changed ? { items: nextItems } : {}),
     };
   }
-  return { kind: "success", columns: [...columns, col] };
+  return { kind: "success", columns: [...columns, columnToAdd] };
 }
 
 export interface PatchColumnInput {
@@ -224,28 +224,28 @@ export interface PatchColumnInput {
   isDone?: boolean;
 }
 
-export function handlePatchColumn(columns: StatusColumn[], id: string, input: PatchColumnInput, items: TodoItem[]): ColumnsActionResult {
-  const target = findColumn(columns, id);
+export function handlePatchColumn(columns: StatusColumn[], columnId: string, input: PatchColumnInput, items: TodoItem[]): ColumnsActionResult {
+  const target = findColumn(columns, columnId);
   if (!target) {
-    return { kind: "error", status: 404, error: `column not found: ${id}` };
+    return { kind: "error", status: 404, error: `column not found: ${columnId}` };
   }
   const patched: StatusColumn = { id: target.id, label: target.label };
   if (target.isDone) patched.isDone = true;
   if (typeof input.label === "string" && input.label.trim().length > 0) {
     patched.label = input.label.trim();
   }
-  let nextColumns = columns.map((column) => (column.id === id ? patched : column));
+  let nextColumns = columns.map((column) => (column.id === columnId ? patched : column));
   // Toggling done flag is non-trivial: only one column may be done.
   let itemsChanged = false;
   let nextItems = items;
   if (input.isDone === true && !target.isDone) {
     // Promote this column to done; demote everyone else.
-    nextColumns = nextColumns.map((column) => (column.id === id ? { ...column, isDone: true } : { id: column.id, label: column.label }));
+    nextColumns = nextColumns.map((column) => (column.id === columnId ? { ...column, isDone: true } : { id: column.id, label: column.label }));
     // Resync `completed` across all items: the new done column's
     // items become true, the old done column's items become false.
     // Doing this with the helper rather than a one-sided pass means
     // both ends of the swap stay consistent.
-    const synced = resyncDoneMembership(items, id);
+    const synced = resyncDoneMembership(items, columnId);
     nextItems = synced.items;
     itemsChanged = synced.changed;
   } else if (input.isDone === false && target.isDone) {
@@ -263,7 +263,7 @@ export function handlePatchColumn(columns: StatusColumn[], id: string, input: Pa
   };
 }
 
-export function handleDeleteColumn(columns: StatusColumn[], id: string, items: TodoItem[]): ColumnsActionResult {
+export function handleDeleteColumn(columns: StatusColumn[], columnId: string, items: TodoItem[]): ColumnsActionResult {
   if (columns.length <= 1) {
     return {
       kind: "error",
@@ -271,11 +271,11 @@ export function handleDeleteColumn(columns: StatusColumn[], id: string, items: T
       error: "cannot delete the last remaining column",
     };
   }
-  const target = findColumn(columns, id);
+  const target = findColumn(columns, columnId);
   if (!target) {
-    return { kind: "error", status: 404, error: `column not found: ${id}` };
+    return { kind: "error", status: 404, error: `column not found: ${columnId}` };
   }
-  const remaining = columns.filter((column) => column.id !== id);
+  const remaining = columns.filter((column) => column.id !== columnId);
   // If we just removed the done column, promote the new last column.
   let nextColumns = remaining;
   if (target.isDone) {
@@ -286,10 +286,10 @@ export function handleDeleteColumn(columns: StatusColumn[], id: string, items: T
   // deleted column was done; otherwise to the new default open column.
   const refugeId = target.isDone ? newDoneId : defaultStatusId(nextColumns);
   let itemsChanged = false;
-  let nextItems = items.map((it): TodoItem => {
-    if (it.status !== id) return it;
+  let nextItems = items.map((item): TodoItem => {
+    if (item.status !== columnId) return item;
     itemsChanged = true;
-    return { ...it, status: refugeId };
+    return { ...item, status: refugeId };
   });
   if (itemsChanged) {
     // The refuge column might have already had items in it; the ones
@@ -331,17 +331,17 @@ export function handleReorderColumns(columns: StatusColumn[], ids: string[]): Co
   }
   const known = new Set(columns.map((column) => column.id));
   const seen = new Set<string>();
-  for (const id of ids) {
-    if (!known.has(id) || seen.has(id)) {
+  for (const columnId of ids) {
+    if (!known.has(columnId) || seen.has(columnId)) {
       return {
         kind: "error",
         status: 400,
         error: "ids must contain every existing column id exactly once",
       };
     }
-    seen.add(id);
+    seen.add(columnId);
   }
   const byId = new Map(columns.map((column) => [column.id, column]));
-  const next = ids.map((id) => byId.get(id)!);
+  const next = ids.map((columnId) => byId.get(columnId)!);
   return { kind: "success", columns: next };
 }

package/server/api/routes/wiki.ts

@@ -46,7 +46,7 @@ function parseTableRow(trimmed: string): WikiPageEntry | null {
   const cols = trimmed
     .split("|")
     .slice(1, -1)
-    .map((c) => c.trim().replace(/^`|`$/g, ""));
+    .map((column) => column.trim().replace(/^`|`$/g, ""));
   if (cols.length < 2) return null;
   const slug = cols[0];
   const title = cols[1] || slug;
@@ -70,11 +70,11 @@ export function extractSlugFromBulletHref(rawHref: string): string {
 }
 
 function parseBulletLinkRow(trimmed: string): WikiPageEntry | null {
-  const m = BULLET_LINK_PATTERN.exec(trimmed);
-  if (!m) return null;
-  const title = m[1].trim();
-  const href = m[2] ?? "";
-  const desc = m[3]?.trim() ?? "";
+  const match = BULLET_LINK_PATTERN.exec(trimmed);
+  if (!match) return null;
+  const title = match[1].trim();
+  const href = match[2] ?? "";
+  const desc = match[3]?.trim() ?? "";
   // Prefer the slug embedded in the href so non-ASCII titles keep
   // a navigable slug. Fall back to slugifying the title only when
   // the href has no recognisable slug (rare — usually means the
@@ -84,10 +84,10 @@ function parseBulletLinkRow(trimmed: string): WikiPageEntry | null {
 }
 
 function parseBulletWikiLinkRow(trimmed: string): WikiPageEntry | null {
-  const m = BULLET_WIKI_LINK_PATTERN.exec(trimmed);
-  if (!m) return null;
-  const title = m[1].trim();
-  const desc = m[2]?.trim() ?? "";
+  const match = BULLET_WIKI_LINK_PATTERN.exec(trimmed);
+  if (!match) return null;
+  const title = match[1].trim();
+  const desc = match[2]?.trim() ?? "";
   return { title, slug: wikiSlugify(title), description: desc };
 }
 
@@ -276,7 +276,7 @@ export function findMissingFiles(pageEntries: readonly WikiPageEntry[], fileSlug
 
 export function findBrokenLinksInPage(fileName: string, content: string, fileSlugs: ReadonlySet<string>): string[] {
   const issues: string[] = [];
-  const wikiLinks = [...content.matchAll(WIKI_LINK_PATTERN)].map((m) => m[1]);
+  const wikiLinks = [...content.matchAll(WIKI_LINK_PATTERN)].map((match) => match[1]);
   for (const link of wikiLinks) {
     const linkSlug = wikiSlugify(link);
     if (!fileSlugs.has(linkSlug)) {
@@ -302,7 +302,7 @@ async function collectLintIssues(): Promise<string[]> {
   }
   const indexContent = readFileOrEmpty(indexFile());
   const pageEntries = parseIndexEntries(indexContent);
-  const indexedSlugs = new Set(pageEntries.map((e) => e.slug));
+  const indexedSlugs = new Set(pageEntries.map((entry) => entry.slug));
   const pageFiles = [...slugs.values()];
   const fileSlugs = new Set(slugs.keys());
 
@@ -312,8 +312,8 @@ async function collectLintIssues(): Promise<string[]> {
   // Parallel read: N small markdown files, ~50 KB each. Bounded by
   // the number of wiki pages, not by CPU.
   const contents = await Promise.all(
-    pageFiles.map(async (f) => {
-      const content = await readTextSafe(path.join(dir, f));
+    pageFiles.map(async (fileName) => {
+      const content = await readTextSafe(path.join(dir, fileName));
       return content ?? "";
     }),
   );

package/server/events/scheduler-adapter.ts

@@ -52,16 +52,16 @@ function logsDir(root = workspacePath): string {
 // ── I/O deps (real filesystem) ───────────────────────────────────
 
 const stateDeps: StateDeps = {
-  readFile: (p: string) => readFile(p, "utf-8"),
-  writeFileAtomic: (p: string, content: string) => writeFileAtomic(p, content),
+  readFile: (filePath: string) => readFile(filePath, "utf-8"),
+  writeFileAtomic: (filePath: string, content: string) => writeFileAtomic(filePath, content),
   exists: existsSync,
 };
 
 const logDeps: LogDeps = {
-  appendFile: (p: string, content: string) => appendFile(p, content),
-  readFile: (p: string) => readFile(p, "utf-8"),
+  appendFile: (filePath: string, content: string) => appendFile(filePath, content),
+  readFile: (filePath: string) => readFile(filePath, "utf-8"),
   exists: existsSync,
-  ensureDir: (p: string) => mkdir(p, { recursive: true }).then(() => {}),
+  ensureDir: (directoryPath: string) => mkdir(directoryPath, { recursive: true }).then(() => {}),
 };
 
 // ── System task registry ─────────────────────────────────────────
@@ -95,11 +95,11 @@ export async function initScheduler(taskManager: ITaskManager, tasks: SystemTask
   taskManagerRef = taskManager;
 
   // Run catch-up
-  const catchUpTasks: CatchUpTask[] = tasks.map((t) => ({
-    id: t.id,
-    name: t.name,
-    schedule: toCoreSchedule(t.schedule),
-    missedRunPolicy: t.missedRunPolicy,
+  const catchUpTasks: CatchUpTask[] = tasks.map((taskDef) => ({
+    id: taskDef.id,
+    name: taskDef.name,
+    schedule: toCoreSchedule(taskDef.schedule),
+    missedRunPolicy: taskDef.missedRunPolicy,
     enabled: true,
   }));
   const plan = computeCatchUpPlan(catchUpTasks, stateMap, Date.now());
@@ -117,7 +117,7 @@ export async function initScheduler(taskManager: ITaskManager, tasks: SystemTask
       runs: plan.runs.length,
     });
     for (const run of plan.runs) {
-      const task = tasks.find((t) => t.id === run.taskId);
+      const task = tasks.find((taskDef) => taskDef.id === run.taskId);
       if (!task) continue;
       await executeAndLog(task, run.context.scheduledFor, TASK_TRIGGERS.catchUp);
     }
@@ -137,7 +137,7 @@ export async function initScheduler(taskManager: ITaskManager, tasks: SystemTask
   }
 
   log.info("scheduler", "initialized", {
-    tasks: tasks.map((t) => t.id),
+    tasks: tasks.map((taskDef) => taskDef.id),
     stateEntries: stateMap.size,
   });
 }
@@ -146,7 +146,7 @@ export async function initScheduler(taskManager: ITaskManager, tasks: SystemTask
  *  Updates the in-memory task definition, the task-manager, and
  *  recalculates nextScheduledAt in persisted state. */
 export async function applyScheduleOverride(taskId: string, schedule: SystemTaskDef["schedule"]): Promise<boolean> {
-  const task = systemTasks.find((t) => t.id === taskId);
+  const task = systemTasks.find((taskDef) => taskDef.id === taskId);
   if (!task || !taskManagerRef) return false;
   if (!taskManagerRef.updateSchedule(taskId, schedule)) return false;
   task.schedule = schedule;
@@ -172,13 +172,13 @@ export function getSchedulerTasks(): Array<{
   missedRunPolicy: string;
   state: TaskExecutionState;
 }> {
-  return systemTasks.map((t) => ({
-    id: t.id,
-    name: t.name,
-    description: t.description,
-    schedule: t.schedule,
-    missedRunPolicy: t.missedRunPolicy,
-    state: stateMap.get(t.id) ?? emptyState(t.id),
+  return systemTasks.map((taskDef) => ({
+    id: taskDef.id,
+    name: taskDef.name,
+    description: taskDef.description,
+    schedule: taskDef.schedule,
+    missedRunPolicy: taskDef.missedRunPolicy,
+    state: stateMap.get(taskDef.id) ?? emptyState(taskDef.id),
   }));
 }
 

package/server/events/session-store/index.ts

@@ -65,8 +65,8 @@ const storelessPending = new Map<string, Set<string>>();
 let pubsub: IPubSub | null = null;
 let evictionTimer: ReturnType<typeof setInterval> | null = null;
 
-export function initSessionStore(ps: IPubSub): void {
-  pubsub = ps;
+export function initSessionStore(pubSubInstance: IPubSub): void {
+  pubsub = pubSubInstance;
   if (evictionTimer) clearInterval(evictionTimer);
   evictionTimer = setInterval(evictIdleSessions, EVICTION_CHECK_INTERVAL_MS);
 }
@@ -288,8 +288,8 @@ interface GenerationPayload {
 
 const GENERATION_KIND_VALUES: ReadonlySet<string> = new Set(Object.values(GENERATION_KINDS));
 
-function isGenerationKind(v: unknown): v is GenerationKind {
-  return typeof v === "string" && GENERATION_KIND_VALUES.has(v);
+function isGenerationKind(value: unknown): value is GenerationKind {
+  return typeof value === "string" && GENERATION_KIND_VALUES.has(value);
 }
 
 /**
@@ -314,7 +314,7 @@ function applyEventToSession(session: ServerSession, type: string, event: Record
       timestamp: Date.now(),
     });
   } else if (type === EVENT_TYPES.toolCallResult) {
-    const entry = session.toolCallHistory.find((e) => e.toolUseId === event.toolUseId);
+    const entry = session.toolCallHistory.find((historyEntry) => historyEntry.toolUseId === event.toolUseId);
     if (entry) entry.result = event.content as string;
   } else if (type === EVENT_TYPES.status) {
     session.statusMessage = event.message as string;
@@ -404,8 +404,8 @@ export function getSessionImageData(chatSessionId: string): string | undefined {
 
 export function getActiveSessionIds(): Set<string> {
   const ids = new Set<string>();
-  for (const [id, session] of store) {
-    if (session.isRunning) ids.add(id);
+  for (const [chatSessionId, session] of store) {
+    if (session.isRunning) ids.add(chatSessionId);
   }
   return ids;
 }
@@ -465,14 +465,14 @@ function notifySessionsChanged(): void {
 
 function evictIdleSessions(): void {
   const now = Date.now();
-  for (const [id, session] of store) {
+  for (const [chatSessionId, session] of store) {
     if (session.isRunning) continue;
     const age = now - new Date(session.updatedAt).getTime();
     if (age > IDLE_EVICTION_MS) {
       log.info("session-store", "evicting idle session", {
-        chatSessionId: id,
+        chatSessionId,
       });
-      removeSession(id);
+      removeSession(chatSessionId);
     }
   }
 }

package/server/events/task-manager/index.ts

@@ -52,8 +52,8 @@ function isDue(now: Date, schedule: TaskSchedule, tickMs: number): boolean {
   }
 
   if (schedule.type === SCHEDULE_TYPES.daily) {
-    const [hh, mm] = schedule.time.split(":").map(Number);
-    const targetMs = hh * ONE_HOUR_MS + mm * ONE_MINUTE_MS;
+    const [hours, minutes] = schedule.time.split(":").map(Number);
+    const targetMs = hours * ONE_HOUR_MS + minutes * ONE_MINUTE_MS;
     const msSinceMidnight = now.getUTCHours() * ONE_HOUR_MS + now.getUTCMinutes() * ONE_MINUTE_MS + now.getUTCSeconds() * ONE_SECOND_MS;
     const rounded = Math.floor(msSinceMidnight / tickMs) * tickMs;
     return rounded === targetMs;
@@ -170,11 +170,11 @@ export function createTaskManager(options?: TaskManagerOptions): ITaskManager {
     },
 
     listTasks() {
-      return [...registry.values()].map((d) => ({
-        id: d.id,
-        description: d.description,
-        schedule: d.schedule,
-        dependsOn: d.dependsOn,
+      return [...registry.values()].map((taskDef) => ({
+        id: taskDef.id,
+        description: taskDef.description,
+        schedule: taskDef.schedule,
+        dependsOn: taskDef.dependsOn,
       }));
     },
   };

package/server/index.ts

@@ -157,13 +157,13 @@ app.use(configRoutes);
 app.use(skillsRoutes);
 async function listSessionsForBridge(opts: { limit: number; offset: number }) {
   const rows = await loadAllSessions();
-  const sorted = rows.sort((a, b) => b.changeMs - a.changeMs);
+  const sorted = rows.sort((leftSession, rightSession) => rightSession.changeMs - leftSession.changeMs);
   const total = sorted.length;
-  const sessions = sorted.slice(opts.offset, opts.offset + opts.limit).map((r) => ({
-    id: r.summary.id,
-    roleId: r.summary.roleId,
-    preview: r.summary.preview,
-    updatedAt: r.summary.updatedAt,
+  const sessions = sorted.slice(opts.offset, opts.offset + opts.limit).map((row) => ({
+    id: row.summary.id,
+    roleId: row.summary.roleId,
+    preview: row.summary.preview,
+    updatedAt: row.summary.updatedAt,
   }));
   return { sessions, total };
 }
@@ -275,8 +275,8 @@ async function ensureCredentialsAvailable(): Promise<void> {
 
   if (process.platform === "darwin") {
     const { refreshCredentials } = await import("./system/credentials.js");
-    const ok = await refreshCredentials();
-    if (ok) return;
+    const refreshSucceeded = await refreshCredentials();
+    if (refreshSucceeded) return;
     log.error("sandbox", "Failed to export credentials from macOS Keychain. Run `npm run sandbox:login` manually.");
     process.exit(1);
   }
@@ -310,14 +310,14 @@ async function setupSandbox(): Promise<boolean> {
 
 function logMcpStatus(): void {
   const enabledMcpTools = mcpTools.filter(isMcpToolEnabled);
-  const disabledMcpTools = mcpTools.filter((t) => !isMcpToolEnabled(t));
+  const disabledMcpTools = mcpTools.filter((toolDef) => !isMcpToolEnabled(toolDef));
   if (enabledMcpTools.length > 0) {
     log.info("mcp", "Available", {
-      tools: enabledMcpTools.map((t) => t.definition.name).join(", "),
+      tools: enabledMcpTools.map((toolDef) => toolDef.definition.name).join(", "),
     });
   }
   if (disabledMcpTools.length > 0) {
-    const names = disabledMcpTools.map((t) => t.definition.name + " (" + (t.requiredEnv ?? []).join(", ") + ")").join(", ");
+    const names = disabledMcpTools.map((toolDef) => toolDef.definition.name + " (" + (toolDef.requiredEnv ?? []).join(", ") + ")").join(", ");
     log.info("mcp", "Unavailable (missing env)", { tools: names });
   }
 }
@@ -424,24 +424,24 @@ function startRuntimeServices(httpServer: ReturnType<typeof app.listen>): void {
   // are silently ignored — the hardcoded defaults above remain.
   const overrides = loadSchedulerOverrides();
   for (const task of systemTasks) {
-    const ovr = overrides[task.id];
-    if (!ovr) continue;
-    if (task.schedule.type === SCHEDULE_TYPES.interval && typeof ovr.intervalMs === "number" && ovr.intervalMs > 0) {
+    const override = overrides[task.id];
+    if (!override) continue;
+    if (task.schedule.type === SCHEDULE_TYPES.interval && typeof override.intervalMs === "number" && override.intervalMs > 0) {
       log.info("scheduler", "applying override", {
         id: task.id,
-        intervalMs: ovr.intervalMs,
+        intervalMs: override.intervalMs,
       });
       task.schedule = {
         type: SCHEDULE_TYPES.interval,
-        intervalMs: ovr.intervalMs,
+        intervalMs: override.intervalMs,
       };
     }
-    if (task.schedule.type === SCHEDULE_TYPES.daily && typeof ovr.time === "string" && UTC_HH_MM_RE.test(ovr.time)) {
+    if (task.schedule.type === SCHEDULE_TYPES.daily && typeof override.time === "string" && UTC_HH_MM_RE.test(override.time)) {
       log.info("scheduler", "applying override", {
         id: task.id,
-        time: ovr.time,
+        time: override.time,
       });
-      task.schedule = { type: SCHEDULE_TYPES.daily, time: ovr.time };
+      task.schedule = { type: SCHEDULE_TYPES.daily, time: override.time };
     }
   }