mulmoclaude 0.9.0 → 0.9.2

package/src/composables/useDashboard.ts

@@ -0,0 +1,191 @@
+// Client store for the dashboard layout (tile order + per-tile view mode,
+// and per-row view-area heights for the favorites grid). Singleton module
+// state shared across consumers, mirroring `useShortcuts`: persistence is
+// server-side (`config/dashboard.json` via PUT /api/dashboard); the client
+// owns the full layout and replaces it wholesale. Mutations are optimistic
+// with rollback on failure and serialised so overlapping replace-all PUTs
+// never land out of order.
+//
+// Membership (which collections appear) is NOT owned here — it derives
+// from the user's pinned collection shortcuts (favorites). `reconcile`
+// folds a fresh favorite-slug list into the stored layout: it appends
+// newly-favorited collections and prunes ones that were unpinned, while
+// preserving the user's dashboard order and per-tile view modes.
+//
+// Row heights are POSITIONAL: indexed by grid row (2 tiles/row), they stay
+// with the slot when tiles are reordered, never with a specific tile.
+
+import { computed, ref, type ComputedRef } from "vue";
+import { API_ROUTES } from "../config/apiRoutes";
+import { apiGet, apiPut } from "../utils/api";
+import type { DashboardTile } from "../types/dashboard";
+
+const tiles = ref<DashboardTile[]>([]);
+const rowHeights = ref<Record<string, number[]>>({});
+const loadError = ref<string | null>(null);
+/** True only after a GET has authoritatively populated the layout. Until
+ *  then, mutations refuse to persist — a replace-all PUT built on the
+ *  empty default would clobber an existing `dashboard.json`. */
+const loaded = ref(false);
+let loadPromise: Promise<void> | null = null;
+
+interface DashboardResponse {
+  tiles: DashboardTile[];
+  rowHeights?: Record<string, number[]>;
+}
+
+/** Snapshot of the mutable layout, for optimistic rollback. */
+interface LayoutSnapshot {
+  tiles: DashboardTile[];
+  rowHeights: Record<string, number[]>;
+}
+
+function snapshot(): LayoutSnapshot {
+  return { tiles: tiles.value, rowHeights: rowHeights.value };
+}
+
+function apply(layout: LayoutSnapshot): void {
+  tiles.value = layout.tiles;
+  rowHeights.value = layout.rowHeights;
+}
+
+/** Load once per session (deduped). A FAILED load is not cached so the
+ *  next call retries rather than permanently serving the failure. */
+async function load(force = false): Promise<void> {
+  if (loadPromise && !force) return loadPromise;
+  loadPromise = (async () => {
+    const result = await apiGet<DashboardResponse>(API_ROUTES.dashboard);
+    if (!result.ok) {
+      loadError.value = result.error;
+      loadPromise = null; // allow retry on the next call
+      return;
+    }
+    loadError.value = null;
+    apply({ tiles: result.data.tiles, rowHeights: result.data.rowHeights ?? {} });
+    loaded.value = true;
+  })();
+  return loadPromise;
+}
+
+// Every mutation runs through this chain so the replace-all PUTs never
+// overlap (the same race `useShortcuts` guards against).
+let mutationChain: Promise<unknown> = Promise.resolve();
+
+function enqueue<T>(task: () => Promise<T>): Promise<T> {
+  const run = mutationChain.then(task, task);
+  mutationChain = run.then(
+    () => undefined,
+    () => undefined,
+  );
+  return run;
+}
+
+/** Persist the given layout, rolling back to `previous` on failure.
+ *  Returns true on success. Call only from inside `enqueue`. */
+async function persist(next: LayoutSnapshot, previous: LayoutSnapshot): Promise<boolean> {
+  apply(next);
+  const result = await apiPut<DashboardResponse>(API_ROUTES.dashboard, { tiles: next.tiles, rowHeights: next.rowHeights });
+  if (!result.ok) {
+    apply(previous);
+    loadError.value = result.error;
+    console.error("[useDashboard] persist failed", result.error);
+    return false;
+  }
+  // Adopt the server's canonical layout. If the response omits rowHeights
+  // (e.g. a version-skewed server), keep the heights we just sent rather
+  // than clearing them — otherwise a resize would visibly snap back.
+  apply({ tiles: result.data.tiles, rowHeights: result.data.rowHeights ?? next.rowHeights });
+  loadError.value = null;
+  return true;
+}
+
+/** Replace the full ordered tile list (used by drag-to-reorder). Row
+ *  heights are positional, so they stay put. */
+function setTiles(next: DashboardTile[]): Promise<boolean> {
+  return enqueue(async () => {
+    await load();
+    if (!loaded.value) return false; // never overwrite an unread layout
+    return persist({ tiles: next, rowHeights: rowHeights.value }, snapshot());
+  });
+}
+
+/** Set (or, when null, clear) one tile's view mode. No-op if the slug
+ *  isn't a tile. */
+function setViewMode(slug: string, viewMode: string | null): Promise<boolean> {
+  return enqueue(async () => {
+    await load();
+    if (!loaded.value) return false;
+    if (!tiles.value.some((tile) => tile.slug === slug)) return true;
+    const previous = snapshot();
+    const next = previous.tiles.map((tile) => {
+      if (tile.slug !== slug) return tile;
+      if (viewMode === null) {
+        const { viewMode: __drop, ...rest } = tile;
+        return rest;
+      }
+      return { ...tile, viewMode };
+    });
+    return persist({ tiles: next, rowHeights: previous.rowHeights }, previous);
+  });
+}
+
+/** Set one grid row's view-area height (px) for the given column-count
+ *  layout. Heights are kept per column count so the 1- and 2-column
+ *  layouts stay independent. Pads with `0` (default) for earlier
+ *  untouched rows. */
+function setRowHeight(columns: number, row: number, height: number): Promise<boolean> {
+  return enqueue(async () => {
+    await load();
+    if (!loaded.value) return false;
+    if (columns < 1 || row < 0) return true;
+    const previous = snapshot();
+    const key = String(columns);
+    const heights = [...(previous.rowHeights[key] ?? [])];
+    while (heights.length <= row) heights.push(0);
+    heights[row] = height;
+    const next = { ...previous.rowHeights, [key]: heights };
+    return persist({ tiles: previous.tiles, rowHeights: next }, previous);
+  });
+}
+
+/** Fold a fresh favorite-slug list into the stored layout: keep stored
+ *  tiles whose slug is still a favorite (preserving order + view mode),
+ *  then append any favorites not yet present (in the favorites' order).
+ *  Persists only when something drifted, so the file self-heals after a
+ *  pin / unpin without a redundant PUT on every visit. */
+function reconcile(favoriteSlugs: string[]): Promise<void> {
+  return enqueue(async () => {
+    await load();
+    if (!loaded.value) return; // never overwrite an unread layout
+    const favoriteSet = new Set(favoriteSlugs);
+    const kept = tiles.value.filter((tile) => favoriteSet.has(tile.slug));
+    const keptSlugs = new Set(kept.map((tile) => tile.slug));
+    const appended = favoriteSlugs.filter((slug) => !keptSlugs.has(slug)).map((slug) => ({ slug }) as DashboardTile);
+    const next = [...kept, ...appended];
+    const drifted = next.length !== tiles.value.length || next.some((tile, i) => tile.slug !== tiles.value[i]?.slug);
+    if (drifted) await persist({ tiles: next, rowHeights: rowHeights.value }, snapshot());
+  });
+}
+
+export function useDashboard(): {
+  tiles: ComputedRef<DashboardTile[]>;
+  rowHeights: ComputedRef<Record<string, number[]>>;
+  loadError: ComputedRef<string | null>;
+  load: (force?: boolean) => Promise<void>;
+  setTiles: (next: DashboardTile[]) => Promise<boolean>;
+  setViewMode: (slug: string, viewMode: string | null) => Promise<boolean>;
+  setRowHeight: (columns: number, row: number, height: number) => Promise<boolean>;
+  reconcile: (favoriteSlugs: string[]) => Promise<void>;
+} {
+  void load();
+  return {
+    tiles: computed(() => tiles.value),
+    rowHeights: computed(() => rowHeights.value),
+    loadError: computed(() => loadError.value),
+    load,
+    setTiles,
+    setViewMode,
+    setRowHeight,
+    reconcile,
+  };
+}

