mulmoclaude 0.9.0 → 0.9.2

package/server/utils/markdown/frontmatter.ts

@@ -10,7 +10,7 @@
 // that's not worth it for so little glue. js-yaml does the heavy
 // lifting in both places, identically.
 
-import yaml from "js-yaml";
+import { FAILSAFE_SCHEMA, dump as yamlDump, load as yamlLoad } from "js-yaml";
 
 export interface ParsedMarkdown {
   /** Parsed YAML object. Empty `{}` when the document has no
@@ -71,7 +71,7 @@ export function serializeWithFrontmatter(meta: Record<string, unknown>, body: st
   // one line. `noRefs: true` avoids YAML anchor syntax (`&id001`)
   // which is technically valid but visually noisy in plain-text
   // markdown.
-  const yamlText = yaml.dump(meta, { lineWidth: -1, noRefs: true }).trimEnd();
+  const yamlText = yamlDump(meta, { lineWidth: -1, noRefs: true }).trimEnd();
   return `---\n${yamlText}\n---\n\n${body}`;
 }
 
@@ -93,16 +93,20 @@ export function mergeFrontmatter(existing: Record<string, unknown>, patch: Recor
 }
 
 function safeYamlLoad(text: string): Record<string, unknown> | null {
+  // js-yaml 5.x throws on empty / whitespace-only input where 4.x
+  // returned `undefined`. An empty frontmatter block is "no metadata",
+  // not "malformed", so handle it before the loader.
+  if (text.trim() === "") return {};
   try {
     // `FAILSAFE_SCHEMA` keeps every scalar as a string and skips
     // type coercion. Two motivating cases:
     //   - YAML 1.1 dates (`created: 2026-04-27`) would become a
-    //     `Date` object under DEFAULT_SCHEMA, breaking round-trip.
+    //     `Date` object under CORE_SCHEMA, breaking round-trip.
     //   - Numeric-looking strings (`version: 1.20` → 1.2 under
     //     JSON_SCHEMA) drop trailing zeros on save.
     // For the wiki-history use case — title / created / updated /
     // tags / editor — every value that should be a string IS one.
-    const loaded = yaml.load(text, { schema: yaml.FAILSAFE_SCHEMA });
+    const loaded = yamlLoad(text, { schema: FAILSAFE_SCHEMA });
     if (loaded === null || loaded === undefined) return {};
     if (typeof loaded !== "object" || Array.isArray(loaded)) return null;
     return loaded as Record<string, unknown>;

package/server/utils/regex.ts

@@ -30,9 +30,10 @@ export const SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
 
 // ── Wiki bullet-link parsers ──────────────────────────────────────
 //
-// Moved to `src/lib/wiki-page/index-parse.ts` as part of the pure-
-// lib extraction (#1297). The patterns are still bounded with hard
-// delimiters; the ReDoS-safety rationale travelled with them.
+// Moved to `@mulmoclaude/core/wiki` (`index-parse.ts`) as part of the
+// pure-lib extraction (#1297, then promoted to shared core). The
+// patterns are still bounded with hard delimiters; the ReDoS-safety
+// rationale travelled with them.
 
 // ── Skills body blank-line stripper ───────────────────────────────
 //

package/server/utils/share/packHtml.ts

@@ -0,0 +1,108 @@
+import { readFile } from "fs/promises";
+import { realpathSync } from "fs";
+import path from "path";
+import JSZip from "jszip";
+import { resolveWorkspacePath } from "../files/workspace-io.js";
+import { resolveWithinRoot } from "../files/safe.js";
+import { rewriteHtmlAssets } from "./rewriteAssets.js";
+import { log } from "../../system/logger/index.js";
+
+const LOG_PREFIX = "share";
+
+export interface PackedFile {
+  bundlePath: string;
+  bytes: Buffer;
+}
+
+// A self-contained bundle: the rewritten entry document plus every
+// referenced local asset, ready to zip. `name` is a suggested base
+// filename (no extension) derived from the source page.
+export interface PackedBundle {
+  name: string;
+  files: PackedFile[];
+}
+
+// `resolveWithinRoot` requires an already-realpath'd root. Resolved
+// lazily (not at import) so loading this module never depends on the
+// workspace dir existing yet; the location doesn't change during a run.
+let workspaceRealCache: string | null = null;
+function workspaceReal(): string {
+  if (workspaceRealCache === null) workspaceRealCache = realpathSync(resolveWorkspacePath("."));
+  return workspaceRealCache;
+}
+
+function stripQueryHash(ref: string): string {
+  const cut = ref.search(/[?#]/);
+  return cut === -1 ? ref : ref.slice(0, cut);
+}
+
+// Resolve a workspace-relative path to a contained absolute path, or
+// null if it escapes the workspace / doesn't exist. `resolveWithinRoot`
+// already realpath-checks containment; the extra `path.relative` guard
+// is the form CodeQL's js/path-injection analysis recognizes as a
+// sanitizer (its `startsWith` form isn't), and is redundant at runtime.
+function safeWorkspaceAbs(relFromRoot: string): string | null {
+  const root = workspaceReal();
+  const abs = resolveWithinRoot(root, relFromRoot);
+  if (!abs) return null;
+  const rel = path.relative(root, abs);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
+  return abs;
+}
+
+// Resolve a ref (relative to the HTML file's dir) to workspace bytes.
+// Returns null when the ref escapes the workspace or the file is
+// missing — the caller warns and leaves the (now dangling) link.
+async function readAsset(htmlDir: string, originalRef: string): Promise<Buffer | null> {
+  const relFromRoot = path.posix.normalize(path.posix.join(htmlDir, stripQueryHash(originalRef)));
+  const abs = safeWorkspaceAbs(relFromRoot);
+  if (!abs) return null;
+  try {
+    return await readFile(abs);
+  } catch {
+    return null;
+  }
+}
+
+export async function packHtmlBundle(htmlRelPath: string): Promise<PackedBundle> {
+  const abs = safeWorkspaceAbs(htmlRelPath);
+  if (!abs) throw new Error(`HTML not found or outside workspace: ${htmlRelPath}`);
+  const html = await readFile(abs, "utf-8");
+
+  const { html: rewritten, assets } = rewriteHtmlAssets(html);
+  const htmlDir = path.posix.dirname(htmlRelPath);
+
+  const files: PackedFile[] = [{ bundlePath: "index.html", bytes: Buffer.from(rewritten, "utf-8") }];
+  for (const asset of assets) {
+    const bytes = await readAsset(htmlDir, asset.originalRef);
+    if (bytes === null) {
+      log.warn(LOG_PREFIX, "asset missing or outside workspace; skipped", { ref: asset.originalRef });
+      continue;
+    }
+    files.push({ bundlePath: asset.bundlePath, bytes });
+  }
+
+  const name = path.posix.basename(htmlRelPath).replace(/\.html?$/i, "") || "share";
+  return { name, files };
+}
+
+// Zip a bundle in memory. Bundles are small (one page + a few assets),
+// so an in-memory buffer is simpler than streaming and stays testable.
+export function zipBundle(files: PackedFile[]): Promise<Buffer> {
+  const zip = new JSZip();
+  for (const file of files) zip.file(file.bundlePath, file.bytes);
+  return zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE", compressionOptions: { level: 9 } });
+}
+
+export function safeZipName(name: string): string {
+  const cleaned = name.replace(/[^\w.-]+/g, "_");
+  return `${cleaned || "share"}.zip`;
+}
+
+// One-call pack: bundle → zip → suggested download filename. Shared by
+// the HTTP route (streams the buffer) and the View dispatch (base64).
+export async function packHtmlZip(htmlRelPath: string): Promise<{ filename: string; zip: Buffer }> {
+  const bundle = await packHtmlBundle(htmlRelPath);
+  const zip = await zipBundle(bundle.files);
+  return { filename: safeZipName(bundle.name), zip };
+}

package/server/utils/share/rewriteAssets.ts

@@ -0,0 +1,178 @@
+import { parse, type HTMLElement } from "node-html-parser";
+
+// A local resource referenced by the HTML that must be copied into the
+// bundle. `originalRef` is the reference verbatim as it appears in the
+// source (relative to the HTML file); `bundlePath` is where it lands in
+// the self-contained bundle (always under `assets/`).
+export interface AssetRef {
+  originalRef: string;
+  bundlePath: string;
+}
+
+export interface RewriteResult {
+  html: string;
+  assets: AssetRef[];
+}
+
+const ASSETS_DIR = "assets";
+
+// Refs we never bundle: absolute URLs, protocol-relative, data/blob,
+// in-page anchors, and non-navigational schemes. Everything else is a
+// workspace-relative path the bundle must localize. Root-absolute
+// (`/foo`) is left alone too — without a known base it can't be mapped.
+function isLocalRef(ref: string): boolean {
+  const value = ref.trim();
+  if (value === "") return false;
+  if (value.startsWith("#") || value.startsWith("//") || value.startsWith("/")) return false;
+  return !/^[a-z][a-z0-9+.-]*:/i.test(value);
+}
+
+function stripQueryHash(ref: string): string {
+  const cut = ref.search(/[?#]/);
+  return cut === -1 ? ref : ref.slice(0, cut);
+}
+
+// Safe single-segment filename for a bundle entry. Splits on BOTH path
+// separators — a crafted `..\..\evil.png` must not survive into a zip
+// entry name, where a Windows unzip tool treats `\` as a separator
+// (zip-slip). `.`/`..`/empty collapse to a neutral name.
+function safeAssetName(ref: string): string {
+  const segment = stripQueryHash(ref).split(/[/\\]/).pop() ?? "";
+  return segment === "" || segment === "." || segment === ".." ? "asset" : segment;
+}
+
+function splitSuffix(ref: string): { filePath: string; suffix: string } {
+  const cut = ref.search(/[?#]/);
+  return cut === -1 ? { filePath: ref, suffix: "" } : { filePath: ref.slice(0, cut), suffix: ref.slice(cut) };
+}
+
+// Maps a local ref to its `assets/<name>` slot. The bundled FILE is
+// keyed by the path with `?query`/`#fragment` stripped, so `a.png?v=1`
+// and `a.png?v=2` share one copy; but the rewritten URL keeps each
+// ref's suffix (an SVG `sprite.svg#icon` fragment must survive). A
+// basename collision across different dirs is disambiguated by a short
+// hash of the file path so two `logo.png` don't clobber each other.
+function createAssetMapper() {
+  const byPath = new Map<string, string>();
+  const usedNames = new Set<string>();
+  const assets: AssetRef[] = [];
+
+  const hash = (value: string): string => {
+    let acc = 0;
+    for (const char of value) acc = (acc * 31 + char.charCodeAt(0)) | 0;
+    return (acc >>> 0).toString(36);
+  };
+
+  const bundlePathFor = (filePath: string): string => {
+    const existing = byPath.get(filePath);
+    if (existing) return existing;
+    const base = safeAssetName(filePath);
+    const name = usedNames.has(base) ? `${hash(filePath)}-${base}` : base;
+    usedNames.add(name);
+    const bundlePath = `${ASSETS_DIR}/${name}`;
+    byPath.set(filePath, bundlePath);
+    assets.push({ originalRef: filePath, bundlePath });
+    return bundlePath;
+  };
+
+  const map = (originalRef: string): string => {
+    const { filePath, suffix } = splitSuffix(originalRef);
+    return bundlePathFor(filePath) + suffix;
+  };
+
+  return { map, assets };
+}
+
+function rewriteCssUrls(css: string, map: (ref: string) => string): string {
+  return css.replace(/url\(([^)]*)\)/gi, (whole, inner: string) => {
+    const raw = inner.trim();
+    const quote = raw.startsWith('"') || raw.startsWith("'") ? raw[0] : "";
+    const ref = quote ? raw.slice(1, -1) : raw;
+    if (!isLocalRef(ref)) return whole;
+    return `url(${quote}${map(ref)}${quote})`;
+  });
+}
+
+function isSrcsetWs(char: string): boolean {
+  return char === " " || char === "\t" || char === "\n" || char === "\r" || char === "\f";
+}
+
+// One srcset candidate: a URL (a run of non-whitespace, so a data: URI's
+// internal commas stay intact) whose trailing commas are separators, then
+// an optional descriptor up to the next comma. Only local URLs are
+// rewritten; everything else is emitted verbatim. Returns the new cursor.
+function rewriteSrcsetCandidate(value: string, start: number, map: (ref: string) => string, out: string[]): number {
+  let index = start;
+  while (index < value.length && !isSrcsetWs(value[index])) index++;
+  let url = value.slice(start, index);
+  let trailing = "";
+  while (url.endsWith(",")) {
+    url = url.slice(0, -1);
+    trailing += ",";
+  }
+  out.push(isLocalRef(url) ? map(url) : url, trailing);
+  if (trailing !== "") return index;
+  const descStart = index;
+  while (index < value.length && value[index] !== ",") index++;
+  out.push(value.slice(descStart, index));
+  return index;
+}
+
+// WHATWG-style srcset walk: candidates are comma-separated, but because a
+// URL is a non-whitespace run, `data:` URIs (whose payload contains commas)
+// are never split. Separators / whitespace / descriptors are preserved.
+function rewriteSrcset(value: string, map: (ref: string) => string): string {
+  const out: string[] = [];
+  let index = 0;
+  while (index < value.length) {
+    const sepStart = index;
+    while (index < value.length && (isSrcsetWs(value[index]) || value[index] === ",")) index++;
+    out.push(value.slice(sepStart, index));
+    if (index < value.length) index = rewriteSrcsetCandidate(value, index, map, out);
+  }
+  return out.join("");
+}
+
+// Embedded resources only. `a[href]` is intentionally excluded — it is
+// navigation, not an inlined asset, and rewriting it would point at a
+// file the single-page bundle doesn't carry.
+const URL_ATTRS: readonly { selector: string; attr: string }[] = [
+  { selector: "img[src]", attr: "src" },
+  { selector: "script[src]", attr: "src" },
+  { selector: "source[src]", attr: "src" },
+  { selector: "link[href]", attr: "href" },
+  { selector: "audio[src]", attr: "src" },
+  { selector: "video[src]", attr: "src" },
+  { selector: "video[poster]", attr: "poster" },
+  { selector: "use[href]", attr: "href" },
+];
+
+function rewriteAttrs(root: HTMLElement, map: (ref: string) => string): void {
+  for (const { selector, attr } of URL_ATTRS) {
+    for (const element of root.querySelectorAll(selector)) {
+      const ref = element.getAttribute(attr);
+      if (ref && isLocalRef(ref)) element.setAttribute(attr, map(ref));
+    }
+  }
+  for (const element of root.querySelectorAll("[srcset]")) {
+    const value = element.getAttribute("srcset");
+    if (value) element.setAttribute("srcset", rewriteSrcset(value, map));
+  }
+  for (const element of root.querySelectorAll("style")) {
+    element.set_content(rewriteCssUrls(element.textContent, map));
+  }
+  for (const element of root.querySelectorAll("[style]")) {
+    const value = element.getAttribute("style");
+    if (value) element.setAttribute("style", rewriteCssUrls(value, map));
+  }
+}
+
+// Rewrites every local resource reference in `html` to point at a
+// co-located `assets/<name>`, returning the rewritten document plus the
+// list of refs to copy. Pure: no filesystem or network.
+export function rewriteHtmlAssets(html: string): RewriteResult {
+  const root = parse(html, { comment: true });
+  const mapper = createAssetMapper();
+  rewriteAttrs(root, mapper.map);
+  return { html: root.toString(), assets: mapper.assets };
+}

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

@@ -4,8 +4,14 @@
 // claude CLI spawn code).
 
 import path from "node:path";
-
-export const CHAT_DIR = "chat";
+import { WORKSPACE_DIRS } from "../paths.js";
+
+// Sourced from WORKSPACE_DIRS so the layout move in #284
+// (`chat/` → `conversations/chat/`) can't drift again — a hardcoded
+// literal here silently detached the indexer from the real session
+// tree between Apr and Jul 2026, leaving every session listing
+// preview to fall back to `meta.firstUserMessage` (issue #1902).
+export const CHAT_DIR = WORKSPACE_DIRS.chat;
 export const INDEX_DIR = "index";
 export const MANIFEST_FILE = "manifest.json";
 

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

@@ -39,23 +39,31 @@ const SUMMARY_SCHEMA = {
   required: ["title", "summary", "keywords"],
 };
 
-// Prompt-building constants.
-const MAX_INPUT_CHARS = 8000;
-const HEAD_CHARS = 3000;
-const TAIL_CHARS = 5000;
-const PER_MESSAGE_MAX = 500;
+// Model used for summarization. Sonnet, not haiku: the title is the
+// primary way a user finds a past chat, so a weak title makes the
+// history list unusable. One cheap structured call per session is
+// negligible next to the agent turns it summarizes.
+const SUMMARY_MODEL = "sonnet";
+
+// Prompt-building constants. Sized for Sonnet's large context: the
+// window is wide enough to carry a long, topic-shifting session's
+// middle (not just head + tail), and per-message clipping keeps the
+// substance of long turns. Exported so the summarizer tests derive
+// their fixtures from them rather than hard-coding sizes that rot.
+export const MAX_INPUT_CHARS = 30000;
+export const HEAD_CHARS = 12000;
+export const TAIL_CHARS = 16000;
+export const PER_MESSAGE_MAX = 1500;
 
 // Spawn / budget constants.
 const DEFAULT_TIMEOUT_MS = 2 * ONE_MINUTE_MS;
 // Budget cap per summarization call, forwarded to `claude
-// --max-budget-usd`. Previously 0.05 but that was tight enough
-// that a first-burst call — which pays a one-time cache creation
-// cost on haiku (~28k cache-creation tokens) — would trip the cap
-// and fail with `error_max_budget_usd` even for tiny 600-char
-// transcripts. 0.15 leaves comfortable headroom for cache
-// creation + a generous output allowance while still capping a
-// full 100-session backfill to well under $20.
-const MAX_BUDGET_USD = 0.15;
+// --max-budget-usd`. A first-burst call pays a one-time cache-creation
+// cost (~28k tokens) that on Sonnet's pricing would trip a tighter cap
+// and fail with `error_max_budget_usd` — yielding NO title at all.
+// 0.40 leaves headroom for cache creation plus the wider input window
+// while still bounding a full backfill.
+const MAX_BUDGET_USD = 0.4;
 
 // Any module that wants to drive the summarizer — including the
 // indexer — takes a SummarizeFn so tests can supply a deterministic
@@ -95,7 +103,7 @@ export function extractText(jsonlContent: string): string {
   return parts.join("\n\n");
 }
 
-// Long sessions are clipped to first ~3000 + last ~5000 chars so
+// Long sessions are clipped to first ~12000 + last ~16000 chars so
 // claude sees both the original topic and the most recent state.
 // Distinct from the simple-tail `truncate()` in `server/utils/text.ts`
 // — the summarizer needs context from both ends, not just the head.
@@ -184,7 +192,7 @@ function spawnClaudeSummarize(input: string, timeoutMs: number): Promise<string>
       "--output-format",
       "json",
       "--model",
-      "haiku",
+      SUMMARY_MODEL,
       "--max-budget-usd",
       String(MAX_BUDGET_USD),
       "--json-schema",

package/server/workspace/collections/configure.ts

@@ -1,14 +1,15 @@
-// Wire @mulmoclaude/collection-plugin/server to MulmoClaude's workspace,
+// Wire @mulmoclaude/core/collection/server to MulmoClaude's workspace,
 // logger, and path layout. Imported for side effect at the very top of
 // server/index.ts so the binding is set before any collection storage
 // operation runs. MulmoTerminal has its own equivalent shim.
 import path from "node:path";
-import { configureCollectionHost } from "@mulmoclaude/collection-plugin/server";
+import { configureCollectionHost } from "@mulmoclaude/core/collection/server";
 import { workspacePath } from "../workspace.js";
 import { log } from "../../system/logger/index.js";
 import { WORKSPACE_DIRS } from "../paths.js";
+import { WORKSPACE_FILES } from "../../../src/config/workspacePaths.js";
 import { USER_SKILLS_DIR, projectSkillsDir } from "../skills/paths.js";
-import { feedsRoot } from "../feeds/paths.js";
+import { feedsRoot } from "@mulmoclaude/core/feeds/paths";
 import { isPresetSlug } from "../skills-preset.js";
 
 configureCollectionHost({
@@ -20,6 +21,7 @@ configureCollectionHost({
     feedsRoot,
     skillsStagingDir: (root) => path.join(root, WORKSPACE_DIRS.skillsStaging),
     archiveDir: WORKSPACE_DIRS.archive,
+    collectionsRegistriesConfig: (root) => path.join(root, ...WORKSPACE_FILES.collectionsRegistries.split("/")),
   },
   isPresetSlug,
 });

package/server/workspace/collections/index.ts

@@ -6,11 +6,11 @@ export {
   CollectionSchemaZ,
   resolveDataDir,
   type LoadedCollection,
-} from "@mulmoclaude/collection-plugin/server";
-export { validateCollectionRecords, validateRecordObject, COMPUTED_TYPES, type RecordIssue } from "@mulmoclaude/collection-plugin/server";
-export { enrichItems } from "@mulmoclaude/collection-plugin/server";
-export { deleteCollection, deleteCollectionRefusalMessage, type DeleteCollectionResult } from "@mulmoclaude/collection-plugin/server";
-export { deleteCustomView, type DeleteViewResult } from "@mulmoclaude/collection-plugin/server";
+} from "@mulmoclaude/core/collection/server";
+export { validateCollectionRecords, validateRecordObject, COMPUTED_TYPES, type RecordIssue } from "@mulmoclaude/core/collection/server";
+export { enrichItems } 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 {
   listItems,
   readItem,
@@ -20,11 +20,13 @@ export {
   resolveCreateItemId,
   readSkillTemplate,
   readCustomViewHtml,
+  readCustomViewI18n,
   buildActionSeedPrompt,
   buildCollectionActionSeedPrompt,
+  promptPathsFor,
   type WriteItemResult,
   type DeleteItemResult,
-} from "@mulmoclaude/collection-plugin/server";
+} from "@mulmoclaude/core/collection/server";
 export type {
   CollectionSchema,
   CollectionAction,

package/server/workspace/collections/notifications.ts

@@ -1,5 +1,5 @@
 // Collection-completion bell reconciler — thin host binding over
-// @mulmoclaude/collection-watchers. The convergent reconcile logic lives
+// @mulmoclaude/core/collection-watchers. The convergent reconcile logic lives
 // in the shared package; this file supplies MulmoClaude's notification
 // taxonomy (publish under "todo", priority→severity mapping) and in-app
 // routing (the `/collections/<slug>?selected=<itemId>` deep-link) via a
@@ -21,7 +21,7 @@ import {
   type LegacyNotifierPluginData,
 } from "../../events/notifications.js";
 import { log } from "../../system/logger/index.js";
-import { configureCollectionWatchers, type CollectionNotificationAdapter, type CompletionPriority } from "@mulmoclaude/collection-watchers";
+import { configureCollectionWatchers, type CollectionNotificationAdapter, type CompletionPriority } from "@mulmoclaude/core/collection-watchers";
 
 // Re-export the reconciler surface verbatim from the package.
 export {
@@ -31,7 +31,7 @@ export {
   clearItemNotification,
   resolveDisplayLabel,
   itemIsDone,
-} from "@mulmoclaude/collection-watchers";
+} from "@mulmoclaude/core/collection-watchers";
 
 const COLLECTION_PLUGIN_PKG = legacyKindToPluginPkg(NOTIFICATION_KINDS.todo);
 

package/server/workspace/collections/types.ts

@@ -1,6 +1,6 @@
 // The canonical collection schema types now live in
-// @mulmoclaude/collection-plugin (single source of truth, also consumed by
+// @mulmoclaude/core/collection (single source of truth, also consumed by
 // the host frontend via src/components/collectionTypes.ts and by
 // MulmoTerminal). Re-exported here so the many `./types.js` importers under
 // server/workspace/collections keep compiling unchanged.
-export * from "@mulmoclaude/collection-plugin";
+export * from "@mulmoclaude/core/collection";

package/server/workspace/collections/watcher.ts

@@ -1,5 +1,5 @@
 // Collection watchers — thin host binding over
-// @mulmoclaude/collection-watchers. The fs.watch plumbing lives in the
+// @mulmoclaude/core/collection-watchers. The fs.watch plumbing lives in the
 // shared package; this file just ensures the host's notification adapter
 // is configured (the `./notifications.js` side-effect import) and
 // re-exports the watcher surface existing callers + tests import from
@@ -16,4 +16,4 @@ export {
   _tickTimeTriggersForTesting,
   _scheduleItemReconcileForTesting,
   type CollectionWatcherOptions,
-} from "@mulmoclaude/collection-watchers";
+} from "@mulmoclaude/core/collection-watchers";

package/server/workspace/feeds/configure.ts

@@ -0,0 +1,24 @@
+// Wire @mulmoclaude/core/feeds/server to this host's workspace, logger, atomic
+// writer, and agent-ingest worker launcher. Called once from server/index.ts
+// BEFORE scheduler init (catch-up can fire `system:feed-refresh` immediately, so
+// wiring after would make those first refreshes fail "host not configured").
+//
+// The worker launcher (`spawnSystemWorker`) is INJECTED by the caller rather
+// than imported here: it lives in the routes layer, and workspace code must not
+// import routes (a workspace→routes cycle is exactly what the old
+// `setAgentWorkerRunner` seam — now folded into `spawnWorker` — existed to
+// avoid). `server/index.ts` (the host entry) is allowed to bridge the two.
+import { configureFeedsHost, type AgentWorkerRunner } from "@mulmoclaude/core/feeds/server";
+import { workspacePath } from "../workspace.js";
+import { log } from "../../system/logger/index.js";
+import { writeFileAtomic } from "../../utils/files/atomic.js";
+
+export function configureFeeds(spawnWorker: AgentWorkerRunner): void {
+  configureFeedsHost({
+    workspaceRoot: workspacePath,
+    log,
+    // Feed state files use the plain (non-uniqueTmp) atomic write, as before.
+    writeFileAtomic: (filePath, content) => writeFileAtomic(filePath, content),
+    spawnWorker,
+  });
+}

package/server/workspace/hooks/handlers/skillBridge.ts

@@ -1,4 +1,4 @@
-// Skill-bridge HOST adapter — thin wiring over @mulmoclaude/skill-bridge.
+// Skill-bridge HOST adapter — thin wiring over @mulmoclaude/core/skill-bridge.
 //
 // The agent writes skill drafts under `data/skills/<slug>/` (a plain data dir, no
 // `.claude/` permission special-case); the shared package decides which writes are
@@ -26,7 +26,7 @@ import {
   mirrorSkillWrite,
   mirrorSkillDelete,
   type BridgeTarget,
-} from "@mulmoclaude/skill-bridge";
+} from "@mulmoclaude/core/skill-bridge";
 import { buildAuthPost, safePost, serverLog } from "../shared/sidecar.js";
 import type { HookPayload } from "../shared/stdin.js";
 import { extractCommand, extractFilePath, extractToolName } from "../shared/stdin.js";

package/server/workspace/hooks/handlers/wikiSnapshot.ts

@@ -6,7 +6,7 @@
 // carries a single PostToolUse entry instead of one per hook source.
 
 import path from "node:path";
-import { wikiSlugFromAbsPath } from "../../../../src/lib/wiki-page/paths.js";
+import { wikiSlugFromAbsPath } from "@mulmoclaude/core/wiki/paths";
 import { buildAuthPost, safePost } from "../shared/sidecar.js";
 import type { HookPayload } from "../shared/stdin.js";
 import { extractFilePath, extractSessionId, extractToolName } from "../shared/stdin.js";

package/server/workspace/paths.ts

@@ -119,6 +119,13 @@ const HOST_WORKSPACE_DIRS = {
   // Non-skill data-source feed registry: feeds/<slug>/schema.json (+
   // _state.json). Records land under each schema's dataPath (data/feeds/*).
   feeds: "feeds",
+  // Retrieval state for NON-feed collections with an `ingest` block
+  // (`kind: "agent"` on a skill-backed collection). Feeds keep their state
+  // at feeds/<slug>/_state.json; skill collections can't (a feeds/<slug>/
+  // dir without schema.json confuses feed discovery, and _state.json must
+  // never live in a collection's dataDir where listItems would read it as a
+  // record). One file per collection: data/ingest-state/<slug>.json.
+  ingestState: "data/ingest-state",
   translation: "data/translation",
   // Pasted/dropped chat attachments — saved at upload time so the
   // LLM can be handed a stable workspace path instead of inline
@@ -216,7 +223,7 @@ const HOST_WORKSPACE_DIRS = {
   // git) — since model files are large binaries that must stay out of
   // the git-tracked tree. Created lazily on first download, never
   // eagerly (most users never enable voice input). See
-  // plans/feat-voice-input.md.
+  // plans/done/feat-voice-input.md.
   models: "models",
   // Runtime-loaded plugins (#1043 C-2). The `plugins/` directory holds
   // user-installed npm-published plugin tarballs; `.cache/<name>/<ver>/`

package/server/workspace/skills/catalog.ts

@@ -187,9 +187,7 @@ export interface CatalogEntryDetail {
 }
 
 export type CatalogDetailResult =
-  | { kind: "ok"; detail: CatalogEntryDetail }
-  | { kind: "not-found"; source: CatalogSource; slug: string }
-  | { kind: "invalid-slug"; slug: string };
+  { kind: "ok"; detail: CatalogEntryDetail } | { kind: "not-found"; source: CatalogSource; slug: string } | { kind: "invalid-slug"; slug: string };
 
 /** Read one catalog entry's SKILL.md and return the description +
  *  body. The same `safeSlugName` taint-launder used by the star

package/server/workspace/skills/external/catalog.ts

@@ -159,9 +159,7 @@ export interface ExternalCatalogDetail {
 }
 
 export type ExternalCatalogDetailResult =
-  | { kind: "ok"; detail: ExternalCatalogDetail }
-  | { kind: "invalid-id" }
-  | { kind: "not-found"; repoId: string; skillFolder: string };
+  { kind: "ok"; detail: ExternalCatalogDetail } | { kind: "invalid-id" } | { kind: "not-found"; repoId: string; skillFolder: string };
 
 interface ResolvedSource {
   repoId: string;

package/server/workspace/skills/paths.ts

@@ -10,13 +10,14 @@
 // chars. Same rule as `server/sources/paths.ts#isValidSlug` — keep
 // them in sync manually.
 
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { claudeSkillsDir } from "../../utils/claudeConfigPath.js";
 
 export const SKILL_FILE = "SKILL.md";
 
-/** `~/.claude/skills/` — user scope, read-only from MulmoClaude. */
-export const USER_SKILLS_DIR = join(homedir(), ".claude", "skills");
+/** `<claudeConfigDir>/skills/` — user scope, read-only from MulmoClaude.
+ *  Default `~/.claude/skills/`; override via `CLAUDE_CONFIG_DIR` (issue #87 §2). */
+export const USER_SKILLS_DIR = claudeSkillsDir();
 
 /** `<workspaceRoot>/.claude/skills/` — project scope, writable. */
 export function projectSkillsDir(workspaceRoot: string): string {