mulmoclaude 1.2.0 → 1.3.0

package/server/api/routes/wiki/history.ts

@@ -17,7 +17,7 @@ import { randomUUID } from "node:crypto";
 import { TOOL_NAMES } from "../../../../src/config/toolNames.js";
 import { hasMeaningfulChange, writeWikiPage } from "../../../workspace/wiki-pages/io.js";
 import { WORKSPACE_DIRS } from "../../../workspace/paths.js";
-import { isSafeStamp, listSnapshots, readSnapshot, stripSnapshotMeta } from "../../../workspace/wiki-pages/snapshot.js";
+import { isSafeStamp, listSnapshots, readSnapshot, stripSnapshotMeta, type SnapshotContent } from "../../../workspace/wiki-pages/snapshot.js";
 import { mergeFrontmatter, serializeWithFrontmatter } from "../../../utils/markdown/frontmatter.js";
 import { badRequest, notFound } from "../../../utils/httpError.js";
 import { readTextOrNull } from "../../../utils/files/safe.js";
@@ -66,39 +66,37 @@ router.get("/pages/:slug/history", async (req: Request<{ slug: string }>, res: R
   res.json({ slug, snapshots });
 });
 
-router.get("/pages/:slug/history/:stamp", async (req: Request<{ slug: string; stamp: string }>, res: Response) => {
+// Validate `:slug`/`:stamp` and load the snapshot, or respond (400 for
+// an unsafe param, 404 for a missing snapshot) and return null. Shared
+// by the read and restore routes so the guard lives in one place.
+async function resolveSnapshotOr4xx(req: Request<{ slug: string; stamp: string }>, res: Response): Promise<SnapshotContent | null> {
   const { slug, stamp } = req.params;
   if (!isSafeSlug(slug)) {
     badRequest(res, "Unsafe slug");
-    return;
+    return null;
   }
   if (!isSafeStamp(stamp)) {
     badRequest(res, "Unsafe stamp");
-    return;
+    return null;
   }
   const snapshot = await readSnapshot(slug, stamp);
   if (snapshot === null) {
     notFound(res, `snapshot not found: ${slug}/${stamp}`);
-    return;
+    return null;
   }
-  res.json({ slug, snapshot });
+  return snapshot;
+}
+
+router.get("/pages/:slug/history/:stamp", async (req: Request<{ slug: string; stamp: string }>, res: Response) => {
+  const snapshot = await resolveSnapshotOr4xx(req, res);
+  if (!snapshot) return;
+  res.json({ slug: req.params.slug, snapshot });
 });
 
 router.post("/pages/:slug/history/:stamp/restore", async (req: Request<{ slug: string; stamp: string }>, res: Response) => {
+  const snapshot = await resolveSnapshotOr4xx(req, res);
+  if (!snapshot) return;
   const { slug, stamp } = req.params;
-  if (!isSafeSlug(slug)) {
-    badRequest(res, "Unsafe slug");
-    return;
-  }
-  if (!isSafeStamp(stamp)) {
-    badRequest(res, "Unsafe stamp");
-    return;
-  }
-  const snapshot = await readSnapshot(slug, stamp);
-  if (snapshot === null) {
-    notFound(res, `snapshot not found: ${slug}/${stamp}`);
-    return;
-  }
 
   // Strip `_snapshot_*` keys before writing — they describe the
   // *original* save event and would be misleading on the restored

package/server/events/collection-change.ts

@@ -63,8 +63,3 @@ export function initCollectionChangePublisher(instance: IPubSub): void {
     }
   });
 }
-
-/** Detach the publisher (test teardown). No-op against an older package. */
-export function _resetCollectionChangePublisherForTesting(): void {
-  resolveSetPublisher()?.(null);
-}

package/server/events/file-change.ts

@@ -11,7 +11,7 @@
 // publisher; we hand those to the package as the primary channel + normaliser.
 
 import type { IPubSub } from "./pub-sub/index.js";
-import { configureFileChangePublisher, publishFileChange, resetFileChangePublisher } from "@mulmoclaude/core/file-change";
+import { configureFileChangePublisher, publishFileChange } from "@mulmoclaude/core/file-change";
 import { fileChannel, toPosixWorkspacePath } from "../../src/config/pubsubChannels.js";
 import { isMarkdownPath } from "../utils/files/markdown-store.js";
 import { isHtmlPath } from "../utils/files/html-store.js";
@@ -48,8 +48,3 @@ export function initFileChangePublisher(instance: IPubSub): void {
     warn: (message, data) => log.warn("file-change", message, data),
   });
 }