package/src/composables/useMarkdownZip.ts

@@ -0,0 +1,51 @@
+// Download markdown / a wiki page as a self-contained HTML zip. Parallel
+// to usePdfDownload, but hits POST /api/share/pack-markdown and receives
+// a zip (index.html with CSS + images inlined). Failure sets `zipFailed`
+// so callers render a localized message — the raw server body is never
+// surfaced.
+
+import { ref, type Ref } from "vue";
+import { API_ROUTES } from "../config/apiRoutes";
+import { apiFetchRaw } from "../utils/api";
+import { saveBlob, filenameFromDisposition } from "../utils/blobDownload";
+
+export interface DownloadMarkdownZipOptions {
+  /** Workspace-relative source dir for resolving relative `<img>` refs. */
+  baseDir?: string;
+  stripFrontmatter?: boolean;
+  marp?: boolean;
+}
+
+export interface UseMarkdownZipHandle {
+  zipDownloading: Ref<boolean>;
+  zipFailed: Ref<boolean>;
+  downloadZip: (markdown: string, filename: string, options?: DownloadMarkdownZipOptions) => Promise<void>;
+}
+
+export function useMarkdownZip(): UseMarkdownZipHandle {
+  const zipDownloading = ref(false);
+  const zipFailed = ref(false);
+
+  async function downloadZip(markdown: string, filename: string, options: DownloadMarkdownZipOptions = {}): Promise<void> {
+    zipFailed.value = false;
+    zipDownloading.value = true;
+    try {
+      const response = await apiFetchRaw(API_ROUTES.share.packMarkdown, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ markdown, filename, baseDir: options.baseDir, stripFrontmatter: options.stripFrontmatter, marp: options.marp }),
+      });
+      if (!response.ok) {
+        zipFailed.value = true;
+        return;
+      }
+      saveBlob(await response.blob(), filenameFromDisposition(response.headers.get("content-disposition"), `${filename}.zip`));
+    } catch {
+      zipFailed.value = true;
+    } finally {
+      zipDownloading.value = false;
+    }
+  }
+
+  return { zipDownloading, zipFailed, downloadZip };
+}

