mulmoclaude 1.3.0 → 1.4.0

package/server/workspace/collections/remoteView.ts

@@ -23,17 +23,14 @@ import {
 } from "@mulmoclaude/core/remote-view";
 import { enrichItems } from "@mulmoclaude/core/collection/server";
 import {
-  collectionWritable,
-  deleteItem,
   readCustomViewHtml,
   readCustomViewI18n,
-  readItem,
   safeRecordId,
   storeFor,
-  writeItem,
   type CollectionCustomView,
   type CollectionItem,
   type CollectionSchema,
+  type CollectionStore,
   type LoadedCollection,
 } from "./index.js";
 import { resolveThumbnail } from "../../utils/files/thumbnail-store.js";
@@ -118,9 +115,7 @@ export type MutateRemoteViewResult =
   | { kind: "path-escape" };
 
 export interface MutateRemoteViewDeps {
-  readItem: typeof readItem;
-  writeItem: typeof writeItem;
-  deleteItem: typeof deleteItem;
+  storeFor: (collection: LoadedCollection) => CollectionStore;
   enrichItems: typeof enrichItems;
   resolveThumbnail: typeof resolveThumbnail;
 }
@@ -132,15 +127,17 @@ export const createMutateRemoteView =
     if (!view) return { kind: "view-not-found", viewId };
     if (view.target !== "mobile") return { kind: "not-mobile", viewId };
     // A dataSource collection is read-only regardless of what write surface
-    // the view declares — the collection-level rule outranks the view's.
-    if (!collectionWritable(collection)) return { kind: "read-only-collection" };
+    // the view declares — the collection-level rule outranks the view's. The
+    // store encodes it as absent write/delete methods.
+    const store = deps.storeFor(collection);
+    if (!store.write || !store.delete) return { kind: "read-only-collection" };
     if (!isWritableView(view)) return { kind: "not-writable", viewId };
-    return request.op === "delete" ? deleteViaView(deps, collection, view.allowDelete === true, request.id) : updateViaView(deps, collection, view, request);
+    return request.op === "delete" ? deleteViaView(store.delete, view.allowDelete === true, request.id) : updateViaView(deps, store, collection, view, request);
   };
 
