mulmoclaude 0.1.2 → 0.3.0

package/server/utils/date.ts

@@ -8,11 +8,11 @@
  * is a wall-clock question, not a UTC question.
  */
 export function toLocalIsoDate(input: Date | number): string {
-  const d = typeof input === "number" ? new Date(input) : input;
-  const y = d.getFullYear();
-  const m = String(d.getMonth() + 1).padStart(2, "0");
-  const day = String(d.getDate()).padStart(2, "0");
-  return `${y}-${m}-${day}`;
+  const dateValue = typeof input === "number" ? new Date(input) : input;
+  const year = dateValue.getFullYear();
+  const month = String(dateValue.getMonth() + 1).padStart(2, "0");
+  const day = String(dateValue.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
 }
 
 /**
@@ -20,11 +20,11 @@ export function toLocalIsoDate(input: Date | number): string {
  * any context where the date must not shift with the server's
  * local timezone.
  */
-export function toUtcIsoDate(ts: Date): string {
-  const y = ts.getUTCFullYear();
-  const m = String(ts.getUTCMonth() + 1).padStart(2, "0");
-  const d = String(ts.getUTCDate()).padStart(2, "0");
-  return `${y}-${m}-${d}`;
+export function toUtcIsoDate(timestamp: Date): string {
+  const year = timestamp.getUTCFullYear();
+  const month = String(timestamp.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(timestamp.getUTCDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
 }
 
 /**
@@ -41,16 +41,16 @@ export function isoDateOnly(iso: string): string {
  * Does NOT validate month/day ranges (Feb 30 passes); that's the
  * caller's or LLM's responsibility.
  */
-export function isValidIsoDate(s: string): boolean {
-  if (s.length !== 10) return false;
-  if (s[4] !== "-" || s[7] !== "-") return false;
-  return isNumeric(s.slice(0, 4)) && isNumeric(s.slice(5, 7)) && isNumeric(s.slice(8, 10));
+export function isValidIsoDate(input: string): boolean {
+  if (input.length !== 10) return false;
+  if (input[4] !== "-" || input[7] !== "-") return false;
+  return isNumeric(input.slice(0, 4)) && isNumeric(input.slice(5, 7)) && isNumeric(input.slice(8, 10));
 }
 
-function isNumeric(s: string): boolean {
-  if (s.length === 0) return false;
-  for (let i = 0; i < s.length; i++) {
-    const code = s.charCodeAt(i);
+function isNumeric(input: string): boolean {
+  if (input.length === 0) return false;
+  for (let index = 0; index < input.length; index++) {
+    const code = input.charCodeAt(index);
     if (code < 48 || code > 57) return false;
   }
   return true;

package/server/utils/files/atomic.ts

@@ -47,18 +47,18 @@ function isTransientRenameError(err: unknown): boolean {
   return err.code === "EPERM" || err.code === "EBUSY" || err.code === "EACCES";
 }
 
-async function renameWithWindowsRetry(from: string, to: string): Promise<void> {
+async function renameWithWindowsRetry(fromPath: string, toPath: string): Promise<void> {
   for (const delayMs of RENAME_RETRY_DELAYS_MS) {
     try {
-      await fs.promises.rename(from, to);
+      await fs.promises.rename(fromPath, toPath);
       return;
     } catch (err) {
       if (!isTransientRenameError(err)) throw err;
-      await new Promise((r) => setTimeout(r, delayMs));
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
     }
   }
   // Final attempt — let any error propagate.
-  await fs.promises.rename(from, to);
+  await fs.promises.rename(fromPath, toPath);
 }
 
 // Sync sleep that parks the thread instead of burning CPU. Only
@@ -66,21 +66,21 @@ async function renameWithWindowsRetry(from: string, to: string): Promise<void> {
 // case block is the sum of RENAME_RETRY_DELAYS_MS (~430ms) and only
 // triggers under AV/indexer contention.
 const SYNC_SLEEP_BUF = new Int32Array(new SharedArrayBuffer(4));
-function sleepSync(ms: number): void {
-  Atomics.wait(SYNC_SLEEP_BUF, 0, 0, ms);
+function sleepSync(millis: number): void {
+  Atomics.wait(SYNC_SLEEP_BUF, 0, 0, millis);
 }
 
-function renameSyncWithWindowsRetry(from: string, to: string): void {
+function renameSyncWithWindowsRetry(fromPath: string, toPath: string): void {
   for (const delayMs of RENAME_RETRY_DELAYS_MS) {
     try {
-      fs.renameSync(from, to);
+      fs.renameSync(fromPath, toPath);
       return;
     } catch (err) {
       if (!isTransientRenameError(err)) throw err;
       sleepSync(delayMs);
     }
   }
-  fs.renameSync(from, to);
+  fs.renameSync(fromPath, toPath);
 }
 
 /**

package/server/utils/files/html-io.ts

@@ -9,12 +9,12 @@ import { workspacePath } from "../../workspace/paths.js";
 import { readTextUnder, writeTextUnder } from "./workspace-io.js";
 
 const HTML_REL = path.posix.join(WORKSPACE_DIRS.html, "current.html");
-const root = (r?: string) => r ?? workspacePath;
+const root = (workspaceRoot?: string) => workspaceRoot ?? workspacePath;
 
-export async function readCurrentHtml(r?: string): Promise<string | null> {
-  return readTextUnder(root(r), HTML_REL);
+export async function readCurrentHtml(workspaceRoot?: string): Promise<string | null> {
+  return readTextUnder(root(workspaceRoot), HTML_REL);
 }
 
-export async function writeCurrentHtml(html: string, r?: string): Promise<void> {
-  await writeTextUnder(root(r), HTML_REL, html);
+export async function writeCurrentHtml(html: string, workspaceRoot?: string): Promise<void> {
+  await writeTextUnder(root(workspaceRoot), HTML_REL, html);
 }

package/server/utils/files/image-store.ts

@@ -35,8 +35,8 @@ async function safeResolve(relativePath: string): Promise<string> {
 /** Save raw base64 (no data URI prefix) as a PNG file. Returns the workspace-relative path. */
 export async function saveImage(base64Data: string): Promise<string> {
   await ensureImagesDir();
-  const id = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
-  const filename = `${id}.png`;
+  const imageId = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+  const filename = `${imageId}.png`;
   const absPath = path.join(IMAGES_DIR, filename);
   await fs.writeFile(absPath, Buffer.from(base64Data, "base64"));
   return path.posix.join(WORKSPACE_DIRS.images, filename);

package/server/utils/files/journal-io.ts

@@ -51,9 +51,9 @@ export async function writeJournalState(state: unknown, rootOverride?: string):
 
 // ── Index ───────────────────────────────────────────────────────
 
-export async function writeJournalIndex(md: string, rootOverride?: string): Promise<void> {
+export async function writeJournalIndex(markdown: string, rootOverride?: string): Promise<void> {
   const filePath = path.join(summariesRoot(root(rootOverride)), INDEX_FILE);
-  await writeFileAtomic(filePath, md);
+  await writeFileAtomic(filePath, markdown);
 }
 
 // ── Daily summaries ─────────────────────────────────────────────

package/server/utils/files/naming.ts

@@ -44,7 +44,7 @@ export function buildArtifactPathRandom(dir: string, prefix: string, ext: string
   // Pass fallbackSlug as slugify's default so it overrides slugify's
   // built-in "page" default when `prefix` sanitizes to empty.
   const slug = slugify(prefix, fallbackSlug);
-  const id = crypto.randomUUID().replace(/-/g, "").slice(0, RANDOM_SUFFIX_LEN);
-  const fname = `${slug}-${id}${ext}`;
+  const suffix = crypto.randomUUID().replace(/-/g, "").slice(0, RANDOM_SUFFIX_LEN);
+  const fname = `${slug}-${suffix}${ext}`;
   return path.posix.join(dir, fname);
 }

package/server/utils/files/roles-io.ts

@@ -10,16 +10,16 @@ import { workspacePath } from "../../workspace/paths.js";
 import { writeFileAtomicSync } from "./atomic.js";
 import { isEnoent } from "./safe.js";
 
-const root = (r?: string) => r ?? workspacePath;
+const root = (workspaceRoot?: string) => workspaceRoot ?? workspacePath;
 
-function roleFilePath(id: string, r?: string): string {
-  return path.join(root(r), WORKSPACE_DIRS.roles, `${id}.json`);
+function roleFilePath(roleId: string, workspaceRoot?: string): string {
+  return path.join(root(workspaceRoot), WORKSPACE_DIRS.roles, `${roleId}.json`);
 }
 
 /** Check if a custom role file exists. */
-export function roleExists(id: string, r?: string): boolean {
+export function roleExists(roleId: string, workspaceRoot?: string): boolean {
   try {
-    fs.statSync(roleFilePath(id, r));
+    fs.statSync(roleFilePath(roleId, workspaceRoot));
     return true;
   } catch {
     return false;
@@ -27,9 +27,9 @@ export function roleExists(id: string, r?: string): boolean {
 }
 
 /** Delete a custom role file. Returns false if not found. */
-export function deleteRole(id: string, r?: string): boolean {
+export function deleteRole(roleId: string, workspaceRoot?: string): boolean {
   try {
-    fs.unlinkSync(roleFilePath(id, r));
+    fs.unlinkSync(roleFilePath(roleId, workspaceRoot));
     return true;
   } catch (err) {
     if (isEnoent(err)) return false;
@@ -38,8 +38,8 @@ export function deleteRole(id: string, r?: string): boolean {
 }
 
 /** Save (create or overwrite) a custom role file atomically. */
-export function saveRole(id: string, data: unknown, r?: string): void {
-  const dir = path.join(root(r), WORKSPACE_DIRS.roles);
+export function saveRole(roleId: string, data: unknown, workspaceRoot?: string): void {
+  const dir = path.join(root(workspaceRoot), WORKSPACE_DIRS.roles);
   fs.mkdirSync(dir, { recursive: true });
-  writeFileAtomicSync(roleFilePath(id, r), JSON.stringify(data, null, 2));
+  writeFileAtomicSync(roleFilePath(roleId, workspaceRoot), JSON.stringify(data, null, 2));
 }

package/server/utils/files/scheduler-io.ts

@@ -9,12 +9,12 @@ import { resolvePath } from "./workspace-io.js";
 import { loadJsonFile } from "./json.js";
 import { writeFileAtomicSync } from "./atomic.js";
 
-const root = (r?: string) => r ?? workspacePath;
+const root = (workspaceRoot?: string) => workspaceRoot ?? workspacePath;
 
-export function loadSchedulerItems<T>(fallback: T, r?: string): T {
-  return loadJsonFile(resolvePath(root(r), WORKSPACE_FILES.schedulerItems), fallback);
+export function loadSchedulerItems<T>(fallback: T, workspaceRoot?: string): T {
+  return loadJsonFile(resolvePath(root(workspaceRoot), WORKSPACE_FILES.schedulerItems), fallback);
 }
 
-export function saveSchedulerItems(items: unknown, r?: string): void {
-  writeFileAtomicSync(resolvePath(root(r), WORKSPACE_FILES.schedulerItems), JSON.stringify(items, null, 2));
+export function saveSchedulerItems(items: unknown, workspaceRoot?: string): void {
+  writeFileAtomicSync(resolvePath(root(workspaceRoot), WORKSPACE_FILES.schedulerItems), JSON.stringify(items, null, 2));
 }

package/server/utils/files/session-io.ts

@@ -18,12 +18,12 @@ export function ensureChatDir(): void {
   ensureWorkspaceDir(CHAT);
 }
 
-function metaRel(id: string): string {
-  return path.posix.join(CHAT, `${id}.json`);
+function metaRel(sessionId: string): string {
+  return path.posix.join(CHAT, `${sessionId}.json`);
 }
 
-function jsonlRel(id: string): string {
-  return path.posix.join(CHAT, `${id}.jsonl`);
+function jsonlRel(sessionId: string): string {
+  return path.posix.join(CHAT, `${sessionId}.jsonl`);
 }
 
 // ── Meta ────────────────────────────────────────────────────────
@@ -41,8 +41,8 @@ export interface SessionMeta {
 export type ReadMetaResult = { kind: "missing" } | { kind: "ok"; meta: SessionMeta } | { kind: "corrupt"; raw: string };
 
 /** Read session metadata with full outcome discrimination. */
-export async function readSessionMetaFull(id: string, rootOverride?: string): Promise<ReadMetaResult> {
-  const raw = await readTextUnder(root(rootOverride), metaRel(id));
+export async function readSessionMetaFull(sessionId: string, rootOverride?: string): Promise<ReadMetaResult> {
+  const raw = await readTextUnder(root(rootOverride), metaRel(sessionId));
   if (raw === null) return { kind: "missing" };
   try {
     return { kind: "ok", meta: JSON.parse(raw) as SessionMeta };
@@ -53,60 +53,60 @@ export async function readSessionMetaFull(id: string, rootOverride?: string): Pr
 
 /** Convenience: returns the meta or null. Treats corrupt as null
  *  (callers that need to distinguish use readSessionMetaFull). */
-export async function readSessionMeta(id: string, rootOverride?: string): Promise<SessionMeta | null> {
-  const result = await readSessionMetaFull(id, rootOverride);
+export async function readSessionMeta(sessionId: string, rootOverride?: string): Promise<SessionMeta | null> {
+  const result = await readSessionMetaFull(sessionId, rootOverride);
   return result.kind === "ok" ? result.meta : null;
 }
 
-export async function writeSessionMeta(id: string, meta: SessionMeta, rootOverride?: string): Promise<void> {
-  await writeTextUnder(root(rootOverride), metaRel(id), JSON.stringify(meta, null, 2));
+export async function writeSessionMeta(sessionId: string, meta: SessionMeta, rootOverride?: string): Promise<void> {
+  await writeTextUnder(root(rootOverride), metaRel(sessionId), JSON.stringify(meta, null, 2));
 }
 
-export async function createSessionMeta(id: string, roleId: string, firstUserMessage: string, rootOverride?: string, origin?: string): Promise<void> {
+export async function createSessionMeta(sessionId: string, roleId: string, firstUserMessage: string, rootOverride?: string, origin?: string): Promise<void> {
   const meta: Record<string, unknown> = {
     roleId,
     startedAt: new Date().toISOString(),
     firstUserMessage,
   };
   if (origin) meta.origin = origin;
-  await writeSessionMeta(id, meta, rootOverride);
+  await writeSessionMeta(sessionId, meta, rootOverride);
 }
 
-export async function backfillOrigin(id: string, origin: SessionMeta["origin"], rootOverride?: string): Promise<void> {
-  const meta = await readSessionMeta(id, rootOverride);
+export async function backfillOrigin(sessionId: string, origin: SessionMeta["origin"], rootOverride?: string): Promise<void> {
+  const meta = await readSessionMeta(sessionId, rootOverride);
   if (!meta || meta.origin) return; // already set
-  await writeSessionMeta(id, { ...meta, origin }, rootOverride);
+  await writeSessionMeta(sessionId, { ...meta, origin }, rootOverride);
 }
 
-export async function backfillFirstUserMessage(id: string, message: string, rootOverride?: string): Promise<void> {
-  const meta = await readSessionMeta(id, rootOverride);
+export async function backfillFirstUserMessage(sessionId: string, message: string, rootOverride?: string): Promise<void> {
+  const meta = await readSessionMeta(sessionId, rootOverride);
   if (!meta || meta.firstUserMessage) return;
-  await writeSessionMeta(id, { ...meta, firstUserMessage: message }, rootOverride);
+  await writeSessionMeta(sessionId, { ...meta, firstUserMessage: message }, rootOverride);
 }
 
-export async function setClaudeSessionId(id: string, claudeSessionId: string, rootOverride?: string): Promise<void> {
-  const meta = await readSessionMeta(id, rootOverride);
+export async function setClaudeSessionId(sessionId: string, claudeSessionId: string, rootOverride?: string): Promise<void> {
+  const meta = await readSessionMeta(sessionId, rootOverride);
   if (!meta) return;
-  await writeSessionMeta(id, { ...meta, claudeSessionId }, rootOverride);
+  await writeSessionMeta(sessionId, { ...meta, claudeSessionId }, rootOverride);
 }
 
-export async function clearClaudeSessionId(id: string, rootOverride?: string): Promise<void> {
-  const meta = await readSessionMeta(id, rootOverride);
+export async function clearClaudeSessionId(sessionId: string, rootOverride?: string): Promise<void> {
+  const meta = await readSessionMeta(sessionId, rootOverride);
   if (!meta) return;
   const { claudeSessionId: __removed, ...rest } = meta;
-  await writeSessionMeta(id, rest, rootOverride);
+  await writeSessionMeta(sessionId, rest, rootOverride);
 }
 
-export async function updateHasUnread(id: string, hasUnread: boolean, rootOverride?: string): Promise<void> {
-  const meta = await readSessionMeta(id, rootOverride);
+export async function updateHasUnread(sessionId: string, hasUnread: boolean, rootOverride?: string): Promise<void> {
+  const meta = await readSessionMeta(sessionId, rootOverride);
   if (!meta) return;
-  await writeSessionMeta(id, { ...meta, hasUnread }, rootOverride);
+  await writeSessionMeta(sessionId, { ...meta, hasUnread }, rootOverride);
 }
 
 // ── Jsonl ───────────────────────────────────────────────────────
 
-export function sessionJsonlAbsPath(id: string, rootOverride?: string): string {
-  return resolvePath(root(rootOverride), jsonlRel(id));
+export function sessionJsonlAbsPath(sessionId: string, rootOverride?: string): string {
+  return resolvePath(root(rootOverride), jsonlRel(sessionId));
 }
 
 /**
@@ -115,12 +115,12 @@ export function sessionJsonlAbsPath(id: string, rootOverride?: string): string {
  * `hasUnread`, `roleId`, `startedAt`, `origin`, etc. Its mtime bumps
  * whenever any of those fields change via `writeSessionMeta`.
  */
-export function sessionMetaAbsPath(id: string, rootOverride?: string): string {
-  return resolvePath(root(rootOverride), metaRel(id));
+export function sessionMetaAbsPath(sessionId: string, rootOverride?: string): string {
+  return resolvePath(root(rootOverride), metaRel(sessionId));
 }
 
-export async function readSessionJsonl(id: string, rootOverride?: string): Promise<string | null> {
-  return readTextUnder(root(rootOverride), jsonlRel(id));
+export async function readSessionJsonl(sessionId: string, rootOverride?: string): Promise<string | null> {
+  return readTextUnder(root(rootOverride), jsonlRel(sessionId));
 }
 
 /**
@@ -130,7 +130,7 @@ export async function readSessionJsonl(id: string, rootOverride?: string): Promi
  * content and don't need to worry about line termination. This
  * prevents JSONL parse failures from missing newlines.
  */
-export async function appendSessionLine(id: string, line: string, rootOverride?: string): Promise<void> {
+export async function appendSessionLine(sessionId: string, line: string, rootOverride?: string): Promise<void> {
   const normalized = line.endsWith("\n") ? line : `${line}\n`;
-  await appendFile(resolvePath(root(rootOverride), jsonlRel(id)), normalized);
+  await appendFile(resolvePath(root(rootOverride), jsonlRel(sessionId)), normalized);
 }

package/server/utils/files/spreadsheet-store.ts

@@ -36,8 +36,8 @@ async function safeResolve(relativePath: string): Promise<string> {
 /** Save sheets array as a JSON file. Returns the workspace-relative path. */
 export async function saveSpreadsheet(sheets: unknown[]): Promise<string> {
   await ensureSpreadsheetsDir();
-  const id = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
-  const filename = `${id}.json`;
+  const sheetId = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+  const filename = `${sheetId}.json`;
   await fs.writeFile(path.join(SPREADSHEETS_DIR, filename), JSON.stringify(sheets), "utf-8");
   return path.posix.join(WORKSPACE_DIRS.spreadsheets, filename);
 }

package/server/utils/files/todos-io.ts

@@ -10,20 +10,20 @@ import { resolvePath } from "./workspace-io.js";
 import { loadJsonFile } from "./json.js";
 import { writeFileAtomicSync } from "./atomic.js";
 
-const root = (r?: string) => r ?? workspacePath;
+const root = (workspaceRoot?: string) => workspaceRoot ?? workspacePath;
 
-export function loadTodos<T>(fallback: T, r?: string): T {
-  return loadJsonFile(resolvePath(root(r), WORKSPACE_FILES.todosItems), fallback);
+export function loadTodos<T>(fallback: T, workspaceRoot?: string): T {
+  return loadJsonFile(resolvePath(root(workspaceRoot), WORKSPACE_FILES.todosItems), fallback);
 }
 
-export function saveTodos(items: unknown, r?: string): void {
-  writeFileAtomicSync(resolvePath(root(r), WORKSPACE_FILES.todosItems), JSON.stringify(items, null, 2));
+export function saveTodos(items: unknown, workspaceRoot?: string): void {
+  writeFileAtomicSync(resolvePath(root(workspaceRoot), WORKSPACE_FILES.todosItems), JSON.stringify(items, null, 2));
 }
 
-export function loadColumns<T>(fallback: T, r?: string): T {
-  return loadJsonFile(resolvePath(root(r), WORKSPACE_FILES.todosColumns), fallback);
+export function loadColumns<T>(fallback: T, workspaceRoot?: string): T {
+  return loadJsonFile(resolvePath(root(workspaceRoot), WORKSPACE_FILES.todosColumns), fallback);
 }
 
-export function saveColumns(columns: unknown, r?: string): void {
-  writeFileAtomicSync(resolvePath(root(r), WORKSPACE_FILES.todosColumns), JSON.stringify(columns, null, 2));
+export function saveColumns(columns: unknown, workspaceRoot?: string): void {
+  writeFileAtomicSync(resolvePath(root(workspaceRoot), WORKSPACE_FILES.todosColumns), JSON.stringify(columns, null, 2));
 }

package/server/utils/files/user-tasks-io.ts

@@ -11,15 +11,15 @@ import { resolvePath } from "./workspace-io.js";
 import { loadJsonFile } from "./json.js";
 import { writeFileAtomic } from "./atomic.js";
 
-const root = (r?: string) => r ?? workspacePath;
+const root = (workspaceRoot?: string) => workspaceRoot ?? workspacePath;
 
-export function loadUserTasks<T>(r?: string): T[] {
-  const tasks = loadJsonFile<T[]>(resolvePath(root(r), WORKSPACE_FILES.schedulerUserTasks), []);
+export function loadUserTasks<T>(workspaceRoot?: string): T[] {
+  const tasks = loadJsonFile<T[]>(resolvePath(root(workspaceRoot), WORKSPACE_FILES.schedulerUserTasks), []);
   return Array.isArray(tasks) ? tasks : [];
 }
 
-export async function saveUserTasks<T>(tasks: T[], r?: string): Promise<void> {
-  const filePath = resolvePath(root(r), WORKSPACE_FILES.schedulerUserTasks);
+export async function saveUserTasks<T>(tasks: T[], workspaceRoot?: string): Promise<void> {
+  const filePath = resolvePath(root(workspaceRoot), WORKSPACE_FILES.schedulerUserTasks);
   await mkdir(path.dirname(filePath), { recursive: true });
   await writeFileAtomic(filePath, JSON.stringify(tasks, null, 2));
 }

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

@@ -52,8 +52,8 @@ export async function readManifest(workspaceRoot: string): Promise<ChatIndexMani
 
 function isManifest(raw: unknown): raw is ChatIndexManifest {
   if (!isRecord(raw)) return false;
-  const o = raw as Record<string, unknown>;
-  return o.version === 1 && Array.isArray(o.entries);
+  const manifestRecord = raw as Record<string, unknown>;
+  return manifestRecord.version === 1 && Array.isArray(manifestRecord.entries);
 }
 
 // In-process mutex serializing the read-modify-write sequence on
@@ -64,7 +64,7 @@ function isManifest(raw: unknown): raw is ChatIndexManifest {
 // this module's single-process assumption.
 let manifestMutex: Promise<void> = Promise.resolve();
 
-async function withManifestLock<T>(fn: () => Promise<T>): Promise<T> {
+async function withManifestLock<T>(lockedFn: () => Promise<T>): Promise<T> {
   const prev = manifestMutex;
   let release: () => void = () => {};
   manifestMutex = new Promise<void>((resolve) => {
@@ -72,7 +72,7 @@ async function withManifestLock<T>(fn: () => Promise<T>): Promise<T> {
   });
   try {
     await prev;
-    return await fn();
+    return await lockedFn();
   } finally {
     release();
   }
@@ -83,12 +83,12 @@ async function withManifestLock<T>(fn: () => Promise<T>): Promise<T> {
 // already serializes callers within this process, but a unique
 // name means the rename can't collide even if a stray .tmp file
 // is left behind by a previous crashed run.
-async function writeManifestAtomic(workspaceRoot: string, m: ChatIndexManifest): Promise<void> {
+async function writeManifestAtomic(workspaceRoot: string, manifest: ChatIndexManifest): Promise<void> {
   // `uniqueTmp` belt-and-suspenders: the in-process mutex above
   // already serializes callers, but a unique tmp name means the
   // rename can't collide even if a stray .tmp file is left behind
   // by a previous crashed run.
-  await writeJsonAtomic(manifestPathFor(workspaceRoot), m, {
+  await writeJsonAtomic(manifestPathFor(workspaceRoot), manifest, {
     uniqueTmp: true,
   });
 }
@@ -117,9 +117,9 @@ export async function isFresh(workspaceRoot: string, sessionId: string, now: num
     if (!isRecord(entry)) return false;
     const indexedAt = (entry as Record<string, unknown>).indexedAt;
     if (typeof indexedAt !== "string") return false;
-    const ts = Date.parse(indexedAt);
-    if (Number.isNaN(ts)) return false;
-    return now - ts < minIntervalMs;
+    const indexedTimestamp = Date.parse(indexedAt);
+    if (Number.isNaN(indexedTimestamp)) return false;
+    return now - indexedTimestamp < minIntervalMs;
   } catch {
     return false;
   }
@@ -137,10 +137,10 @@ async function readSessionMeta(workspaceRoot: string, sessionId: string): Promis
     const raw = await readFile(sessionMetaPathFor(workspaceRoot, sessionId), "utf-8");
     const parsed: unknown = JSON.parse(raw);
     if (!isRecord(parsed)) return {};
-    const o = parsed as Record<string, unknown>;
+    const metaRecord = parsed as Record<string, unknown>;
     return {
-      roleId: typeof o.roleId === "string" ? o.roleId : undefined,
-      startedAt: typeof o.startedAt === "string" ? o.startedAt : undefined,
+      roleId: typeof metaRecord.roleId === "string" ? metaRecord.roleId : undefined,
+      startedAt: typeof metaRecord.startedAt === "string" ? metaRecord.startedAt : undefined,
     };
   } catch {
     return {};
@@ -152,7 +152,7 @@ async function readSessionMeta(workspaceRoot: string, sessionId: string): Promis
 export async function listSessionIds(workspaceRoot: string): Promise<string[]> {
   try {
     const files = await readdir(chatDirFor(workspaceRoot));
-    return files.filter((f) => f.endsWith(".jsonl")).map((f) => f.slice(0, -".jsonl".length));
+    return files.filter((fileName) => fileName.endsWith(".jsonl")).map((fileName) => fileName.slice(0, -".jsonl".length));
   } catch {
     return [];
   }
@@ -199,9 +199,9 @@ export async function indexSession(workspaceRoot: string, sessionId: string, dep
   // Upsert into manifest under the in-process lock: replace any
   // prior entry with the same id, sort newest-first by startedAt.
   await updateManifest(workspaceRoot, (current) => {
-    const filtered = current.entries.filter((e) => e.id !== sessionId);
+    const filtered = current.entries.filter((entryItem) => entryItem.id !== sessionId);
     filtered.push(entry);
-    filtered.sort((a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt));
+    filtered.sort((leftEntry, rightEntry) => Date.parse(rightEntry.startedAt) - Date.parse(leftEntry.startedAt));
     return { version: 1, entries: filtered };
   });
 

package/server/workspace/custom-dirs.ts

@@ -45,8 +45,8 @@ const CONTROL_CHAR_RE_G = /[\x00-\x1f]/g;
 
 // ── Validation ──────────────────────────────────────────────────
 
-function isValidStructure(v: unknown): v is DirStructure {
-  return v === DIR_STRUCTURES.flat || v === DIR_STRUCTURES.byName || v === DIR_STRUCTURES.byDate;
+function isValidStructure(value: unknown): value is DirStructure {
+  return value === DIR_STRUCTURES.flat || value === DIR_STRUCTURES.byName || value === DIR_STRUCTURES.byDate;
 }
 
 function validatePath(rawPath: string): string | null {
@@ -55,7 +55,7 @@ function validatePath(rawPath: string): string | null {
   const normalized = path.posix.normalize(rawPath);
 
   // Must start with allowed prefix
-  if (!ALLOWED_PREFIXES.some((p) => normalized.startsWith(p))) return null;
+  if (!ALLOWED_PREFIXES.some((prefix) => normalized.startsWith(prefix))) return null;
 
   // No path traversal
   if (normalized.includes("..")) return null;
@@ -64,7 +64,7 @@ function validatePath(rawPath: string): string | null {
   if (path.isAbsolute(normalized)) return null;
 
   // Not a reserved system directory
-  if (RESERVED_DIRS.some((r) => normalized === r || normalized.startsWith(r + "/"))) {
+  if (RESERVED_DIRS.some((reservedDir) => normalized === reservedDir || normalized.startsWith(reservedDir + "/"))) {
     return null;
   }
 
@@ -112,7 +112,7 @@ export function loadCustomDirs(root?: string): CustomDirEntry[] {
     const entries = parsed
       .slice(0, MAX_ENTRIES)
       .map(validateEntry)
-      .filter((e): e is CustomDirEntry => e !== null);
+      .filter((entry): entry is CustomDirEntry => entry !== null);
 
     const skipped = parsed.length - entries.length;
     if (skipped > 0) {
@@ -153,8 +153,8 @@ export function validateCustomDirs(raw: unknown): { entries: CustomDirEntry[] }
     if (entry) {
       entries.push(entry);
     } else {
-      const p = isRecord(item) ? String((item as Record<string, unknown>).path ?? "") : "";
-      errors.push(`entry ${i}: invalid path "${p}"`);
+      const itemPath = isRecord(item) ? String((item as Record<string, unknown>).path ?? "") : "";
+      errors.push(`entry ${i}: invalid path "${itemPath}"`);
     }
   });
   if (errors.length > 0) {
@@ -205,14 +205,14 @@ export function buildCustomDirsPrompt(entries: readonly CustomDirEntry[]): strin
     "",
   ];
 
-  for (const e of entries) {
+  for (const entry of entries) {
     const structureHint =
-      e.structure === DIR_STRUCTURES.byName
+      entry.structure === DIR_STRUCTURES.byName
         ? " (organize by name in subfolders)"
-        : e.structure === DIR_STRUCTURES.byDate
+        : entry.structure === DIR_STRUCTURES.byDate
           ? " (organize by date: YYYY/MM/DD/)"
           : "";
-    lines.push(`- \`${e.path}/\`${structureHint} — ${e.description}`);
+    lines.push(`- \`${entry.path}/\`${structureHint} — ${entry.description}`);
   }
 
   lines.push("");