package/src/composables/useNotifications.ts

@@ -40,10 +40,7 @@ export interface NotifierHistoryEntry extends NotifierEntry {
 }
 
 type NotifierEvent =
-  | { type: "published"; entry: NotifierEntry }
-  | { type: "cleared"; id: string }
-  | { type: "cancelled"; id: string }
-  | { type: "updated"; entry: NotifierEntry };
+  { type: "published"; entry: NotifierEntry } | { type: "cleared"; id: string } | { type: "cancelled"; id: string } | { type: "updated"; entry: NotifierEntry };
 
 const HISTORY_CAP = 50;
 

package/src/composables/useSharePack.ts

@@ -0,0 +1,60 @@
+// Download an artifacts/html page as a self-contained zip from the host
+// UI (file explorer preview). Mirrors usePdfDownload: POST the workspace
+// path to /api/share/pack, receive a binary zip, run the
+// blob-to-download dance. Failure sets `packFailed` so the caller can
+// render a localized message — the raw server body is never surfaced.
+
+import { ref, type Ref } from "vue";
+import { API_ROUTES } from "../config/apiRoutes";
+import { apiFetchRaw } from "../utils/api";
+import { saveBlob, filenameFromDisposition } from "../utils/blobDownload";
+
+export interface UseSharePackHandle {
+  packing: Ref<boolean>;
+  packFailed: Ref<boolean>;
+  downloadZip: (htmlPath: string) => Promise<void>;
+  /** Clear the failed flag — call on navigation so a stale error banner
+   *  doesn't carry over to the next file. */
+  reset: () => void;
+}
+
+function fallbackName(htmlPath: string): string {
+  const base =
+    htmlPath
+      .split("/")
+      .pop()
+      ?.replace(/\.html?$/i, "") || "share";
+  return `${base}.zip`;
+}
+
+export function useSharePack(): UseSharePackHandle {
+  const packing = ref(false);
+  const packFailed = ref(false);
+
+  async function downloadZip(htmlPath: string): Promise<void> {
+    packFailed.value = false;
+    packing.value = true;
+    try {
+      const response = await apiFetchRaw(API_ROUTES.share.pack, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ path: htmlPath }),
+      });
+      if (!response.ok) {
+        packFailed.value = true;
+        return;
+      }
+      saveBlob(await response.blob(), filenameFromDisposition(response.headers.get("content-disposition"), fallbackName(htmlPath)));
+    } catch {
+      packFailed.value = true;
+    } finally {
+      packing.value = false;
+    }
+  }
+
+  function reset(): void {
+    packFailed.value = false;
+  }
+
+  return { packing, packFailed, downloadZip, reset };
+}