-
-/** Test-only — clear the module singleton so each test starts clean. */
-export function _resetFileChangePublisherForTesting(): void {
-  resetFileChangePublisher();
-}

package/server/index.ts

@@ -75,6 +75,10 @@ import { readSessionJsonl, readSessionMeta } from "./utils/files/session-io.js";
 import { resolveBridgeSessionRole } from "./api/bridge/sessionRole.js";
 import { onSessionEvent, initSessionStore } from "./events/session-store/index.js";
 import { initFileChangePublisher } from "./events/file-change.js";
+// Importing also binds the shared mulmoScript server ops to this host's
+// backend and registers the built-in "mulmoScript" dispatch handler (side
+// effect at module load — plans/feat-mulmoscript-plugin.md phase 3).
+import { initMulmoScriptGenerationPublisher } from "./plugins/mulmoscript-server.js";
 import { initCollectionChangePublisher } from "./events/collection-change.js";
 import { getRole, loadAllRoles } from "./workspace/roles.js";
 import { discoverSkills } from "./workspace/skills/index.js";
@@ -93,8 +97,7 @@ import { migrateCookingRecipesFromPlugin } from "./workspace/cooking-recipes/mig
 import { env, isAblated, isGeminiAvailable } from "./system/env.js";
 import { buildSandboxStatus } from "./api/sandboxStatus.js";
 import { existsSync, readFileSync } from "fs";
-import { realpath as fsRealpath } from "fs/promises";
-import { containsDotfileSegment, resolveWithinRoot } from "./utils/files/safe.js";
+import { makeCachedRealpath, resolveArtifactRequestPath } from "./utils/files/safe.js";
 import { cpus, loadavg } from "os";
 import { isDockerAvailable, ensureSandboxImage } from "./system/docker.js";
 import { maybeRunJournal } from "./workspace/journal/index.js";
