mulmoclaude 0.1.2 → 0.4.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

@@ -6,7 +6,7 @@
 // Moved from server/utils/file.ts (issue #366 Phase 1). The old
 // file re-exports these for backwards compat.
 
-import fs from "fs";
+import { mkdirSync, promises, renameSync, unlinkSync, writeFileSync } from "fs";
 import path from "path";
 import { randomUUID } from "crypto";
 
@@ -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 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 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);
+      renameSync(fromPath, toPath);
       return;
     } catch (err) {
       if (!isTransientRenameError(err)) throw err;
       sleepSync(delayMs);
     }
   }
-  fs.renameSync(from, to);
+  renameSync(fromPath, toPath);
 }
 
 /**
@@ -90,15 +90,15 @@ function renameSyncWithWindowsRetry(from: string, to: string): void {
  */
 export async function writeFileAtomic(filePath: string, content: string, opts: WriteAtomicOptions = {}): Promise<void> {
   const tmp = opts.uniqueTmp ? `${filePath}.${randomUUID()}.tmp` : `${filePath}.tmp`;
-  await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+  await promises.mkdir(path.dirname(filePath), { recursive: true });
   try {
-    await fs.promises.writeFile(tmp, content, {
+    await promises.writeFile(tmp, content, {
       encoding: "utf-8",
       mode: opts.mode,
     });
     await renameWithWindowsRetry(tmp, filePath);
   } catch (err) {
-    await fs.promises.unlink(tmp).catch(() => {});
+    await promises.unlink(tmp).catch(() => {});
     throw err;
   }
 }
@@ -110,13 +110,13 @@ export async function writeFileAtomic(filePath: string, content: string, opts: W
  */
 export function writeFileAtomicSync(filePath: string, content: string, opts: WriteAtomicOptions = {}): void {
   const tmp = opts.uniqueTmp ? `${filePath}.${randomUUID()}.tmp` : `${filePath}.tmp`;
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  mkdirSync(path.dirname(filePath), { recursive: true });
   try {
-    fs.writeFileSync(tmp, content, { encoding: "utf-8", mode: opts.mode });
+    writeFileSync(tmp, content, { encoding: "utf-8", mode: opts.mode });
     renameSyncWithWindowsRetry(tmp, filePath);
   } catch (err) {
     try {
-      fs.unlinkSync(tmp);
+      unlinkSync(tmp);
     } catch {
       // best-effort cleanup
     }

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

@@ -1,4 +1,4 @@
-import fs from "fs/promises";
+import { mkdir, readFile, realpath, writeFile } from "fs/promises";
 import path from "path";
 import crypto from "crypto";
 import { WORKSPACE_DIRS, WORKSPACE_PATHS } from "../../workspace/paths.js";
@@ -12,8 +12,8 @@ let imagesDirReal: string | null = null;
 
 async function ensureImagesDir(): Promise<string> {
   if (imagesDirReal) return imagesDirReal;
-  await fs.mkdir(IMAGES_DIR, { recursive: true });
-  imagesDirReal = await fs.realpath(IMAGES_DIR);
+  await mkdir(IMAGES_DIR, { recursive: true });
+  imagesDirReal = await realpath(IMAGES_DIR);
   return imagesDirReal;
 }
 
@@ -35,23 +35,23 @@ 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"));
+  await writeFile(absPath, Buffer.from(base64Data, "base64"));
   return path.posix.join(WORKSPACE_DIRS.images, filename);
 }
 
 /** Overwrite an existing image file. The relativePath must start with "images/". */
 export async function overwriteImage(relativePath: string, base64Data: string): Promise<void> {
   const absPath = await safeResolve(relativePath);
-  await fs.writeFile(absPath, Buffer.from(base64Data, "base64"));
+  await writeFile(absPath, Buffer.from(base64Data, "base64"));
 }
 
 /** Read an image file and return raw base64 (no data URI prefix). */
 export async function loadImageBase64(relativePath: string): Promise<string> {
   const absPath = await safeResolve(relativePath);
-  const buf = await fs.readFile(absPath);
+  const buf = await readFile(absPath);
   return buf.toString("base64");
 }
 
@@ -64,3 +64,14 @@ export function stripDataUri(dataUri: string): string {
 export function isImagePath(value: string): boolean {
   return value.startsWith(`${WORKSPACE_DIRS.images}/`) && value.endsWith(".png");
 }
+
+/** Build the workspace-relative image path for a filename, or null
+ *  if the derived path wouldn't satisfy `isImagePath` (e.g. empty
+ *  name, wrong extension). Keeps route handlers from reaching for
+ *  `WORKSPACE_DIRS.images` directly — the images/ convention lives
+ *  in exactly one place. */
+export function imagePathFromFilename(filename: string): string | null {
+  if (!filename) return null;
+  const relativePath = path.posix.join(WORKSPACE_DIRS.images, filename);
+  return isImagePath(relativePath) ? relativePath : null;
+}

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

@@ -17,7 +17,7 @@ import { isEnoent } from "./safe.js";
 import { log } from "../../system/logger/index.js";
 import { summariesRoot, dailyPathFor, topicPathFor, TOPICS_DIR, INDEX_FILE, STATE_FILE, DAILY_DIR, ARCHIVE_DIR } from "../../workspace/journal/paths.js";
 
-import fs from "node:fs";
+import { statSync } from "node:fs";
 
 const root = (rootOverride?: string) => rootOverride ?? workspacePath;
 
@@ -26,7 +26,7 @@ const root = (rootOverride?: string) => rootOverride ?? workspacePath;
 export function journalStateExists(rootOverride?: string): boolean {
   const filePath = path.join(summariesRoot(root(rootOverride)), STATE_FILE);
   try {
-    fs.statSync(filePath);
+    statSync(filePath);
     return true;
   } catch {
     return false;
@@ -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/json.ts

@@ -3,7 +3,7 @@
 // Moved from server/utils/file.ts (issue #366 Phase 1). The old
 // file re-exports these for backwards compat.
 
-import fs from "fs";
+import { mkdirSync, promises, readFileSync, writeFileSync } from "fs";
 import path from "path";
 import { writeFileAtomic } from "./atomic.js";
 import { isEnoent } from "./safe.js";
@@ -20,7 +20,7 @@ import { log } from "../../system/logger/index.js";
 export function loadJsonFile<T>(filePath: string, defaultValue: T): T {
   let raw: string;
   try {
-    raw = fs.readFileSync(filePath, "utf-8");
+    raw = readFileSync(filePath, "utf-8");
   } catch (err) {
     if (isEnoent(err)) return defaultValue;
     log.error("json", "loadJsonFile read failed", {
@@ -41,8 +41,8 @@ export function loadJsonFile<T>(filePath: string, defaultValue: T): T {
 }
 
 export function saveJsonFile(filePath: string, data: unknown): void {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  mkdirSync(path.dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(data, null, 2));
 }
 
 // ── Async ───────────────────────────────────────────────────────
@@ -60,7 +60,7 @@ export async function writeJsonAtomic(filePath: string, data: unknown, opts: Par
  */
 export async function readJsonOrNull<T>(filePath: string): Promise<T | null> {
   try {
-    const content = await fs.promises.readFile(filePath, "utf-8");
+    const content = await promises.readFile(filePath, "utf-8");
     const parsed: T = JSON.parse(content);
     return parsed;
   } catch {

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

@@ -1,4 +1,4 @@
-import fs from "fs/promises";
+import { readFile, writeFile } from "fs/promises";
 import path from "path";
 import { workspacePath } from "../../workspace/workspace.js";
 import { WORKSPACE_DIRS } from "../../workspace/paths.js";
@@ -11,20 +11,20 @@ import { buildArtifactPathRandom } from "./naming.js";
  */
 export async function saveMarkdown(content: string, prefix: string): Promise<string> {
   const relPath = buildArtifactPathRandom(WORKSPACE_DIRS.markdowns, prefix, ".md", "document");
-  await fs.writeFile(path.join(workspacePath, relPath), content, "utf-8");
+  await writeFile(path.join(workspacePath, relPath), content, "utf-8");
   return relPath;
 }
 
 /** Read a markdown file and return its content. */
 export async function loadMarkdown(relativePath: string): Promise<string> {
   const absPath = path.join(workspacePath, relativePath);
-  return fs.readFile(absPath, "utf-8");
+  return readFile(absPath, "utf-8");
 }
 
 /** Overwrite an existing markdown file. */
 export async function overwriteMarkdown(relativePath: string, content: string): Promise<void> {
   const absPath = path.join(workspacePath, relativePath);
-  await fs.writeFile(absPath, content, "utf-8");
+  await writeFile(absPath, content, "utf-8");
 }
 
 /** Check if a string is a markdown file path (not inline content). */

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/reference-dirs-io.ts

@@ -4,7 +4,7 @@
 // All fs access is funneled through shared helpers so path changes
 // propagate from a single constant.
 
-import fs from "fs";
+import { mkdirSync, statSync } from "fs";
 import path from "path";
 import { WORKSPACE_DIRS, workspacePath } from "../../workspace/paths.js";
 import { loadJsonFile } from "./json.js";
@@ -31,14 +31,14 @@ export function readReferenceDirsJson(root?: string): unknown[] {
 /** Write reference-dirs.json atomically. Creates config/ if needed. */
 export function writeReferenceDirsJson(entries: readonly unknown[], root?: string): void {
   const filePath = configPath(root ?? workspacePath);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  mkdirSync(path.dirname(filePath), { recursive: true });
   writeFileAtomicSync(filePath, JSON.stringify(entries, null, 2));
 }
 
 /** Check whether a host path exists and is a directory. */
 export function isExistingDirectory(hostPath: string): boolean {
   try {
-    return fs.statSync(hostPath).isDirectory();
+    return statSync(hostPath).isDirectory();
   } catch {
     return false;
   }

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

@@ -4,22 +4,22 @@
 // Optional `root` for test DI.
 
 import path from "node:path";
-import fs from "node:fs";
+import { mkdirSync, statSync, unlinkSync } from "node:fs";
 import { WORKSPACE_DIRS } from "../../workspace/paths.js";
 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));
+    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));
+    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);
-  fs.mkdirSync(dir, { recursive: true });
-  writeFileAtomicSync(roleFilePath(id, r), JSON.stringify(data, null, 2));
+export function saveRole(roleId: string, data: unknown, workspaceRoot?: string): void {
+  const dir = path.join(root(workspaceRoot), WORKSPACE_DIRS.roles);
+  mkdirSync(dir, { recursive: true });
+  writeFileAtomicSync(roleFilePath(roleId, workspaceRoot), JSON.stringify(data, null, 2));
 }

package/server/utils/files/safe.ts

@@ -7,7 +7,7 @@
 // Moved from server/utils/fs.ts (issue #366 Phase 1). The old
 // file re-exports these for backwards compat.
 
-import fs from "fs";
+import { Dirent, Stats, promises, readFileSync, readdirSync, realpathSync, statSync } from "fs";
 import path from "path";
 import { isErrorWithCode } from "../types.js";
 
@@ -19,7 +19,7 @@ export function isEnoent(err: unknown): boolean {
 /** Read a binary file by absolute path. Null on ENOENT. */
 export function readBinarySafeSync(absPath: string): Buffer | null {
   try {
-    return fs.readFileSync(absPath);
+    return readFileSync(absPath);
   } catch {
     return null;
   }
@@ -28,7 +28,7 @@ export function readBinarySafeSync(absPath: string): Buffer | null {
 /** Read a text file by absolute path (async). Null on ENOENT. */
 export async function readTextSafe(absPath: string): Promise<string | null> {
   try {
-    return await fs.promises.readFile(absPath, "utf-8");
+    return await promises.readFile(absPath, "utf-8");
   } catch {
     return null;
   }
@@ -37,39 +37,39 @@ export async function readTextSafe(absPath: string): Promise<string | null> {
 /** Read a text file by absolute path (sync). Null on ENOENT. */
 export function readTextSafeSync(absPath: string): string | null {
   try {
-    return fs.readFileSync(absPath, "utf-8");
+    return readFileSync(absPath, "utf-8");
   } catch {
     return null;
   }
 }
 
-export function statSafe(absPath: string): fs.Stats | null {
+export function statSafe(absPath: string): Stats | null {
   try {
-    return fs.statSync(absPath);
+    return statSync(absPath);
   } catch {
     return null;
   }
 }
 
-export async function statSafeAsync(absPath: string): Promise<fs.Stats | null> {
+export async function statSafeAsync(absPath: string): Promise<Stats | null> {
   try {
-    return await fs.promises.stat(absPath);
+    return await promises.stat(absPath);
   } catch {
     return null;
   }
 }
 
-export function readDirSafe(absPath: string): fs.Dirent[] {
+export function readDirSafe(absPath: string): Dirent[] {
   try {
-    return fs.readdirSync(absPath, { withFileTypes: true });
+    return readdirSync(absPath, { withFileTypes: true });
   } catch {
     return [];
   }
 }
 
-export async function readDirSafeAsync(absPath: string): Promise<fs.Dirent[]> {
+export async function readDirSafeAsync(absPath: string): Promise<Dirent[]> {
   try {
-    return await fs.promises.readdir(absPath, { withFileTypes: true });
+    return await promises.readdir(absPath, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -77,7 +77,7 @@ export async function readDirSafeAsync(absPath: string): Promise<fs.Dirent[]> {
 
 export async function readTextOrNull(file: string): Promise<string | null> {
   try {
-    return await fs.promises.readFile(file, "utf-8");
+    return await promises.readFile(file, "utf-8");
   } catch {
     return null;
   }
@@ -95,7 +95,7 @@ export function resolveWithinRoot(rootReal: string, relPath: string): string | n
   const resolved = path.resolve(rootReal, normalized);
   let resolvedReal: string;
   try {
-    resolvedReal = fs.realpathSync(resolved);
+    resolvedReal = realpathSync(resolved);
   } catch {
     return null;
   }

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/scheduler-overrides-io.ts

@@ -4,7 +4,7 @@
 // system task ID (e.g. "system:journal"), value overrides the
 // default schedule.
 
-import fs from "fs";
+import { mkdirSync } from "fs";
 import path from "path";
 import { workspacePath } from "../../workspace/paths.js";
 import { WORKSPACE_FILES } from "../../../src/config/workspacePaths.js";
@@ -59,6 +59,6 @@ export function loadSchedulerOverrides(root?: string): ScheduleOverrides {
 /** Save schedule overrides atomically. Creates directory if needed. */
 export function saveSchedulerOverrides(overrides: ScheduleOverrides, root?: string): void {
   const filePath = overridesPath(root);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  mkdirSync(path.dirname(filePath), { recursive: true });
   writeFileAtomicSync(filePath, JSON.stringify(overrides, null, 2));
 }