package/src/composables/useTranslatedQueries.ts

@@ -1,109 +1,29 @@
-// Translates a role's suggested queries into the user's current
-// browser locale via /api/translation. Until the response lands the
-// caller keeps seeing the English source — the swap is reactive
-// (Vue updates the SuggestionsPanel when the cache slot fills in).
+// Translates a role's suggested queries into the user's current browser locale.
+// A thin wrapper over the generic `useTranslatedStrings` (namespace
+// "role-queries"); all caching / de-dup / fallback logic lives there and in the
+// host-agnostic `@mulmoclaude/core/translation/client` cache it wraps.
 //
-// Cache keyed by `${roleId}:${locale}` and shared across all
-// consumers. Concurrent requests for the same key are deduped via
-// an in-flight Promise map.
-//
-// `locale` is taken as a Ref instead of being read from `useI18n()`
-// internally so the composable can be unit-tested outside a Vue
-// setup context.
+// `locale` is taken as a Ref instead of being read from `useI18n()` internally
+// so the composable can be unit-tested outside a Vue setup context.
 
-import { computed, watchEffect, type ComputedRef, type Ref, ref } from "vue";
-import { apiPost } from "../utils/api";
-import { API_ROUTES } from "../config/apiRoutes";
+import { computed, type ComputedRef, type Ref } from "vue";
+import { useTranslatedStrings, __resetTranslatedStringsCacheForTests } from "./useTranslatedStrings";
 import type { Role } from "../config/roles";
 
 const TRANSLATION_NAMESPACE = "role-queries";
 
-interface TranslateResponse {
-  translations: string[];
-}
-
-const cache = new Map<string, Ref<string[] | null>>();
-const inflight = new Map<string, Promise<void>>();
-
-function cacheKey(roleId: string, locale: string): string {
-  return `${roleId}:${locale}`;
-}
-
-function ensureSlot(key: string): Ref<string[] | null> {
-  let slot = cache.get(key);
-  if (!slot) {
-    slot = ref<string[] | null>(null);
-    cache.set(key, slot);
-  }
-  return slot;
-}
-
-async function runFetch(key: string, locale: string, sentences: string[]): Promise<void> {
-  const result = await apiPost<TranslateResponse>(API_ROUTES.translation.translate, {
-    namespace: TRANSLATION_NAMESPACE,
-    targetLanguage: locale,
-    sentences,
-  });
-  if (!result.ok) {
-    console.warn("[useTranslatedQueries] translate failed:", result.error);
-    return;
-  }
-  const { translations } = result.data;
-  if (!Array.isArray(translations) || translations.length !== sentences.length) {
-    console.warn("[useTranslatedQueries] translate returned wrong length", {
-      expected: sentences.length,
-      got: Array.isArray(translations) ? translations.length : "(not array)",
-    });
-    return;
-  }
-  ensureSlot(key).value = [...translations];
-}
-
-function ensureFetch(roleId: string, locale: string, sentences: string[]): void {
-  const key = cacheKey(roleId, locale);
-  if (inflight.has(key)) return;
-  if (ensureSlot(key).value !== null) return;
-  const pending = runFetch(key, locale, sentences).finally(() => {
-    inflight.delete(key);
-  });
-  inflight.set(key, pending);
-}
-
 export interface UseTranslatedQueriesResult {
-  /** Translated queries when available, falling back to the role's
-   *  English source while the request is in flight or fails. */
+  /** Translated queries when available, falling back to the role's English
+   *  source while the request is in flight or fails. */
   readonly queries: ComputedRef<string[]>;
 }
 
 export function useTranslatedQueries(role: Ref<Role | undefined>, locale: Ref<string>): UseTranslatedQueriesResult {
-  watchEffect(() => {
-    const current = role.value;
-    if (!current) return;
-    const sources = current.queries;
-    if (!sources || sources.length === 0) return;
-    const lang = locale.value;
-    if (lang === "en") return;
-    ensureFetch(current.id, lang, [...sources]);
-  });
-
-  const queries = computed<string[]>(() => {
-    const current = role.value;
-    const sources = current?.queries ?? [];
-    if (sources.length === 0) return [];
-    const lang = locale.value;
-    if (lang === "en" || !current) return [...sources];
-    return cache.get(cacheKey(current.id, lang))?.value ?? [...sources];
-  });
-
+  const sentences = computed<readonly string[]>(() => role.value?.queries ?? []);
+  const queries = useTranslatedStrings(TRANSLATION_NAMESPACE, sentences, locale);
   return { queries };
 }
 