-async function deleteViaView(deps: MutateRemoteViewDeps, collection: LoadedCollection, allowDelete: boolean, itemId: string): Promise<MutateRemoteViewResult> {
+async function deleteViaView(remove: NonNullable<CollectionStore["delete"]>, allowDelete: boolean, itemId: string): Promise<MutateRemoteViewResult> {
   if (!allowDelete) return { kind: "delete-not-allowed" };
-  const result = await deps.deleteItem(collection.dataDir, itemId, { slug: collection.slug });
+  const result = await remove(itemId);
   if (result.kind === "invalid-id") return { kind: "invalid-id", id: result.itemId };
   if (result.kind === "path-escape") return { kind: "path-escape" };
   if (result.kind === "not-found") return { kind: "item-not-found", id: result.itemId };
@@ -149,10 +146,13 @@ async function deleteViaView(deps: MutateRemoteViewDeps, collection: LoadedColle
 
 async function updateViaView(
   deps: MutateRemoteViewDeps,
+  store: CollectionStore,
   collection: LoadedCollection,
   view: CollectionCustomView,
   request: Extract<RemoteViewMutateRequest, { op: "update" }>,
 ): Promise<MutateRemoteViewResult> {
+  const { write } = store;
+  if (!write) return { kind: "read-only-collection" }; // unreachable: caller guards presence
   const { primaryKey } = collection.schema;
   const patchKeys = Object.keys(request.patch);
   if (patchKeys.length === 0) return { kind: "invalid-patch" };
@@ -161,17 +161,17 @@ async function updateViaView(
   // desync the file name from the record) even if an author listed it.
   const offending = patchKeys.find((key) => key === primaryKey || !allowed.has(key));
   if (offending) return { kind: "field-not-editable", field: offending };
-  // Classify a bad id BEFORE readItem — which returns null for an unsafe id, a
-  // path-escape, AND a genuinely-missing record alike — so update reports the
-  // same explicit `invalid-id` the delete path does (via deleteItem) instead of
-  // masking it as a 404. (A valid id whose dataDir escapes the workspace can
-  // hold no record, so it still resolves to item-not-found; a real write is
-  // additionally refused by writeItem's own containment guard below.)
+  // Classify a bad id BEFORE the store read — which returns null for an unsafe
+  // id, a path-escape, AND a genuinely-missing record alike — so update reports
+  // the same explicit `invalid-id` the delete path does (via `store.delete`)
+  // instead of masking it as a 404. (A valid id whose data location escapes the
+  // workspace can hold no record, so it still resolves to item-not-found; a
+  // real write is additionally refused by the store's own containment guard.)
   if (safeRecordId(request.id) === null) return { kind: "invalid-id", id: request.id };
-  const existing = await deps.readItem(collection.dataDir, request.id, { slug: collection.slug });
+  const existing = await store.read(request.id);
   if (!existing) return { kind: "item-not-found", id: request.id };
   const merged: CollectionItem = { ...existing, ...request.patch, [primaryKey]: request.id };
-  const result = await deps.writeItem(collection.dataDir, request.id, merged, { slug: collection.slug });
+  const result = await write(request.id, merged);
   if (result.kind === "invalid-id") return { kind: "invalid-id", id: result.itemId };
   if (result.kind === "path-escape") return { kind: "path-escape" };
   if (result.kind === "conflict") return { kind: "item-not-found", id: result.itemId }; // unreachable: refuseOverwrite is false
@@ -201,7 +201,7 @@ async function updateViaView(
   return { kind: "ok", op: "update", item: item as CollectionItem };
 }
 
-export const mutateRemoteView = createMutateRemoteView({ readItem, writeItem, deleteItem, enrichItems, resolveThumbnail });
+export const mutateRemoteView = createMutateRemoteView({ storeFor, enrichItems, resolveThumbnail });
 
 // ── Item pages with inlined image thumbnails (phase 5 — plans/feat-remote-view-images.md) ──
 // A mobile view's `getItems`, view-aware so it can inline the `imageFields` its

package/server/workspace/collections/watcher.ts

@@ -15,5 +15,6 @@ export {
   _syncWatchersForTesting,
   _tickTimeTriggersForTesting,
   _scheduleItemReconcileForTesting,
+  _scheduleStorageReconcileForTesting,
   type CollectionWatcherOptions,
 } from "@mulmoclaude/core/collection-watchers";

package/server/workspace/custom-dirs.ts

@@ -9,7 +9,7 @@ import path from "path";
 import { workspacePath, WORKSPACE_DIRS } from "./paths.js";
 import { log } from "../system/logger/index.js";
 import { writeJsonAtomicSync } from "../utils/files/json.js";
-import { isRecord } from "../utils/types.js";
+import { hasStringProp, isRecord } from "../utils/types.js";
 
 // ── Types ───────────────────────────────────────────────────────
 
@@ -82,16 +82,23 @@ function sanitizeDescription(raw: string): string {
 
 function validateEntry(raw: unknown): CustomDirEntry | null {
   if (!isRecord(raw)) return null;
-  const obj = raw as Record<string, unknown>;
 
-  const validPath = validatePath(String(obj.path ?? ""));
+  // Type-check the field rather than `String(...)`-ing it. This file is fed by a
+  // hand-edited config, so `path` can be an array or object; stringifying one
+  // handed `validatePath` the literal "[object Object]" to evaluate as a path.
+  // (`validatePath`'s own `typeof !== "string"` check could never fire behind a
+  // `String()` call.)
+  if (!hasStringProp(raw, "path")) return null;
+  const validPath = validatePath(raw.path);
   if (!validPath) return null;
 
-  const structure = isValidStructure(obj.structure) ? obj.structure : DIR_STRUCTURES.flat;
+  const structure = isValidStructure(raw.structure) ? raw.structure : DIR_STRUCTURES.flat;
 
   return {
     path: validPath,
-    description: sanitizeDescription(String(obj.description ?? "")),
+    // A non-string description is dropped rather than described as
+    // "[object Object]" — it is optional, so absent is the honest reading.
+    description: sanitizeDescription(hasStringProp(raw, "description") ? raw.description : ""),
     structure,
   };
 }
@@ -153,7 +160,10 @@ export function validateCustomDirs(raw: unknown): { entries: CustomDirEntry[] }
     if (entry) {
       entries.push(entry);
     } else {
-      const itemPath = isRecord(item) ? String((item as Record<string, unknown>).path ?? "") : "";
+      // Only echo a genuine string back in the error; a non-string `path` is
+      // exactly the case where "[object Object]" would mislead the reader about
+      // what their config actually says.
+      const itemPath = hasStringProp(item, "path") ? item.path : "";
       errors.push(`entry ${i}: invalid path "${itemPath}"`);
     }
   });

package/server/workspace/reference-dirs.ts

@@ -11,7 +11,7 @@ import path from "path";
 import { homedir } from "os";
 import { log } from "../system/logger/index.js";
 import { readReferenceDirsJson, writeReferenceDirsJson, isExistingDirectory } from "../utils/files/reference-dirs-io.js";
-import { isRecord } from "../utils/types.js";
+import { hasStringProp, isRecord } from "../utils/types.js";
 
 // ── Types ───────────────────────────────────────────────────────
 
@@ -104,7 +104,10 @@ function validateEntry(raw: unknown): ReferenceDirEntry | null {
     return null;
   }
 
-  const label = sanitizeLabel(String(obj.label ?? path.basename(absPath)));
+  // Type-check like `hostPath` above rather than `String(...)`-ing: a
+  // non-string `label` in the hand-edited config falls back to the basename
+  // instead of labelling the directory "[object Object]".
+  const label = sanitizeLabel(hasStringProp(raw, "label") ? raw.label : path.basename(absPath));
 
   return { hostPath: absPath, label };
 }
@@ -155,7 +158,9 @@ export function validateReferenceDirs(raw: unknown): { entries: ReferenceDirEntr
     if (entry) {
       entries.push(entry);
     } else {
-      const hostPath = isRecord(item) ? String((item as Record<string, unknown>).hostPath ?? "") : "";
+      // Echo the path back only when it really is one — a non-string entry is
+      // precisely where "[object Object]" would misreport the user's config.
+      const hostPath = hasStringProp(item, "hostPath") ? item.hostPath : "";
       errors.push(`entry ${i}: invalid or blocked path "${hostPath}"`);
     }
   });

package/src/components/SettingsGoogleTab.vue

@@ -11,10 +11,13 @@
 
     <div v-if="loaded" class="flex items-center gap-3">
       <span class="text-sm" :class="statusColour" data-testid="settings-google-status">{{ statusText }}</span>
+      <!-- Stays clickable while `pending`: a user who abandoned the browser
+           consent can restart the link instead of waiting out the server-side
+           timeout (the click aborts the stale flow and opens a fresh one). -->
       <button
         v-if="!linked"
         class="px-2 py-1 text-xs rounded bg-blue-500 text-white hover:bg-blue-600 disabled:opacity-50"
-        :disabled="busy || pending || clientSecret === 'ambiguous'"
+        :disabled="busy || clientSecret === 'ambiguous'"
         data-testid="settings-google-connect-btn"
         @click="connect"
       >

package/src/components/StackView.vue

@@ -128,6 +128,7 @@ import type { ToolResultComplete } from "gui-chat-protocol/vue";
 import { View as TextResponseOriginalView } from "../plugins/textResponse/index";
 import { handleExternalLinkClick } from "../utils/dom/externalLink";
 import { clampIframeHeight } from "../utils/dom/iframeHeightClamp";
+import { isNearBottom } from "../utils/dom/scrollable";
 import type { TextResponseData } from "../plugins/textResponse/types";
 import { formatSmartTime } from "../utils/format/date";
 import { isRecord } from "../utils/types";
@@ -231,6 +232,9 @@ const emit = defineEmits<{
 }>();
 
 const containerRef = ref<HTMLDivElement | null>(null);
+// Auto-follow gate: true while the reader is at the bottom. Updated from the
+// container's scroll handler (#2179).
+const stickToBottom = ref(true);
 const itemRefs = new Map<string, HTMLElement>();
 const naturalWrapperRefs = new Map<string, HTMLElement>();
 
@@ -445,6 +449,11 @@ function computeActiveUuidFromScroll(): string | null {
 
 function onContainerScroll(): void {
   if (suppressScrollSync) return;
+  // Only a genuine user scroll moves the auto-follow gate. Programmatic
+  // scrolls are suppressed above — otherwise following would cancel itself:
+  // the newest-card jump lands away from the bottom, which would read as
+  // "the user scrolled up" and stop the next chunk from arriving.
+  if (containerRef.value) stickToBottom.value = isNearBottom(containerRef.value);
   if (scrollSpyRafId !== null) return;
   scrollSpyRafId = requestAnimationFrame(() => {
     scrollSpyRafId = null;
@@ -490,7 +499,9 @@ const latestResultScrollKey = computed(() => {
 
 watch(latestResultScrollKey, () => {
   nextTick(() => {
-    if (containerRef.value) {
+    // Streaming fires this on every chunk — only follow while the reader is
+    // still parked at the bottom, so scrolling up to read stays put (#2179).
+    if (containerRef.value && stickToBottom.value) {
       beginSuppressScrollSync();
       const newest = props.toolResults[props.toolResults.length - 1];
       const target = resolveLatestScrollTarget(displayItems.value, newest, (result) => result.uuid);

package/src/composables/collections/uiHost.ts

@@ -43,7 +43,7 @@ import { useConfirm } from "../useConfirm";
 import { useShortcuts } from "../useShortcuts";
 import PinToggle from "../../components/PinToggle.vue";
 import type { NotifierSeverity } from "../../utils/collections/notifiedItems";
-import type { CollectionsListResponse, FeedsListResponse } from "@mulmoclaude/core/collection";
+import type { CollectionsListResponse, CollectionOntologyResponse, FeedsListResponse } from "@mulmoclaude/core/collection";
 import type { TranslateResponse } from "@mulmoclaude/core/translation/client";
 import type { CollectionDetailResponse, ItemMutationResponse } from "../../components/collectionTypes";
 
@@ -167,6 +167,7 @@ configureCollectionUi({
   // index pages
   listCollections: () => apiGet<CollectionsListResponse>(API_ROUTES.collections.list),
   listFeeds: () => apiGet<FeedsListResponse>(API_ROUTES.feeds.list),
+  fetchOntology: () => apiGet<CollectionOntologyResponse>(API_ROUTES.collections.ontology),
   listRegistry: () => apiGet<RegistryListResponse>(API_ROUTES.collectionsRegistry.list),
   importRegistry: (author, slug, registry) => apiPost<RegistryImportResponse>(API_ROUTES.collectionsRegistry.import, { author, slug, registry }),
   reconcileShortcuts: (kind, live) => useShortcuts().reconcile(kind, live),

package/src/composables/useChatScroll.ts

@@ -1,9 +1,16 @@
 // Auto-scroll the sidebar chat list to the bottom when new results
 // arrive or a run starts. Also re-focuses the chat input when a run
 // finishes.
+//
+// Following is gated on the reader still being at the bottom: streaming
+// appends fire this watch on every chunk, and forcing the scroll each
+// time dragged the view out from under anyone who had scrolled up to
+// read (#2179). A run starting is treated as an explicit user action
+// (they just sent something), so that one re-arms and jumps.
 
 import { computed, nextTick, watch, type ComputedRef, type Ref } from "vue";
 import type { ToolResultComplete } from "gui-chat-protocol/vue";
+import { useStickToBottom } from "./useStickToBottom";
 
 export function useChatScroll<T extends { focus: () => void }>(opts: {
   sessionSidebarRef: Ref<{ root: HTMLDivElement | null } | null>;
@@ -14,6 +21,7 @@ export function useChatScroll<T extends { focus: () => void }>(opts: {
   const { sessionSidebarRef, toolResults, isRunning, chatInputRef } = opts;
 
   const chatListRef = computed(() => sessionSidebarRef.value?.root ?? null);
+  const { stuck, resume } = useStickToBottom(chatListRef);
   // Key that changes both on new results AND on streaming updates to
   // the last text card (which appends in place, leaving length stable).
   const latestResultScrollKey = computed(() => {
@@ -22,8 +30,11 @@ export function useChatScroll<T extends { focus: () => void }>(opts: {
     return `${list.length}:${last?.uuid ?? ""}:${last?.message?.length ?? 0}`;
   });
 
-  function scrollChatToBottom(): void {
-    nextTick(() => {
+  function scrollChatToBottom(options: { force?: boolean } = {}): void {
+    if (!options.force && !stuck.value) return;
+    // Scrolling after the DOM settles is the whole point; callers are sync and
+    // have nothing to do with the tick's completion.
+    void nextTick(() => {
       if (chatListRef.value) {
         chatListRef.value.scrollTop = chatListRef.value.scrollHeight;
       }
@@ -34,14 +45,15 @@ export function useChatScroll<T extends { focus: () => void }>(opts: {
     chatInputRef.value?.focus();
   }
 
-  watch(latestResultScrollKey, scrollChatToBottom);
+  watch(latestResultScrollKey, () => scrollChatToBottom());
   watch(isRunning, (running) => {
     if (running) {
-      scrollChatToBottom();
+      resume();
+      scrollChatToBottom({ force: true });
     } else {
-      nextTick(() => focusChatInput());
+      void nextTick(() => focusChatInput());
     }
   });
 
-  return { scrollChatToBottom, focusChatInput };
+  return { scrollChatToBottom, focusChatInput, stuckToBottom: stuck };
 }

package/src/composables/useFileSelection.ts

@@ -41,7 +41,10 @@ export function useFileSelection() {
 
   function selectFile(filePath: string): void {
     selectedPath.value = filePath;
-    loadContent(filePath);
+    // Fire-and-forget: selection must not block on I/O, and `loadContent`
+    // catches internally so this cannot reject — its outcome is read off
+    // `contentLoading` / `contentError`.
+    void loadContent(filePath);
     // Pass segments as an array so Vue Router encodes each segment
     // independently (spaces / multi-byte / `?#%` get UTF-8 percent-
     // encoding), while slashes stay as path separators. Passing the

package/src/composables/useStickToBottom.ts

@@ -0,0 +1,51 @@
+// Tracks whether a scroll container is parked at (or just above) its bottom,
+// so auto-follow callers can stop yanking the view away from a reader who
+// scrolled up mid-stream (#2179).
+//
+// Starts stuck: a fresh list follows new output until the reader deliberately
+// scrolls away, and re-arms the moment they scroll back down — the Slack /
+// Discord behaviour. Only real scroll events move the flag, so a container
+// that simply grows taller below the viewport keeps following.
+
+import { getCurrentInstance, onBeforeUnmount, ref, watch, type Ref } from "vue";
+import { isNearBottom, NEAR_BOTTOM_THRESHOLD_PX } from "../utils/dom/scrollable";
+
+export function useStickToBottom(elementRef: Ref<HTMLElement | null>, thresholdPx: number = NEAR_BOTTOM_THRESHOLD_PX) {
+  const stuck = ref(true);
+  let attached: HTMLElement | null = null;
+
+  const sync = (): void => {
+    if (attached) stuck.value = isNearBottom(attached, thresholdPx);
+  };
+
+  const detach = (): void => {
+    attached?.removeEventListener("scroll", sync);
+    attached = null;
+  };
+
+  watch(
+    elementRef,
+    (element) => {
+      detach();
+      if (!element) return;
+      attached = element;
+      // A freshly mounted container follows again — otherwise a reader who
+      // had scrolled away in a previous list would find the new one silently
+      // not following.
+      stuck.value = true;
+      element.addEventListener("scroll", sync, { passive: true });
+    },
+    { immediate: true },
+  );
+
+  // Guarded so the composable can also be driven directly from a test, where
+  // there is no component instance to own the hook.
+  if (getCurrentInstance()) onBeforeUnmount(detach);
+
+  /** Re-arm following after an explicit jump-to-bottom (sending a message). */
+  const resume = (): void => {
+    stuck.value = true;
+  };
+
+  return { stuck, resume };
+}

package/src/config/apiRoutes.ts

@@ -300,6 +300,12 @@ const HOST_API_ROUTES = {
   // host renders its records via `<CollectionView>`.
   collections: {
     list: "/api/collections",
+    /** GET → { entries: CollectionOntologyEntry[] } — the raw workspace
+     *  ontology; the /collections Map tab builds its graph client-side
+     *  from these via the shared `buildOntologyGraph` (server/client
+     *  parity). Must be registered BEFORE `detail` so "ontology" is
+     *  never matched as a `:slug`. */
+    ontology: "/api/collections/ontology",
     /** GET → { collection, items } */
     detail: "/api/collections/:slug",
     /** POST → create one record (auto-id when primaryKey value omitted) */
@@ -363,6 +369,14 @@ const HOST_API_ROUTES = {
      *  read-only by construction (see core/queryZ.ts); 400 on a file-backed
      *  collection (no query engine). Backs chart-drawing custom views. */
     viewDataQuery: "/api/collections/:slug/view-data/query",
+    /** GET → resolve one record-referenced `image` field value (a workspace
+     *  path, `?path=…`) into a downscaled thumbnail → { path, dataUrl }.
+     *  Requires only the `read` capability; the path must be a CURRENT value
+     *  of one of the schema's image-type fields (no arbitrary file reads).
+     *  Optional `?maxEdge=` (clamped 64–1024, default 512). This is how a
+     *  desktop custom view displays workspace image files — sibling of the
+     *  remote view's `imageFields` inlining. */
+    viewDataImage: "/api/collections/:slug/view-data/image",
     /** DELETE → remove one custom view: drop it from schema.json `views[]` and
      *  unlink its `views/<file>.html` (global-bearer auth) → { deleted, viewId }.
      *  Source-aware; refuses user-scope + preset collections. */

package/src/utils/dom/scrollable.ts

@@ -1,5 +1,20 @@
 // Small DOM helpers shared across components.
 
+/** Tolerance band for {@link isNearBottom}: a reader sitting within this many
+ *  pixels of the end still counts as "at the bottom", so auto-follow survives
+ *  the small drift of reading the last line. */
+export const NEAR_BOTTOM_THRESHOLD_PX = 80;
+
+// Whether a scroll container is parked at (or just above) its bottom.
+// Auto-follow readers gate on this so streaming output stops yanking the
+// view away from someone who scrolled up to read (#2179).
+export function isNearBottom(
+  element: Pick<HTMLElement, "scrollTop" | "scrollHeight" | "clientHeight">,
+  thresholdPx: number = NEAR_BOTTOM_THRESHOLD_PX,
+): boolean {
+  return element.scrollHeight - element.scrollTop - element.clientHeight <= thresholdPx;
+}
+
 // Walk a container's descendants and return the first one that
 // has both more vertical content than its visible height AND a
 // CSS overflow that allows scrolling. Used so canvas-level arrow

package/src/utils/errors.ts

@@ -1,40 +1,9 @@
-// Shared error helpers for the Vue side. Mirrors the server-side
-// `server/utils/errors.ts` so the same helper is available wherever
-// we handle caught exceptions.
+// Shared error helpers for the Vue side. Same implementation as the server —
+// both re-export `@mulmoclaude/core/utils`, whose helpers are browser-safe
+// (pure string work, no node imports). Keeping one implementation is what
+// stops the gRPC `{ code, details, metadata }` case from printing as
+// `[object Object]` on one side and "quota exceeded" on the other (#2217).
 //
 // Use `errorMessage(err)` instead of inlining
-// `err instanceof Error ? err.message : String(err)` — searching for
-// one canonical helper is easier than grepping for the inline form.
-//
-// Non-Error objects with a `details` (gRPC convention) or `message`
-// string field have that field surfaced — without this, gRPC errors
-// like `{ code, details, metadata }` show up as `[object Object]`.
-//
-// The optional `fallback` covers the common idiom of surfacing a
-// descriptive message ("Invalid JSON", "Connection error.") when a
-// throw turns out to be a non-Error value.
-
-export function errorMessage(err: unknown, fallback?: string): string {
-  if (err instanceof Error) return err.message;
-  if (err !== null && typeof err === "object") {
-    const obj = err as { details?: unknown; message?: unknown };
-    if (typeof obj.details === "string" && obj.details) return obj.details;
-    if (typeof obj.message === "string" && obj.message) return obj.message;
-  }
-  if (fallback !== undefined) return fallback;
-  return String(err);
-}
-
-// Coerce an unknown caught value into an Error, preserving the
-// original if it already was one. Use in error boundaries / Promise
-// rejections / event-handler onerror callbacks where the downstream
-// API wants an Error object (not just its message string).
-//
-// `fallback` is the message used when coercing a non-Error value —
-// pass a descriptive string for cases where `String(err)` would just
-// produce noise (e.g. `<img>.onerror` hands you an Event, not the
-// underlying load failure).
-export function toError(err: unknown, fallback?: string): Error {
-  if (err instanceof Error) return err;
-  return new Error(fallback ?? errorMessage(err));
-}
+// `err instanceof Error ? err.message : String(err)`.
+export { errorMessage, toError } from "@mulmoclaude/core/utils";