mulmoclaude 0.5.2 → 0.6.0

package/src/plugins/markdown/View.vue

@@ -26,10 +26,32 @@
       </div>
       <div class="markdown-content-wrapper">
         <div class="p-4">
+          <!-- Frontmatter properties panel (FileContentRenderer-style)
+               — only rendered when the file has a `---\n...\n---`
+               header. Lazy-on-write means most existing files don't
+               have one yet (#895). -->
+          <div v-if="mdDoc.fields.length > 0" class="mb-3 rounded border border-gray-200 bg-gray-50 p-3 text-xs">
+            <div v-for="field in mdDoc.fields" :key="field.key" class="flex items-baseline gap-2 py-0.5">
+              <span class="font-semibold text-gray-600 shrink-0">{{ field.key }}:</span>
+              <template v-if="Array.isArray(field.value)">
+                <span class="flex flex-wrap gap-1">
+                  <span
+                    v-for="(item, idx) in field.value"
+                    :key="String(idx) + ':' + formatScalarField(item)"
+                    class="rounded-full bg-white border border-gray-300 px-2 py-0.5 text-gray-700"
+                  >
+                    {{ formatScalarField(item) }}
+                  </span>
+                </span>
+              </template>
+              <span v-else class="text-gray-800 break-words">{{ formatScalarField(field.value) }}</span>
+            </div>
+          </div>
           <!-- Click delegation: a single listener on the wrapper picks
                up every interactive checkbox inserted by v-html. We
                cannot bind @click directly on each `<input>` because
                v-html bypasses Vue's template compiler. -->
+          <!-- eslint-disable-next-line vue/no-v-html -- marked.parse output of app-owned markdown content; trusted in-process render -->
           <div class="markdown-content prose prose-slate max-w-none" @click="onMarkdownClick" v-html="renderedHtml"></div>
         </div>
       </div>
@@ -58,18 +80,20 @@
 import { computed, ref, watch, nextTick } from "vue";
 import { useI18n } from "vue-i18n";
 import { marked } from "marked";
-
-const { t } = useI18n();
+import { formatScalarField, useMarkdownDoc } from "../../composables/useMarkdownDoc";
 import type { ToolResult } from "gui-chat-protocol";
-import { isFilePath, type MarkdownToolData } from "./definition";
+import { isFilePath, type MarkdownToolData, type DocumentEndpoints } from "./definition";
 import { rewriteMarkdownImageRefs } from "../../utils/image/rewriteMarkdownImageRefs";
 import { findTaskLines, makeTasksInteractive, toggleTaskAt } from "../../utils/markdown/taskList";
 import { usePdfDownload } from "../../composables/usePdfDownload";
 import { apiGet, apiPut } from "../../utils/api";
-import { API_ROUTES } from "../../config/apiRoutes";
+import { pluginEndpoints } from "../api";
 import { useClipboardCopy } from "../../composables/useClipboardCopy";
 import { buildPdfFilename } from "../../utils/files/filename";
 import { useAppApi } from "../../composables/useAppApi";
+import { useFileChange } from "../../composables/useFileChange";
+
+const { t } = useI18n();
 
 const props = defineProps<{
   selectedResult: ToolResult<MarkdownToolData>;
@@ -94,6 +118,9 @@ const loadError = ref<string | null>(null);
 const markdownContent = ref("");
 const editableMarkdown = ref("");
 
+const endpoints = pluginEndpoints<DocumentEndpoints>("markdown");
+const filesEndpoints = pluginEndpoints<{ content: string }>("files");
+
 async function fetchMarkdownContent(): Promise<void> {
   loadError.value = null;
   const raw = props.selectedResult.data?.markdown;
@@ -104,7 +131,7 @@ async function fetchMarkdownContent(): Promise<void> {
   }
   if (isFilePath(raw)) {
     loading.value = true;
-    const result = await apiGet<{ content?: string }>(API_ROUTES.files.content, {
+    const result = await apiGet<{ content?: string }>(filesEndpoints.content, {
       path: raw,
     });
     if (!result.ok) {
@@ -128,9 +155,43 @@ async function fetchMarkdownContent(): Promise<void> {
 // Fetch on mount
 fetchMarkdownContent();
 
-const hasChanges = computed(() => {
-  return editableMarkdown.value !== markdownContent.value;
+const hasChanges = computed(() => editableMarkdown.value !== markdownContent.value);
+
+// Subscribe to per-file change events so any tab / browser / agent run
+// that overwrites the file refreshes this view automatically. The path
+// passed in is the workspace-relative `data.markdown` (only valid when
+// `isFilePath` — inline legacy content has no on-disk twin).
+const watchedPath = computed(() => {
+  const raw = props.selectedResult.data?.markdown;
+  return typeof raw === "string" && isFilePath(raw) ? raw : null;
 });
+const { version: fileVersion } = useFileChange(watchedPath);
+
+// Declared early so the `fileVersion` watcher below can reach into the
+// `<details>` element to close the editor when a remote write lands.
+const sourceDetails = ref<HTMLDetailsElement>();
+
+// Remote write: refetch so the rendered view tracks disk. If the
+// editor is open we close it first — `fileVersion` only fires once
+// per remote write, so leaving the panel open and skipping the fetch
+// would strand the view on stale content until the next write
+// (#1001 P1). Discarding in-progress edits is rare enough to be
+// acceptable; a "remote changed" banner is queued for a follow-up —
+// see plans/done/feat-file-change-pubsub.md.
+watch(fileVersion, (current, previous) => {
+  if (current === 0 || current === previous) return;
+  if (sourceDetails.value?.open) {
+    sourceDetails.value.open = false;
+  }
+  void fetchMarkdownContent();
+});
+
+// Frontmatter-aware view of the loaded content — separates the
+// `---\n...\n---` header (rendered as a properties panel) from the
+// markdown body (passed to marked). Without this split the header
+// would render as a stray `<hr>` plus key:value plain text in
+// every file the LLM saved with frontmatter (#895 PR A).
+const mdDoc = useMarkdownDoc(markdownContent);
 
 const renderedHtml = computed(() => {
   if (!markdownContent.value) return "";
@@ -142,7 +203,7 @@ const renderedHtml = computed(() => {
   // references get rewritten.
   const raw = props.selectedResult.data?.markdown;
   const basePath = typeof raw === "string" && isFilePath(raw) ? raw.slice(0, raw.lastIndexOf("/")) : "";
-  const withImages = rewriteMarkdownImageRefs(markdownContent.value, basePath);
+  const withImages = rewriteMarkdownImageRefs(mdDoc.value.body, basePath);
   // Strip the `disabled=""` attribute marked puts on GFM task
   // checkboxes and tag them so `onMarkdownClick` can find them
   // (#775). Inline content (no file backing) gets the same
@@ -167,12 +228,11 @@ watch(
   },
 );
 
-const sourceDetails = ref<HTMLDetailsElement>();
 const editing = ref(false);
 const { copied, copy } = useClipboardCopy();
 
 function onDetailsToggle(event: Event) {
-  const open = (event.target as HTMLDetailsElement).open;
+  const { open } = event.target as HTMLDetailsElement;
   editing.value = open;
   if (!open) {
     editableMarkdown.value = markdownContent.value;
@@ -194,7 +254,7 @@ async function downloadPdf() {
   if (!markdownContent.value) return;
   const prefix = props.selectedResult.data?.filenamePrefix;
   const rawName = prefix || props.selectedResult.title || "";
-  const uuid = props.selectedResult.uuid;
+  const { uuid } = props.selectedResult;
   const filename = buildPdfFilename({
     name: rawName,
     fallback: "document",
@@ -215,7 +275,7 @@ async function applyMarkdown() {
   // (e.g. the YYYY/MM partitions added in #764).
   if (isFilePath(raw)) {
     saving.value = true;
-    const result = await apiPut<unknown>(API_ROUTES.plugins.updateMarkdown, {
+    const result = await apiPut<unknown>(endpoints.update.url, {
       relativePath: raw,
       markdown: editableMarkdown.value,
     });
@@ -267,7 +327,7 @@ async function persistTaskMarkdown(relativePath: string, markdown: string): Prom
   // on screen, and persisting it would clobber unrelated state.
   if (props.selectedResult.data?.markdown !== relativePath) return;
 
-  const result = await apiPut<unknown>(API_ROUTES.plugins.updateMarkdown, {
+  const result = await apiPut<unknown>(endpoints.update.url, {
     relativePath,
     markdown,
   });
@@ -294,7 +354,7 @@ async function persistTaskMarkdown(relativePath: string, markdown: string): Prom
 }
 
 function onMarkdownClick(event: MouseEvent): void {
-  const target = event.target;
+  const { target } = event;
   if (!(target instanceof HTMLInputElement)) return;
   if (target.type !== "checkbox") return;
   if (!target.classList.contains("md-task")) return;
@@ -317,20 +377,27 @@ function onMarkdownClick(event: MouseEvent): void {
   // it as a task; marked treats it as code) — toggling source by
   // index would corrupt the file. Refuse all clicks when this
   // happens.
-  const sourceTasks = findTaskLines(markdownContent.value);
+  // Walk only the body (the same source `marked` rendered) so
+  // frontmatter contents containing `- [ ]`-shaped YAML never
+  // collide with task counting (#895 PR A). The prefix is
+  // preserved byte-for-byte and re-attached after the toggle.
+  const { body } = mdDoc.value;
+  const prefix = markdownContent.value.slice(0, markdownContent.value.length - body.length);
+  const sourceTasks = findTaskLines(body);
   if (sourceTasks.length !== taskInputs.length) {
     target.checked = !target.checked;
     saveError.value = t("pluginMarkdown.taskCountMismatch");
     return;
   }
 
-  const updated = toggleTaskAt(markdownContent.value, taskIndex);
-  if (updated === null) {
+  const updatedBody = toggleTaskAt(body, taskIndex);
+  if (updatedBody === null) {
     // Source/DOM drift — refuse to write something we can't trace.
     target.checked = !target.checked;
     return;
   }
 
+  const updated = prefix + updatedBody;
   // Optimistic local update — v-html will re-render and the
   // textarea (if anyone opens it next) sees the same content.
   markdownContent.value = updated;

package/src/plugins/markdown/definition.ts

@@ -1,6 +1,12 @@
 import type { ToolDefinition } from "gui-chat-protocol";
+import { META } from "./meta";
+import type { ResolvedRoute } from "../meta-types";
 
-export const TOOL_NAME = "presentDocument";
+export const TOOL_NAME = META.toolName;
+/** Resolved-URL view of the markdown plugin's routes — `{ method,
+ *  url }` per route key, with the `/api/markdown` prefix already
+ *  composed by the host. */
+export type DocumentEndpoints = { readonly [K in keyof typeof META.apiRoutes]: ResolvedRoute };
 
 export interface MarkdownToolData {
   markdown: string;

package/src/plugins/markdown/index.ts

@@ -1,18 +1,20 @@
-import type { ToolPlugin } from "../../tools/types";
+import type { PluginRegistration, ToolPlugin } from "../../tools/types";
 import type { ToolResult } from "gui-chat-protocol";
-import toolDefinition, { TOOL_NAME } from "./definition";
-import type { MarkdownToolData } from "./definition";
+import toolDefinition, { TOOL_NAME, type DocumentEndpoints, type MarkdownToolData } from "./definition";
+import { pluginEndpoints } from "../api";
+import { wrapWithScope } from "../scope";
 import View from "./View.vue";
 import Preview from "./Preview.vue";
-import { apiPost } from "../../utils/api";
-import { API_ROUTES } from "../../config/apiRoutes";
+import { apiCall } from "../../utils/api";
 import { makeUuid } from "../../utils/id";
 
 const markdownPlugin: ToolPlugin<MarkdownToolData> = {
   toolDefinition,
 
   async execute(_context, args) {
-    const result = await apiPost<ToolResult<MarkdownToolData>>(API_ROUTES.plugins.presentDocument, args);
+    const endpoints = pluginEndpoints<DocumentEndpoints>("markdown");
+    const { method, url } = endpoints.create;
+    const result = await apiCall<ToolResult<MarkdownToolData>>(url, { method, body: args });
     if (!result.ok) {
       return {
         toolName: TOOL_NAME,
@@ -29,9 +31,14 @@ const markdownPlugin: ToolPlugin<MarkdownToolData> = {
 
   isEnabled: () => true,
   generatingMessage: "Creating document...",
-  viewComponent: View,
-  previewComponent: Preview,
+  viewComponent: wrapWithScope("markdown", View),
+  previewComponent: wrapWithScope("markdown", Preview),
 };
 
 export default markdownPlugin;
 export { TOOL_NAME };
+
+export const REGISTRATION: PluginRegistration = {
+  toolName: TOOL_NAME,
+  entry: markdownPlugin,
+};

package/src/plugins/markdown/meta.ts

@@ -0,0 +1,16 @@
+import { definePluginMeta } from "../meta-types";
+
+export const META = definePluginMeta({
+  toolName: "presentDocument",
+  apiNamespace: "markdown",
+  apiRoutes: {
+    /** POST /api/markdown — create a new markdown document. */
+    create: { method: "POST", path: "" },
+    /** PUT /api/markdown/update — overwrite an existing document.
+     *  Body carries the workspace-relative path so the route doesn't
+     *  have to reconstruct one from a basename — required after #764
+     *  sharded artifact storage by YYYY/MM. */
+    update: { method: "PUT", path: "/update" },
+  },
+  mcpDispatch: "create",
+});

package/src/plugins/meta-types.ts

@@ -0,0 +1,97 @@
+// Shape every built-in plugin's `meta.ts` exports as `META`.
+// Host aggregators (src/config/*, server/workspace/paths.ts) iterate
+// over `BUILT_IN_PLUGIN_METAS` and auto-merge the per-dimension
+// records. Plugin-specific literals never appear in host code — the
+// plugin owns what the plugin owns.
+//
+// Browser-safe: no Vue / no Node-only imports. Both server and
+// frontend can import this file (and via it, every plugin's META).
+
+/** HTTP methods the route registry recognises. */
+export type RouteMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+
+/** A single route the plugin owns. The host composes the full URL
+ *  as `/api/<apiNamespace><path>`; consumers read both `method` and
+ *  the resolved `url` from the host registry. */
+export interface RouteSpec {
+  readonly method: RouteMethod;
+  /** Sub-path under the namespace (`""` = the namespace root,
+   *  `"/:id"` = a parameterised child). Express path syntax. */
+  readonly path: string;
+}
+
+/** Resolved route — what the host registry hands back to consumers
+ *  (server route registration AND client `apiCall`). The plugin
+ *  declares `{ method, path }`; the host adds the `/api/<ns>` prefix
+ *  and exposes `{ method, url }`. */
+export interface ResolvedRoute {
+  readonly method: RouteMethod;
+  /** Full Express path including `/api/<namespace>` prefix. */
+  readonly url: string;
+}
+
+/** Type-checking helper for a plugin's `meta.ts` literal. The
+ *  `const` type parameter narrows nested literals (`toolName:
+ *  "manageX"`, `apiRoutes.foo.path: "/:id"`, …) so host aggregators
+ *  see the same string-literal types they would with
+ *  `as const satisfies PluginMeta` — minus the dual annotation
+ *  noise. Plugin authors write:
+ *
+ *  ```ts
+ *  export const META = definePluginMeta({
+ *    toolName: "manageX",
+ *    apiNamespace: "x",
+ *    apiRoutes: {
+ *      dispatch: { method: "POST", path: "" },
+ *    },
+ *  });
+ *  ``` */
+export function definePluginMeta<const T extends PluginMeta>(meta: T): T {
+  return meta;
+}
+
+/** A plugin's central-registry-facing metadata. */
+export interface PluginMeta {
+  /** MCP tool name string the LLM and JSONL files use. */
+  readonly toolName: string;
+  /** URL prefix segment under `/api/`. The plugin owns this slug;
+   *  the host owns the `/api/` prefix. Defaults to `toolName` if
+   *  omitted but most plugins prefer a shorter slug (e.g.
+   *  `"accounting"` rather than `"manageAccounting"`).
+   *
+   *  Also doubles as the outer key under `API_ROUTES` — so
+   *  `API_ROUTES.<apiNamespace>.<routeKey>` is `{ method, url }`. */
+  readonly apiNamespace?: string;
+  /** Routes owned by this plugin. Each value declares an HTTP
+   *  method and a sub-path; the host composes the full URL as
+   *  `/api/<apiNamespace><path>`. */
+  readonly apiRoutes?: Readonly<Record<string, RouteSpec>>;
+  /** MCP-bridge dispatch route key. Names the entry in `apiRoutes`
+   *  the MCP server posts tool calls to. Lets `BUILT_IN_SERVER_BINDINGS`
+   *  derive the binding's URL from META instead of repeating it. */
+  readonly mcpDispatch?: string;
+  /** Workspace-relative directories owned by this plugin (flat
+   *  keys). Merged into the central `WORKSPACE_DIRS` so existing
+   *  call sites (`WORKSPACE_DIRS.accounting`) keep working. */
+  readonly workspaceDirs?: Readonly<Record<string, string>>;
+  /** Static pubsub channel names owned by this plugin (flat keys).
+   *  Merged into the central `PUBSUB_CHANNELS`. Channel factories
+   *  (e.g. `bookChannel(bookId)`) are not part of this map — they
+   *  live as separate named exports in the plugin's `meta.ts`
+   *  because their signatures are plugin-specific. */
+  readonly staticChannels?: Readonly<Record<string, string>>;
+}
+
+/** Substitute `:param` placeholders in a route URL with caller-
+ *  provided values. URL-encodes each value so `/foo bar` and
+ *  `?injection=1` survive intact. */
+export function buildRouteUrl(route: ResolvedRoute, params?: Readonly<Record<string, string | number>>): string {
+  if (!params) return route.url;
+  let { url } = route;
+  for (const [key, value] of Object.entries(params)) {
+    const placeholder = `:${key}`;
+    if (!url.includes(placeholder)) continue;
+    url = url.split(placeholder).join(encodeURIComponent(String(value)));
+  }
+  return url;
+}

package/src/plugins/metas.ts

@@ -0,0 +1,224 @@
+// Vue-free barrel of every built-in plugin's `META` (the central-
+// registry-facing metadata). Host aggregators (src/config/*,
+// server/workspace/paths.ts) iterate over `BUILT_IN_PLUGIN_METAS`
+// and auto-merge per-dimension records — they never hold
+// plugin-specific literals.
+//
+// Why a separate barrel from `src/plugins/index.ts`?
+// `src/plugins/index.ts` exports `BUILT_IN_PLUGINS` (plugin
+// REGISTRATIONS, including Vue View / Preview components). Server
+// code can't import Vue, so this file gives server-side aggregators
+// a Vue-free entry point that still co-locates the per-plugin
+// metadata.
+//
+// **Auto-generated**. The list comes from
+// `_generated/metas.ts` which is rewritten by
+// `scripts/codegen-plugin-barrels.ts` (run via `predev` / `prebuild`
+// hooks). Adding a plugin means dropping a `meta.ts` into the new
+// `src/plugins/<name>/` directory; this file does not need editing.
+
+import type { PluginMeta } from "./meta-types";
+import { GENERATED_PLUGIN_METAS } from "./_generated/metas";
+
+export const BUILT_IN_PLUGIN_METAS = GENERATED_PLUGIN_METAS;
+export type BuiltInPluginMetas = typeof BUILT_IN_PLUGIN_METAS;
+
+// ────────────────────────────────────────────────────────────────
+// Collision detection
+// ────────────────────────────────────────────────────────────────
+//
+// Aggregators spread plugin-owned records into host records. Without
+// a guard, a plugin claiming a host-reserved key (`apiNamespace:
+// "agent"`) or two plugins claiming the same key (both with
+// `workspaceDirs.images`) would silently win the merge and route
+// real traffic to the wrong handler.
+//
+// We don't `throw` at module load — that would brick the whole app
+// for a single buggy plugin (especially relevant once user-installed
+// runtime plugins land). Instead the helpers below are pure,
+// returning collision lists; callers decide the policy:
+//
+//   - Built-in aggregators FILTER colliding plugin keys before merge
+//     (host wins / first-registered plugin wins).
+//   - `server/plugins/diagnostics.ts` collects the lists at boot,
+//     surfaces them via `log.warn` + a system notification, and
+//     persists them so a UI mounting later can still display them.
+
+/** A plugin key colliding with a host-owned key in one aggregator. */
+export interface HostPluginCollision {
+  /** Aggregator label (`"API_ROUTES"`, `"WORKSPACE_DIRS"`, …). */
+  label: string;
+  /** The key claimed by both host and plugin. */
+  key: string;
+  /** `toolName` of the plugin claiming it. Empty for legacy callers
+   *  that don't pass per-key plugin attribution. */
+  plugin: string;
+}
+
+/** Two plugins claiming the same key in the same dimension. */
+export interface IntraPluginCollision {
+  /** Which dimension the duplicate appears in. */
+  dimension: "toolName" | "apiNamespace" | "workspaceDirs" | "staticChannels";
+  /** The duplicated key. */
+  key: string;
+  /** `toolName`s of the two plugins claiming it (first-registered, second). */
+  plugins: [string, string];
+}
+
+/** Pure check — does any plugin key shadow a host key? Returns the
+ *  list of colliding keys (empty when clean). Aggregators call this
+ *  to decide which plugin keys to drop during the merge. */
+export function findHostPluginCollisions(hostRecord: Readonly<Record<string, unknown>>, pluginRecord: Readonly<Record<string, unknown>>): readonly string[] {
+  const hostKeys = new Set(Object.keys(hostRecord));
+  return Object.keys(pluginRecord).filter((key) => hostKeys.has(key));
+}
+
+/** Build an attributed collision list — one entry per (key, plugin)
+ *  pair, where `pluginAttribution[key]` names the plugin claiming
+ *  that key. Used by aggregators that aggregate ACROSS plugins
+ *  (workspaceDirs, staticChannels) where each key may come from a
+ *  different plugin. */
+export function attributeHostPluginCollisions(
+  label: string,
+  hostRecord: Readonly<Record<string, unknown>>,
+  pluginRecord: Readonly<Record<string, unknown>>,
+  pluginByKey: Readonly<Record<string, string>>,
+): HostPluginCollision[] {
+  return findHostPluginCollisions(hostRecord, pluginRecord).map((key) => ({ label, key, plugin: pluginByKey[key] ?? "" }));
+}
+
+/** Build a first-write-wins aggregate of a per-plugin record across
+ *  all plugins. Duplicate keys (= "intra-plugin collision") are
+ *  reported in the returned `collisions` list with the first-claiming
+ *  plugin AND the offender; the offender's value is dropped — runtime
+ *  routes to the first plugin's handler.
+ *
+ *  This is the fix for Codex review iter-3+: previously each
+ *  aggregator used `Object.fromEntries` / `Object.assign` to merge,
+ *  which is JS-level last-write-wins. The diagnostic ran AFTER the
+ *  merge and could only describe what was already lost, with the
+ *  warning text contradicting actual behavior ("second is ignored"
+ *  vs runtime's "second wins"). With this builder the merge IS the
+ *  detection point — first-write semantics are enforced. */
+export function buildPluginAggregate<V>(
+  metas: readonly PluginMeta[],
+  extract: (meta: PluginMeta) => Readonly<Record<string, V>> | undefined,
+  dimension: IntraPluginCollision["dimension"],
+): { aggregate: Record<string, V>; owner: Record<string, string>; collisions: IntraPluginCollision[] } {
+  const aggregate: Record<string, V> = {};
+  const owner: Record<string, string> = {};
+  const collisions: IntraPluginCollision[] = [];
+  for (const meta of metas) {
+    const record = extract(meta);
+    if (!record) continue;
+    for (const [key, value] of Object.entries(record)) {
+      const priorPlugin = owner[key];
+      if (priorPlugin !== undefined) {
+        // Two distinct plugins claim the same key. Keep the first
+        // entry; report the offender so diagnostics can warn.
+        collisions.push({ dimension, key, plugins: [priorPlugin, meta.toolName] });
+        continue;
+      }
+      aggregate[key] = value;
+      owner[key] = meta.toolName;
+    }
+  }
+  return { aggregate, owner, collisions };
+}
+
+/** Filter a plugin record so only the keys that survive the merge
+ *  policy remain: keys not claimed by the host. Returns the cleaned
+ *  record AND the list of (label, key, plugin) drops so diagnostics
+ *  can report them.
+ *
+ *  Intra-plugin collisions are filtered EARLIER by
+ *  `buildPluginAggregate`; by the time this function runs the input
+ *  is already first-write-wins-clean. */
+export function filterPluginKeys<V>(
+  label: string,
+  hostKeys: ReadonlySet<string>,
+  pluginRecord: Readonly<Record<string, V>>,
+  pluginByKey: Readonly<Record<string, string>>,
+): { cleaned: Record<string, V>; dropped: HostPluginCollision[] } {
+  const cleaned: Record<string, V> = {};
+  const dropped: HostPluginCollision[] = [];
+  for (const [key, value] of Object.entries(pluginRecord)) {
+    if (hostKeys.has(key)) {
+      dropped.push({ label, key, plugin: pluginByKey[key] ?? "" });
+      continue;
+    }
+    cleaned[key] = value;
+  }
+  return { cleaned, dropped };
+}
+
+// ────────────────────────────────────────────────────────────────
+// Host aggregate facade
+// ────────────────────────────────────────────────────────────────
+//
+// `buildPluginAggregate` + `filterPluginKeys` always come paired:
+// gather plugin contributions, drop the ones that collide with host
+// keys, spread into the host record. Each of the four aggregator
+// files (toolNames, apiRoutes, pubsubChannels, paths.ts) was repeating
+// the same ~25-line shape. `defineHostAggregate` collapses the
+// runtime half to one call so a new dimension (e.g. featureFlags) is
+// one line at the call site, not five copy-pastes.
+//
+// The TYPE-LEVEL mapped shape stays at the call site — each
+// aggregator's literal-preserving type (`PluginWorkspaceDirsMap`,
+// `PluginApiRoutesMap`, …) is dimension-specific and would lose
+// fidelity if collapsed into a generic helper. The runtime helper
+// returns `Record<string, V>` and the call site narrows it.
+
+export interface HostAggregateOptions<V> {
+  /** Aggregator label used in `HostPluginCollision.label` (e.g.
+   *  `"TOOL_NAMES"`, `"API_ROUTES"`). */
+  readonly label: string;
+  /** Host-owned record. Plugin keys that collide with these are
+   *  dropped from the merge (host wins) and reported in
+   *  `hostCollisions`. */
+  readonly hostRecord: Readonly<Record<string, V>>;
+  /** Per-plugin extractor — returns the contribution this plugin
+   *  makes to this dimension, or `undefined` to skip. */
+  readonly extract: (meta: PluginMeta) => Readonly<Record<string, V>> | undefined;
+  /** Dimension label tagged onto every emitted
+   *  `IntraPluginCollision`. */
+  readonly dimension: IntraPluginCollision["dimension"];
+  /** Extra reserved keys to drop on collision, ON TOP OF
+   *  `Object.keys(hostRecord)`. Used when a sibling map shares a
+   *  namespace with this aggregate — e.g. `WORKSPACE_DIRS` reserves
+   *  `WORKSPACE_FILES` keys so a plugin can't smuggle in
+   *  `workspaceDirs: { memory: ... }` and silently disagree with
+   *  `WORKSPACE_FILES.memory` (CR review #1125). The reserved keys
+   *  are NOT added to `merged` — only used for collision filtering. */
+  readonly additionalReservedKeys?: ReadonlySet<string>;
+}
+
+export interface HostAggregate<V> {
+  /** Merged record: host fields plus every plugin contribution that
+   *  survived collision filtering. */
+  readonly merged: Record<string, V>;
+  /** Plugin keys dropped because a host record claimed the same
+   *  key. */
+  readonly hostCollisions: readonly HostPluginCollision[];
+  /** Two plugins claiming the same key — the second is dropped
+   *  (first-write-wins) and reported here. */
+  readonly intraCollisions: readonly IntraPluginCollision[];
+}
+
+/** Run the standard "build per-plugin aggregate, drop host
+ *  collisions, spread into host record" pipeline in one call. The
+ *  caller still owns the literal-preserving type cast on `merged`. */
+export function defineHostAggregate<V>(metas: readonly PluginMeta[], opts: HostAggregateOptions<V>): HostAggregate<V> {
+  const { aggregate, owner, collisions } = buildPluginAggregate(metas, opts.extract, opts.dimension);
+  const reserved = new Set<string>(Object.keys(opts.hostRecord));
+  if (opts.additionalReservedKeys) {
+    for (const key of opts.additionalReservedKeys) reserved.add(key);
+  }
+  const { cleaned, dropped } = filterPluginKeys(opts.label, reserved, aggregate, owner);
+  return {
+    merged: { ...opts.hostRecord, ...cleaned },
+    hostCollisions: dropped,
+    intraCollisions: collisions,
+  };
+}

package/src/plugins/presentForm/Preview.vue

@@ -1,7 +1,6 @@
 <template>
   <div class="w-full h-full flex flex-col items-center justify-center p-4 bg-gradient-to-br from-blue-50 to-indigo-50 rounded-lg border-2 border-gray-200">
     <div class="text-center">
-      <!-- Form Icon -->
       <svg class="w-12 h-12 mx-auto mb-3 text-blue-600" fill="none" stroke="currentColor" viewBox="0 0 24 24">
         <path
           stroke-linecap="round"
@@ -11,15 +10,12 @@
         />
       </svg>
 
-      <!-- Form Title or Default -->
       <h3 class="text-gray-900 font-bold text-lg mb-1 line-clamp-2">
         {{ formData?.title || t("pluginPresentForm.fallbackTitle") }}
       </h3>
 
-      <!-- Field Count -->
       <p class="text-gray-600 text-sm mb-2">{{ t("pluginPresentForm.fieldCount", { count: fieldCount }, fieldCount) }}</p>
 
-      <!-- Completion Status -->
       <div v-if="!isSubmitted" class="flex items-center justify-center gap-2">
         <div class="w-32 h-2 bg-gray-200 rounded-full overflow-hidden">
           <div class="h-full bg-blue-600 transition-all duration-300" :style="{ width: `${completionPercentage}%` }" />
@@ -27,7 +23,6 @@
         <span class="text-xs text-gray-500">{{ `${completionPercentage}%` }}</span>
       </div>
 
-      <!-- Submitted Badge -->
       <div v-else class="inline-flex items-center gap-1 px-3 py-1 bg-green-100 text-green-700 rounded-full text-xs font-semibold">
         <svg class="w-3 h-3" fill="currentColor" viewBox="0 0 20 20">
           <path
@@ -62,22 +57,16 @@ const props = defineProps<{
 
 const formData = computed<FormData | null>(() => {
   if (props.result?.toolName === "presentForm") {
-    return props.result.jsonData as FormData;
+    return (props.result.data ?? props.result.jsonData) as FormData;
   }
   return null;
 });
 
-const viewState = computed<FormViewState | null>(() => {
-  return (props.result?.viewState as unknown as FormViewState) || null;
-});
+const viewState = computed<FormViewState | null>(() => (props.result?.viewState as unknown as FormViewState) || null);
 
-const fieldCount = computed(() => {
-  return formData.value?.fields.length || 0;
-});
+const fieldCount = computed(() => formData.value?.fields.length || 0);
 
-const isSubmitted = computed(() => {
-  return viewState.value?.submitted || false;
-});
+const isSubmitted = computed(() => viewState.value?.submitted || false);
 
 const completionPercentage = computed(() => {
   if (!formData.value || isSubmitted.value) return 100;