-// ── Test-only hooks ─────────────────────────────────────────────────
-// Vitest / node:test lives in a fresh worker per file, so module
-// state usually cleans itself up. These helpers exist so suites that
-// share a worker can still reset between cases.
-
-export function __resetTranslatedQueriesCacheForTests(): void {
-  cache.clear();
-  inflight.clear();
-}
+// Re-exported under the historical name so existing tests keep resetting the
+// (now shared) translation cache between cases.
+export const __resetTranslatedQueriesCacheForTests = __resetTranslatedStringsCacheForTests;

package/src/composables/useTranslatedStrings.ts

@@ -0,0 +1,68 @@
+// Generic runtime-translation composable: translate a reactive list of English
+// UI strings into the user's locale via the host's /api/translation route. The
+// host-agnostic cache (de-dup, memo, length validation) lives in
+// `@mulmoclaude/core/translation/client`; this file is the thin Vue layer —
+// reactivity + the `en`/empty fallback. `useTranslatedQueries` (role chips) and
+// any future caller share the one module-singleton cache below.
+//
+// `locale` and `sentences` are taken as Refs (not read from `useI18n()`) so the
+// composable can be unit-tested outside a Vue setup context.
+
+import { computed, watchEffect, type ComputedRef, type Ref, ref } from "vue";
+import { createTranslationCache, type TranslateRequest, type TranslateResponse } from "@mulmoclaude/core/translation/client";
+import { apiPost } from "../utils/api";
+import { API_ROUTES } from "../config/apiRoutes";
+
+const cache = createTranslationCache((req) =>
+  apiPost<TranslateResponse>(API_ROUTES.translation.translate, req).then((result) => (result.ok ? result.data : null)),
+);
+
+/** Pure projection: the translated batch when present, else the English source. */
+export function pickTranslated(translated: readonly string[] | null, sources: readonly string[]): string[] {
+  return [...(translated ?? sources)];
+}
+
+/** Resolve a request through the cache (peek-then-fetch) and hand the result to
+ *  `apply`, but only while `isCurrent()` still holds — so a slow response can't
+ *  overwrite a newer locale/input's translation. */
+function loadInto(req: TranslateRequest, isCurrent: () => boolean, apply: (value: readonly string[]) => void): void {
+  const hit = cache.peek(req);
+  if (hit !== null) {
+    apply(hit);
+    return;
+  }
+  cache
+    .fetch(req)
+    .then((result) => {
+      if (result !== null && isCurrent()) apply(result);
+    })
+    .catch(() => {
+      /* transport rejected — keep the English fallback */
+    });
+}
+
+/** Translated strings when available, falling back to the English source while
+ *  the request is in flight or on failure. `en` and empty inputs never fetch. */
+export function useTranslatedStrings(namespace: string, sentences: Ref<readonly string[]>, locale: Ref<string>): ComputedRef<string[]> {
+  const translated = ref<readonly string[] | null>(null);
+  watchEffect(() => {
+    const lang = locale.value;
+    const sources = sentences.value;
+    translated.value = null; // reset on any input change → source shows meanwhile
+    if (lang === "en" || sources.length === 0) return;
+    const req = { namespace, targetLanguage: lang, sentences: sources };
+    loadInto(
+      req,
+      () => locale.value === lang && sentences.value === sources,
+      (value) => (translated.value = value),
+    );
+  });
+  return computed<string[]>(() => pickTranslated(translated.value, sentences.value));
+}
+
+// ── Test-only hook ──────────────────────────────────────────────────
+// Vitest / node:test usually gets a fresh worker per file, but suites that
+// share a worker reset the singleton cache between cases through this.
+export function __resetTranslatedStringsCacheForTests(): void {
+  cache.clear();
+}