@@ -351,17 +354,7 @@ app.use("/api", (req, res, next) => {
 //  3. `dotfiles: deny` + `fallthrough: false` on `express.static`
 //     itself, plus its built-in `..` normalize for path traversal.
 const IMAGE_EXT_RE = /\.(png|jpe?g|webp|gif|svg|mp4|webm|mov|m4v|ogv|mp3|ogg|oga|wav|m4a|aac)$/i;
-let imagesDirReal: string | null = null;
-async function getImagesDirReal(): Promise<string | null> {
-  if (imagesDirReal) return imagesDirReal;
-  try {
-    imagesDirReal = await fsRealpath(WORKSPACE_PATHS.images);
-    return imagesDirReal;
-  } catch {
-    // Dir not yet materialised (fresh workspace, no image saved).
-    return null;
-  }
-}
+const getImagesDirReal = makeCachedRealpath(WORKSPACE_PATHS.images);
 app.use(
   "/artifacts/images",
   async (req, res, next) => {
@@ -374,17 +367,9 @@ app.use(
       res.status(404).end();
       return;
     }
-    let relPath: string;
-    try {
-      // decodeURIComponent throws URIError on malformed escapes
-      // (`%ZZ`, stray `%`). Fail closed so a junk URL returns 404
-      // instead of bubbling a 500 out of the express error chain.
-      relPath = decodeURIComponent(req.path.replace(/^\//, ""));
-    } catch {
-      res.status(404).end();
-      return;
-    }
-    if (!resolveWithinRoot(root, relPath)) {
+    // No explicit dotfile check here: this mount never short-circuits,
+    // so `express.static`'s `dotfiles: "deny"` below is the authority.
+    if (resolveArtifactRequestPath(root, req.path, false) === null) {
       res.status(404).end();
       return;
     }
@@ -440,16 +425,7 @@ app.use(
 // eslint-disable-next-line sonarjs/regex-complexity -- flat extension allowlist with no nested quantifiers, ReDoS-safe; complexity is just the disjunction count
 const HTML_PREVIEW_EXT_RE = /\.(html?|png|jpe?g|webp|gif|svg|ico|mp4|webm|mov|m4v|ogv|mp3|ogg|oga|wav|m4a|aac)$/i;
 const HTML_DOCUMENT_EXT_RE = /\.html?$/i;
-let htmlsDirReal: string | null = null;
-async function getHtmlsDirReal(): Promise<string | null> {
-  if (htmlsDirReal) return htmlsDirReal;
-  try {
-    htmlsDirReal = await fsRealpath(WORKSPACE_PATHS.htmls);
-    return htmlsDirReal;
-  } catch {
-    return null;
-  }
-}
+const getHtmlsDirReal = makeCachedRealpath(WORKSPACE_PATHS.htmls);
 
 // Honour `X-Forwarded-*` so dev (Vite proxies `/artifacts/html` →
 // `localhost:3001` with `changeOrigin: true`) emits the browser-
@@ -488,26 +464,13 @@ app.use(
       res.status(404).end();
       return;
     }
-    let relPath: string;
-    try {
-      relPath = decodeURIComponent(req.path.replace(/^\//, ""));
-    } catch {
-      res.status(404).end();
-      return;
-    }
-    if (!resolveWithinRoot(root, relPath)) {
-      res.status(404).end();
-      return;
-    }
-    // Dotfile deny — `express.static` below enforces this for the
-    // non-HTML branch via `dotfiles: "deny"`, but the HTML short-
-    // circuit added in #1056 was bypassing the guard and would
-    // happily serve `/artifacts/html/.hidden.html` (Codex review on
-    // #1056). Apply the same policy uniformly so both branches
-    // refuse any path component starting with `.`. The helper
-    // splits on both `/` and `\` so an encoded backslash (`%5C`)
-    // can't sneak a `dir\.hidden.html` past the check on Windows.
-    if (containsDotfileSegment(relPath)) {
+    // denyDotfiles: the HTML short-circuit below serves the file itself
+    // (bypassing `express.static`'s `dotfiles: "deny"`), so this mount
+    // must reject dotfile segments in the guard — without it,
+    // `/artifacts/html/.hidden.html` would be served (Codex review on
+    // #1056).
+    const relPath = resolveArtifactRequestPath(root, req.path, true);
+    if (relPath === null) {
       res.status(404).end();
       return;
     }
@@ -560,16 +523,7 @@ const SVG_RESPONSE_CSP = "default-src 'none'; style-src 'unsafe-inline'; img-src
 // `<img src>` request can't carry an Authorization header. Loopback-
 // only listener + `requireSameOrigin` remain the trust boundary.
 const SVG_EXT_RE = /\.svg$/i;
-let svgsDirReal: string | null = null;
-async function getSvgsDirReal(): Promise<string | null> {
-  if (svgsDirReal) return svgsDirReal;
-  try {
-    svgsDirReal = await fsRealpath(WORKSPACE_PATHS.svgs);
-    return svgsDirReal;
-  } catch {
-    return null;
-  }
-}
+const getSvgsDirReal = makeCachedRealpath(WORKSPACE_PATHS.svgs);
 app.use(
   "/artifacts/svg",
   async (req, res, next) => {
@@ -582,18 +536,10 @@ app.use(
       res.status(404).end();
       return;
     }
-    let relPath: string;
-    try {
-      relPath = decodeURIComponent(req.path.replace(/^\//, ""));
-    } catch {
-      res.status(404).end();
-      return;
-    }
-    if (!resolveWithinRoot(root, relPath)) {
-      res.status(404).end();
-      return;
-    }
-    if (containsDotfileSegment(relPath)) {
+    // denyDotfiles for the same reason as the html mount: this handler
+    // sets headers and serves via a bearer-bypassed <img> path, so the
+    // dotfile guard can't be left solely to `express.static`.
+    if (resolveArtifactRequestPath(root, req.path, true) === null) {
       res.status(404).end();
       return;
     }
@@ -1125,6 +1071,9 @@ function initEventPublishers(pubsub: IPubSub): void {
   // near the route mount; only the pub/sub instance is wired here.
   initAccountingEventPublisher(pubsub);
   initCollectionChangePublisher(pubsub);
+  // MulmoScript generation events → plugin pubsub channel (the extracted
+  // presentMulmoScript View's spinner/reload signal).
+  initMulmoScriptGenerationPublisher(pubsub);
 }
 
 // System task defs + user-configurable schedule overrides. Split out

package/server/plugins/diagnostics.ts

@@ -123,12 +123,6 @@ export function collectPluginMetaDiagnostics(): readonly PluginMetaDiagnostic[]
   return cachedDiagnostics;
 }
 
-/** Reset the cache. Test-only — production code calls
- *  `collectPluginMetaDiagnostics()` once at boot. */
-export function resetPluginMetaDiagnosticsCacheForTest(): void {
-  cachedDiagnostics = null;
-}
-
 /** Run at server boot after the notifier engine is initialized.
  *  Logs every diagnostic via `log.warn` and publishes one notification
  *  per item so the bell shows them. Dedupes against the engine's

package/server/plugins/mulmoscript-server.ts

@@ -0,0 +1,58 @@
+// MulmoClaude's binding of the shared mulmoScript server ops (phase 3 of
+// plans/feat-mulmoscript-plugin.md). The mulmocast orchestration, realpath
+// containment, dispatch routing, and generation tracking all live in
+// @mulmoclaude/mulmoscript-plugin/server; this module supplies the
+// host-specific backend — stories location, artifacts FileOps, hardened
+// atomic writes, the ffmpeg probe, the logger, and the generation fan-out
+// (session `pendingGenerations` channel + plugin pubsub) — and registers
+// the built-in "mulmoScript" dispatch handler. Imported for side effect at
+// boot (server/index.ts); the REST routes in api/routes/mulmo-script.ts
+// consume the same instance.
+
+import path from "path";
+import { createMulmoScriptServerOps, createMulmoScriptDispatchHandler, GENERATION_EVENT } from "@mulmoclaude/mulmoscript-plugin/server";
+import { WORKSPACE_PATHS } from "../workspace/paths.js";
+import { writeFileAtomic } from "../utils/files/atomic.js";
+import { depStatus } from "../system/optionalDeps.js";
+import { log } from "../system/logger/index.js";
+import { publishGeneration } from "../events/session-store/index.js";
+import type { IPubSub } from "../events/pub-sub/index.js";
+import { makeArtifactsFileOps, pluginChannelName } from "./runtime.js";
+import { registerBuiltinDispatch } from "./builtin-dispatch.js";
+
+/** Scope name — matches `wrapWithScope("mulmoScript", …)` in
+ *  `src/plugins/presentMulmoScript/index.ts`, which is what the View's
+ *  `useRuntime().dispatch` / `pubsub` use as the plugin namespace. */
+const MULMOSCRIPT_SCOPE = "mulmoScript";
+
+let pubsubInstance: IPubSub | null = null;
+
+export const mulmoScriptOps = createMulmoScriptServerOps({
+  storiesDir: path.resolve(WORKSPACE_PATHS.stories),
+  artifacts: makeArtifactsFileOps(),
+  writeFileAtomic: async (absolutePath, data) => {
+    await writeFileAtomic(absolutePath, typeof data === "string" ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength));
+  },
+  isFfmpegAvailable: () => depStatus("ffmpeg")?.available,
+  // Edge-triggered by the package's tracker: fan each transition out to
+  // the per-session pendingGenerations channel (sidebar indicator;
+  // no-ops without a session) AND the plugin pubsub channel the
+  // extracted View subscribes to for spinners + reload-on-finish.
+  onGenerationEvent: (chatSessionId, event) => {
+    publishGeneration(chatSessionId, event.kind, event.filePath, event.key, event.done, event.error);
+    pubsubInstance?.publish(pluginChannelName(MULMOSCRIPT_SCOPE, GENERATION_EVENT), event);
+  },
+  log: {
+    info: (message, data) => log.info("mulmo-script", message, data),
+    warn: (message, data) => log.warn("mulmo-script", message, data),
+    error: (message, data) => log.error("mulmo-script", message, data),
+  },
+});
+
+registerBuiltinDispatch(MULMOSCRIPT_SCOPE, createMulmoScriptDispatchHandler(mulmoScriptOps));
+
+/** Wired at boot (initEventPublishers) — publishes before this are
+ *  session-only. */
+export function initMulmoScriptGenerationPublisher(instance: IPubSub): void {
+  pubsubInstance = instance;
+}

package/server/prompts/system/system.md

@@ -42,11 +42,11 @@ Raw HTML tags work inside `.md` files too — use them when markdown's `![]()` c
 
 ## Attached file marker
 
-When a user message starts with one or more lines of the form
+When a user message carries one or more lines of the form
 
 `[Attached file: <workspace-relative-path>]`
 
-the user has attached / pasted / dropped a file (or selected one in the UI) for this turn. **Each line is one file** — when the user attaches multiple files in the same turn, you will see multiple consecutive marker lines, in declaration order, before the user's actual message text. Every path always points at a real workspace file:
+the user has attached / pasted / dropped a file (or selected one in the UI) for this turn. **Each line is one file** — when the user attaches multiple files in the same turn, you will see multiple consecutive marker lines, in declaration order. They usually sit before the user's actual message text, but on a slash-command turn they follow it (so the leading `/` stays at the very start for command resolution). Every path always points at a real workspace file:
 
 - `data/attachments/YYYY/MM/<id>.<ext>` — paste/drop/file-picker uploads. The extension reflects the actual format (`.png`, `.pdf`, `.docx`, `.xlsx`, `.txt`, etc.). PPTX uploads are converted server-side and the path you receive is the resulting `.pdf`; the original `.pptx` lives next to it under the same `<id>` if you ever need to inspect it.
 - `artifacts/images/YYYY/MM/<id>.png` — a generated / canvas / edited image the user selected from the sidebar.

package/server/remoteHost/handlers/getCollection.ts

@@ -7,13 +7,14 @@
 //
 // Factory (createGetCollection) keeps the mapping unit-testable with the engine
 // stubbed; the default export wires the real engine functions.
-import { listItems, loadCollection, toDetail } from "../../workspace/collections/index.js";
+import { loadCollection, storeFor, toDetail, type CollectionItem, type LoadedCollection } from "../../workspace/collections/index.js";
 import type { CommandHandler, JsonObject } from "../commandChannel.js";
 import { clampLimit, clampOffset, deriveItems, pageResult } from "./collectionPage.js";
 
 export interface GetCollectionDeps {
   loadCollection: typeof loadCollection;
-  listItems: typeof listItems;
+  /** Store-aware records loader (file records or a dataSource CSV's rows). */
+  listRecords: (collection: LoadedCollection) => Promise<CollectionItem[]>;
   toDetail: typeof toDetail;
 }
 
@@ -25,8 +26,8 @@ export const createGetCollection =
     const limit = clampLimit(params.limit);
     const collection = await deps.loadCollection(slug);
     if (!collection) throw new Error(`collection '${slug}' not found`);
-    const all = deriveItems(collection.schema, await deps.listItems(collection.dataDir));
+    const all = deriveItems(collection.schema, await deps.listRecords(collection));
     return pageResult(deps.toDetail(collection), all, offset, limit);
   };
 
-export const getCollection = createGetCollection({ loadCollection, listItems, toDetail });
+export const getCollection = createGetCollection({ loadCollection, listRecords: (collection) => storeFor(collection).list(), toDetail });

package/server/remoteHost/handlers/googleCalendar.ts

@@ -8,17 +8,22 @@
 import {
   createCalendarEvent,
   DEFAULT_LIST_MAX_RESULTS,
+  getCalendarColors,
   getGoogleAccessToken,
   isIsoDateTimeWithOffset,
   listCalendarEvents,
+  listCalendars,
   MAX_LIST_RESULTS,
+  type CalendarColorEntry,
 } from "@mulmoclaude/core/google";
-import type { CommandHandler, JsonObject } from "../commandChannel.js";
+import type { CommandHandler, JsonObject, JsonValue } from "../commandChannel.js";
 
 export interface GoogleCalendarDeps {
   getAccessToken: typeof getGoogleAccessToken;
   createEvent: typeof createCalendarEvent;
   listEvents: typeof listCalendarEvents;
+  listCalendars: typeof listCalendars;
+  getColors: typeof getCalendarColors;
 }
 
 const requiredString = (params: JsonObject, key: string): string => {
@@ -27,6 +32,15 @@ const requiredString = (params: JsonObject, key: string): string => {
   return value;
 };
 
+const optionalString = (params: JsonObject, key: string): string | undefined => {
+  const value = params[key];
+  if (value === undefined || value === null) return undefined;
+  if (typeof value !== "string" || value.trim() === "") throw new Error(`${key} must be a non-empty string`);
+  // Return trimmed so whitespace can't reach the Google API (matches the
+  // plugin's Zod .trim() normalization).
+  return value.trim();
+};
+
 // Calendar's `dateTime`/`timeMin` are RFC3339 and reject date-only,
 // offset-less, or impossible values with an opaque 400, so the strict shared
 // validator runs here where the remote gets an actionable message.
@@ -47,6 +61,14 @@ const clampMaxResults = (value: unknown): number => {
   return Math.min(Math.max(value, 1), MAX_LIST_RESULTS);
 };
 
+// Spread rebuilds an anonymous object type — the named CalendarColorEntry
+// interface (no index signature) can't satisfy the channel's structural
+// JsonValue directly (same constraint as CalendarEventSummary).
+const toColorMapJson = (map: Record<string, CalendarColorEntry>): JsonObject =>
+  Object.fromEntries(
+    Object.entries(map).map(([colorId, entry]): [string, JsonValue] => [colorId, { background: entry.background, foreground: entry.foreground }]),
+  );
+
 export const createGoogleCalendarCreateEvent =
   (deps: GoogleCalendarDeps): CommandHandler =>
   async (params: JsonObject) => {
@@ -55,6 +77,8 @@ export const createGoogleCalendarCreateEvent =
       startDateTime: asDateTime(requiredString(params, "start"), "start"),
       endDateTime: asDateTime(requiredString(params, "end"), "end"),
       description: typeof params.description === "string" ? params.description : undefined,
+      calendarId: optionalString(params, "calendarId"),
+      colorId: optionalString(params, "colorId"),
     };
     const event = await deps.createEvent(await deps.getAccessToken(), input);
     // Spread rebuilds an anonymous object type — the CalendarEventSummary
@@ -68,10 +92,33 @@ export const createGoogleCalendarListEvents =
   async (params: JsonObject) => {
     const timeMin = optionalDateTime(params, "timeMin");
     const maxResults = clampMaxResults(params.maxResults);
-    const events = await deps.listEvents(await deps.getAccessToken(), { timeMin, maxResults });
+    const calendarId = optionalString(params, "calendarId");
+    const events = await deps.listEvents(await deps.getAccessToken(), { timeMin, maxResults, calendarId });
     return { events: events.map((event) => ({ ...event })) };
   };
 
-const deps: GoogleCalendarDeps = { getAccessToken: getGoogleAccessToken, createEvent: createCalendarEvent, listEvents: listCalendarEvents };
+export const createGoogleCalendarListCalendars =
+  (deps: GoogleCalendarDeps): CommandHandler =>
+  async () => {
+    const calendars = await deps.listCalendars(await deps.getAccessToken());
+    return { calendars: calendars.map((calendar) => ({ ...calendar })) };
+  };
+
+export const createGoogleCalendarColors =
+  (deps: GoogleCalendarDeps): CommandHandler =>
+  async () => {
+    const colors = await deps.getColors(await deps.getAccessToken());
+    return { colors: { event: toColorMapJson(colors.event), calendar: toColorMapJson(colors.calendar) } };
+  };
+
+const deps: GoogleCalendarDeps = {
+  getAccessToken: getGoogleAccessToken,
+  createEvent: createCalendarEvent,
+  listEvents: listCalendarEvents,
+  listCalendars,
+  getColors: getCalendarColors,
+};
 export const googleCalendarCreateEvent = createGoogleCalendarCreateEvent(deps);
 export const googleCalendarListEvents = createGoogleCalendarListEvents(deps);
+export const googleCalendarListCalendars = createGoogleCalendarListCalendars(deps);
+export const googleCalendarColors = createGoogleCalendarColors(deps);

package/server/remoteHost/handlers/index.ts

@@ -6,7 +6,7 @@ import { getCollection } from "./getCollection.js";
 import { getFeed } from "./getFeed.js";
 import { getRemoteView } from "./getRemoteView.js";
 import { getRemoteViewItems } from "./getRemoteViewItems.js";
-import { googleCalendarCreateEvent, googleCalendarListEvents } from "./googleCalendar.js";
+import { googleCalendarColors, googleCalendarCreateEvent, googleCalendarListCalendars, googleCalendarListEvents } from "./googleCalendar.js";
 import { listAccountingBooks } from "./listAccountingBooks.js";
 import { listCollections } from "./listCollections.js";
 import { listFeeds } from "./listFeeds.js";
@@ -29,4 +29,6 @@ export const handlers: CommandHandlers = {
   startChat,
   "google.calendar.createEvent": googleCalendarCreateEvent,
   "google.calendar.listEvents": googleCalendarListEvents,
+  "google.calendar.listCalendars": googleCalendarListCalendars,
+  "google.calendar.colors": googleCalendarColors,
 };

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

@@ -1,20 +1,6 @@
-import path from "path";
-import { workspacePath } from "../../workspace/workspace.js";
 import { WORKSPACE_DIRS } from "../../workspace/paths.js";
-import { writeFileAtomic } from "./atomic.js";
 import { makePathValidator } from "./path-validator.js";
 
-// Strict — overwriteHtml's path.join doesn't normalize traversal, so this gate is the primary defence.
+// The sole guard on html-store paths: `path.join` elsewhere doesn't normalize
+// traversal, so callers must pre-check writes with this validator.
 export const isHtmlPath = makePathValidator({ prefix: WORKSPACE_DIRS.htmls, ext: ".html" });
-
-// Defense in depth (matches `overwriteSvg`): if a caller forgets to
-// pre-check via `isHtmlPath`, `path.join(workspacePath, relativePath)`
-// would silently produce a traversal escape. The re-check inside the
-// write closes that trust chain.
-export async function overwriteHtml(relativePath: string, content: string): Promise<void> {
-  if (!isHtmlPath(relativePath)) {
-    throw new Error(`invalid html path: ${relativePath}`);
-  }
-  const absPath = path.join(workspacePath, relativePath);
-  await writeFileAtomic(absPath, content);
-}

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

@@ -7,20 +7,8 @@ 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 { statSync } from "node:fs";
-
 const root = (rootOverride?: string) => rootOverride ?? workspacePath;
 
-export function journalStateExists(rootOverride?: string): boolean {
-  const filePath = path.join(summariesRoot(root(rootOverride)), STATE_FILE);
-  try {
-    statSync(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 export async function readJournalState<T>(fallback: T, rootOverride?: string): Promise<T> {
   const filePath = path.join(summariesRoot(root(rootOverride)), STATE_FILE);
   try {

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

@@ -15,10 +15,9 @@
 // written ledger never bricks server boot. Writes go through the
 // atomic helper, so a crashed install can't leave a corrupt file.
 
-import { existsSync } from "node:fs";
-import { mkdir, readFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { loadJsonFile, writeJsonAtomic } from "./json.js";
+import { loadJsonFile } from "./json.js";
 import { WORKSPACE_PATHS } from "../../workspace/paths.js";
 
 export interface LedgerEntry {
@@ -49,14 +48,6 @@ export function readLedger(): LedgerEntry[] {
   return sanitiseLedger(raw);
 }
 
-export async function writeLedger(entries: readonly LedgerEntry[]): Promise<void> {
-  const dir = path.dirname(WORKSPACE_PATHS.pluginsLedger);
-  if (!existsSync(dir)) {
-    await mkdir(dir, { recursive: true });
-  }
-  await writeJsonAtomic(WORKSPACE_PATHS.pluginsLedger, [...entries]);
-}
-
 /** Read a runtime-plugin asset (extracted under
  *  `plugins/.cache/<name>/<version>/`) and return its bytes plus
  *  the inferred Content-Type. The route handler in

package/server/utils/files/safe.ts

@@ -99,6 +99,45 @@ export function hasTraversalSegment(value: string): boolean {
   return value.split(/[/\\]/).some((segment) => segment === ".." || segment === ".");
 }
 
+// Lazily realpath a directory once and cache the result. Returns null
+// until the directory exists on disk (a fresh workspace hasn't created
+// it yet) and retries on the next call. The /artifacts/* static mounts
+// each need their storage root as a realpath for the traversal check,
+// but the root may not be materialised at boot.
+export function makeCachedRealpath(dir: string): () => Promise<string | null> {
+  let cached: string | null = null;
+  return async () => {
+    if (cached) return cached;
+    try {
+      cached = await promises.realpath(dir);
+      return cached;
+    } catch {
+      return null;
+    }
+  };
+}
+
+// Decode and traversal-guard an `/artifacts/*` request path against an
+// already-realpath'd storage root. Returns the in-root relative path to
+// serve, or null when the URL is malformed, escapes the root, or (when
+// `denyDotfiles`) touches a dotfile segment. The images / html / svg
+// static mounts share this so the decode + traversal + dotfile policy is
+// defined once. `rootReal` MUST be a realpath (see `resolveWithinRoot`).
+export function resolveArtifactRequestPath(rootReal: string, reqPath: string, denyDotfiles: boolean): string | null {
+  let relPath: string;
+  try {
+    // decodeURIComponent throws URIError on malformed escapes (`%ZZ`,
+    // stray `%`). Fail closed so a junk URL 404s instead of bubbling a
+    // 500 out of the express error chain.
+    relPath = decodeURIComponent(reqPath.replace(/^\//, ""));
+  } catch {
+    return null;
+  }
+  if (!resolveWithinRoot(rootReal, relPath)) return null;
+  if (denyDotfiles && containsDotfileSegment(relPath)) return null;
+  return relPath;
+}
+
 // `rootReal` MUST already be a realpath. Returns null on traversal or if either path doesn't exist on disk.
 export function resolveWithinRoot(rootReal: string, relPath: string): string | null {
   const normalized = path.normalize(relPath || "");

package/server/utils/httpError.ts

@@ -50,6 +50,12 @@ export function notFound(res: Response, error: string): Response {
   return sendError(res, 404, error);
 }
 
+/** 405 Method Not Allowed — the resource exists but refuses this verb
+ *  (e.g. a write against a read-only `dataSource` collection). */
+export function methodNotAllowed(res: Response, error: string): Response {
+  return sendError(res, 405, error);
+}
+
 /** 409 Conflict — duplicate, concurrent modification, already running, etc. */
 export function conflict(res: Response, error: string): Response {
   return sendError(res, 409, error);

package/server/utils/time.ts

@@ -47,6 +47,3 @@ export const SUBPROCESS_WORK_TIMEOUT_MS = ONE_MINUTE_MS;
 
 /** CLI subprocess timeout (claude -p for summarization, etc.) */
 export const CLI_SUBPROCESS_TIMEOUT_MS = 5 * ONE_MINUTE_MS;
-
-/** Maximum one-shot notification delay */
-export const MAX_NOTIFICATION_DELAY_SEC = 3_600; // 1 hour in seconds

package/server/workspace/collections/index.ts

@@ -11,6 +11,7 @@ export { validateCollectionRecords, validateRecordObject, COMPUTED_TYPES, type R
 export { buildWorkspaceOntology, schemaRelations, type CollectionOntologyEntry, type OntologyRelation } from "@mulmoclaude/core/collection/server";
 export { applyMutateAction, firstMutateParamProblem, type MutateActionOutcome } from "@mulmoclaude/core/collection/server";
 export { enrichItems, computeCollectionIcon } from "@mulmoclaude/core/collection/server";
+export { storeFor, collectionWritable, readOnlyRefusal, type CollectionStore } from "@mulmoclaude/core/collection/server";
 export { deleteCollection, deleteCollectionRefusalMessage, type DeleteCollectionResult } from "@mulmoclaude/core/collection/server";
 export { deleteCustomView, type DeleteViewResult } from "@mulmoclaude/core/collection/server";
 export {