package/src/composables/useVoiceInput.ts

@@ -1,12 +1,12 @@
 // Thin Vue wrapper over the framework-neutral capture controller in
-// `@mulmoclaude/whisper/client` (shared with MulmoTerminal). This file supplies
+// `@mulmoclaude/core/whisper/client` (shared with MulmoTerminal). This file supplies
 // the MulmoClaude-specific transport (api client + route constants) and language
 // mapping, and mirrors the controller's pushed state into Vue refs. The capture
 // logic itself (MediaRecorder + VAD + segment queue) lives in the package.
-// See plans/feat-extract-whisper-package.md.
+// See plans/done/feat-extract-whisper-package.md.
 
 import { onScopeDispose, ref, type Ref } from "vue";
-import { createVoiceCapture, localeToWhisperLanguage, type VoiceCaptureTransport } from "@mulmoclaude/whisper/client";
+import { createVoiceCapture, localeToWhisperLanguage, type VoiceCaptureTransport } from "@mulmoclaude/core/whisper/client";
 import { API_ROUTES } from "../config/apiRoutes";
 import { apiGet, apiPost } from "../utils/api";
 

package/src/config/apiRoutes.ts

@@ -33,11 +33,13 @@ type ResolveRoutes<R extends Readonly<Record<string, RouteSpec>>> = {
   readonly [K in keyof R]: ResolvedRoute;
 };
 type PluginApiRoutesMap<T extends BuiltInPluginMetas> = {
-  readonly [M in T[number] as M extends { readonly apiRoutes: Readonly<Record<string, RouteSpec>> }
-    ? M extends { readonly apiNamespace: infer K extends string }
-      ? K
-      : M["toolName"]
-    : never]: M extends { readonly apiRoutes: infer R extends Readonly<Record<string, RouteSpec>> } ? ResolveRoutes<R> : never;
+  readonly [
+    M in T[number] as M extends { readonly apiRoutes: Readonly<Record<string, RouteSpec>> }
+      ? M extends { readonly apiNamespace: infer K extends string }
+        ? K
+        : M["toolName"]
+      : never
+  ]: M extends { readonly apiRoutes: infer R extends Readonly<Record<string, RouteSpec>> } ? ResolveRoutes<R> : never;
 };
 
 /** Resolve every plugin route into a `ResolvedRoute` keyed by the
@@ -61,6 +63,11 @@ const HOST_API_ROUTES = {
   // order). Single replace-endpoint — no add/remove route sprawl.
   shortcuts: "/api/shortcuts",
 
+  // Dashboard layout (per-tile view mode + order for the favorites grid).
+  // GET reads the list; PUT replaces it wholesale (client owns order /
+  // view mode). Single replace-endpoint, mirroring `shortcuts`.
+  dashboard: "/api/dashboard",
+
   agent: {
     run: "/api/agent",
     cancel: "/api/agent/cancel",
@@ -133,6 +140,25 @@ const HOST_API_ROUTES = {
     upload: "/api/attachments",
   },
 
+  // Sharing: pack an HTML artifact + its referenced local assets into a
+  // self-contained zip (index.html + assets/), streamed as a download.
+  // `packMarkdown` renders markdown / a wiki page to a self-contained
+  // HTML (images inlined) and zips that.
+  share: {
+    pack: "/api/share/pack",
+    packMarkdown: "/api/share/pack-markdown",
+  },
+
+  // Remote host over Firestore (phase 1). The server signs in to Firebase as
+  // the user (connect, body carries a browser-minted Google idToken), runs the
+  // command-loop + presence heartbeat, and exposes its running state. See
+  // plans/feat-remote-host-firestore-list-collections.md.
+  remoteHost: {
+    connect: "/api/remote-host/connect",
+    disconnect: "/api/remote-host/disconnect",
+    status: "/api/remote-host/status",
+  },
+
   mcpTools: {
     list: "/api/mcp-tools",
     invoke: "/api/mcp-tools/:tool",
@@ -167,7 +193,7 @@ const HOST_API_ROUTES = {
   // Local voice input (Mac-only, whisper.cpp). `run` transcribes one
   // audio clip; `model` reports capability + download status; `modelDownload`
   // is the opt-in trigger fired by the Settings → Voice enable toggle.
-  // See plans/feat-voice-input.md.
+  // See plans/done/feat-voice-input.md.
   transcribe: {
     run: "/api/transcribe",
     model: "/api/transcribe/model",
@@ -267,6 +293,14 @@ const HOST_API_ROUTES = {
     /** GET ?id=<viewId> → the custom view's HTML file (global-bearer auth),
      *  read from data/skills/:slug/views/. The parent renders it sandboxed. */
     viewFile: "/api/collections/:slug/view-file",
+    /** GET ?id=<viewId>&locale=<tag> → translation dict for one custom view
+     *  (global-bearer auth) → { locale, dict }. `dict` is the host-picked
+     *  flat map for the requested locale (fallback `"en"`, else `{}`); the
+     *  host never streams other locales' strings. Empty dict + `locale: ""`
+     *  when the view declares no `i18n` file or the file is missing /
+     *  malformed — the view keeps working via `__MC_VIEW.t()`'s key
+     *  fallback. */
+    viewI18n: "/api/collections/:slug/view-i18n",
     /** POST → mint a slug- and capability-scoped token for a custom view
      *  (global-bearer auth) → { token, exp, dataUrl, capabilities }. */
     viewToken: "/api/collections/:slug/view-token",
@@ -280,6 +314,22 @@ const HOST_API_ROUTES = {
     viewDelete: "/api/collections/:slug/views/:viewId",
   },
 
+  // Curated collection registry (receptron/mulmoclaude-collections). The host
+  // server-fetches the published index.json (GitHub Pages) and proxies it to the
+  // /collections Discover tab — the upstream URL is never exposed to the client.
+  collectionsRegistry: {
+    list: "/api/collections-registry",
+    /** GET ?author=&slug= → { entry, schema, meta } for one in-index collection. */
+    preview: "/api/collections-registry/preview",
+    /** POST { author, slug } → fetch + re-validate + install into .claude/skills/,
+     *  normalize dataPath, materialize seed, record provenance. */
+    import: "/api/collections-registry/import",
+    /** POST { slug, author, license?, includeSeed? } → write a registry-contribution
+     *  bundle (collections/<author>/<slug>/ + meta.json + optional seed) under
+     *  data/registry-export/ for the user to open a PR. */
+    export: "/api/collections-registry/export",
+  },
+
   // `scheduler` group migrated to META — see `src/plugins/scheduler/automationsMeta.ts`.
   // Auto-merged via `apiNamespace: "scheduler"`.
 
@@ -345,9 +395,7 @@ const HOST_API_ROUTES = {
 // `defineHostAggregate` is runtime-generic; the cast on the merged
 // result narrows it back to the literal-preserving shape above.
 type ApiRoutesAggregateValue =
-  | (typeof HOST_API_ROUTES)[keyof typeof HOST_API_ROUTES]
-  | Readonly<Record<string, string>>
-  | Readonly<Record<string, ResolvedRoute>>;
+  (typeof HOST_API_ROUTES)[keyof typeof HOST_API_ROUTES] | Readonly<Record<string, string>> | Readonly<Record<string, ResolvedRoute>>;
 
 const API_ROUTES_AGGREGATE = defineHostAggregate<ApiRoutesAggregateValue>(BUILT_IN_PLUGIN_METAS, {
   label: "API_ROUTES",

package/src/config/createFilePolicy.ts

@@ -16,7 +16,7 @@
 // a workspace-relative POSIX string matching `TreeNode.path` for the
 // folder row that should expose the menu.
 
-import { isSafeSlug } from "../lib/wiki-page/slug";
+import { isSafeSlug } from "@mulmoclaude/core/wiki";
 
 export interface CreateFilePolicy {
   /** Workspace-relative POSIX folder path. Matched verbatim against

package/src/config/firebase.ts

@@ -0,0 +1,12 @@
+// Browser-side Firebase init for the remote-host settings page.
+//
+// Initializes the Firebase web app and exposes the Auth instance used by the
+// SettingsRemoteHostTab to run the Google sign-in popup and extract the Google
+// OAuth idToken (which is then POSTed to the server's /connect route).
+import { initializeApp } from "firebase/app";
+import { getAuth } from "firebase/auth";
+
+import { firebaseConfig } from "./firebaseConfig";
+
+export const firebaseApp = initializeApp(firebaseConfig);
+export const auth = getAuth(firebaseApp);