mulmoclaude 0.5.2 → 0.6.0

package/src/plugins/wiki/history/RestoreConfirm.vue

@@ -0,0 +1,63 @@
+<script setup lang="ts">
+import { useI18n } from "vue-i18n";
+import { formatSmartTime } from "../../../utils/format/date";
+import type { SnapshotSummary } from "./api";
+
+const props = defineProps<{
+  snapshot: SnapshotSummary;
+  /** True while the parent's POST is in flight; disables both
+   *  buttons and surfaces a spinner on the action button. */
+  restoring: boolean;
+}>();
+
+const emit = defineEmits<{
+  cancel: [];
+  confirm: [];
+}>();
+
+const { t } = useI18n();
+
+function editorLabel(editor: SnapshotSummary["editor"]): string {
+  if (editor === "llm") return t("pluginWiki.history.editorBadgeLLM");
+  if (editor === "system") return t("pluginWiki.history.editorBadgeSystem");
+  return t("pluginWiki.history.editorBadgeUser");
+}
+</script>
+
+<template>
+  <div
+    class="fixed inset-0 z-40 flex items-center justify-center bg-black/40"
+    data-testid="wiki-history-restore-confirm"
+    @click.self="!restoring && emit('cancel')"
+  >
+    <div class="bg-white rounded-lg shadow-xl max-w-md w-full mx-4 p-5">
+      <h3 class="text-lg font-semibold text-gray-800 mb-3">
+        {{ t("pluginWiki.history.restoreConfirmTitle") }}
+      </h3>
+      <p class="text-sm text-gray-700 leading-relaxed">
+        {{ t("pluginWiki.history.restoreConfirmBody", { ts: formatSmartTime(props.snapshot.ts), editor: editorLabel(props.snapshot.editor) }) }}
+      </p>
+      <div class="mt-5 flex items-center justify-end gap-2">
+        <button
+          type="button"
+          class="h-8 px-3 rounded text-sm text-gray-700 hover:bg-gray-100 disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
+          :disabled="restoring"
+          data-testid="wiki-history-restore-cancel"
+          @click="emit('cancel')"
+        >
+          {{ t("pluginWiki.history.restoreConfirmCancel") }}
+        </button>
+        <button
+          type="button"
+          class="h-8 px-3 rounded text-sm bg-blue-600 hover:bg-blue-700 text-white disabled:opacity-60 disabled:cursor-not-allowed flex items-center gap-1 transition-colors"
+          :disabled="restoring"
+          data-testid="wiki-history-restore-confirm-action"
+          @click="emit('confirm')"
+        >
+          <span v-if="restoring" class="material-icons text-base animate-spin">progress_activity</span>
+          {{ t("pluginWiki.history.restoreConfirmAction") }}
+        </button>
+      </div>
+    </div>
+  </div>
+</template>

package/src/plugins/wiki/history/api.ts

@@ -0,0 +1,52 @@
+import { apiGet, apiPost, type ApiResult } from "../../../utils/api.js";
+import { pluginEndpoints } from "../../api.js";
+import type { WikiEndpoints } from "../index.js";
+
+export interface SnapshotSummary {
+  stamp: string;
+  bytes: number;
+  ts: string;
+  editor: "user" | "llm" | "system";
+  sessionId?: string;
+  reason?: string;
+}
+
+export interface SnapshotContent extends SnapshotSummary {
+  meta: Record<string, unknown>;
+  body: string;
+}
+
+interface ListResponse {
+  slug: string;
+  snapshots: SnapshotSummary[];
+}
+
+interface ReadResponse {
+  slug: string;
+  snapshot: SnapshotContent;
+}
+
+interface RestoreResponse {
+  slug: string;
+  restored: { fromStamp: string };
+}
+
+function fillRoute(template: string, params: Record<string, string>): string {
+  return template.replace(/:([a-zA-Z]+)/g, (_, key: string) => encodeURIComponent(params[key]));
+}
+
+function endpoints(): WikiEndpoints {
+  return pluginEndpoints<WikiEndpoints>("wiki");
+}
+
+export function fetchHistoryList(slug: string): Promise<ApiResult<ListResponse>> {
+  return apiGet<ListResponse>(fillRoute(endpoints().pageHistory, { slug }));
+}
+
+export function fetchHistorySnapshot(slug: string, stamp: string): Promise<ApiResult<ReadResponse>> {
+  return apiGet<ReadResponse>(fillRoute(endpoints().pageHistorySnapshot, { slug, stamp }));
+}
+
+export function restoreHistorySnapshot(slug: string, stamp: string): Promise<ApiResult<RestoreResponse>> {
+  return apiPost<RestoreResponse>(fillRoute(endpoints().pageHistoryRestore, { slug, stamp }));
+}

package/src/plugins/wiki/history/diff.ts

@@ -0,0 +1,145 @@
+import { diffLines } from "diff";
+
+// Keys that `writeWikiPage` auto-stamps on every save. Diffing
+// these would surface a change on every snapshot even when the
+// user touched nothing meaningful (Q5 in the PR 3 plan).
+const AUTO_STAMP_KEYS = ["updated", "editor"] as const;
+
+export const DIFF_LINE_KIND = {
+  context: "context",
+  add: "add",
+  del: "del",
+} as const;
+export type DiffLineKind = (typeof DIFF_LINE_KIND)[keyof typeof DIFF_LINE_KIND];
+
+export interface DiffLine {
+  kind: DiffLineKind;
+  text: string;
+}
+
+/** A contiguous viewport into the diff. Between hunks there are
+ *  unchanged lines that have been collapsed to keep the view
+ *  readable; the renderer surfaces those gaps via `hiddenBefore`
+ *  and (on the last hunk only) `hiddenAfter`. */
+export interface DiffHunk {
+  lines: DiffLine[];
+  /** Unchanged lines collapsed before this hunk (i.e. between the
+   *  previous hunk's end and this hunk's start, or between BOF and
+   *  the first hunk). 0 when nothing is hidden. */
+  hiddenBefore: number;
+  /** Unchanged lines collapsed after this hunk and before EOF.
+   *  Always 0 except on the last hunk. */
+  hiddenAfter: number;
+}
+
+/** Compute a line-level unified diff with ±N context.
+ *
+ *  Returns an empty array when `left === right` — there are no
+ *  changes to surface. Otherwise builds hunks: each one is a
+ *  contiguous run that contains at least one add/del line plus up
+ *  to `contextLines` unchanged lines on each side. When two
+ *  changes are within `2 * contextLines` of each other their
+ *  context windows overlap and the hunks merge. */
+export function renderUnifiedDiff(left: string, right: string, contextLines = 3): DiffHunk[] {
+  if (left === right) return [];
+
+  const changes = diffLines(left, right);
+  const lines: DiffLine[] = [];
+  for (const change of changes) {
+    const kind: DiffLineKind = change.added ? DIFF_LINE_KIND.add : change.removed ? DIFF_LINE_KIND.del : DIFF_LINE_KIND.context;
+    for (const text of splitLines(change.value)) {
+      lines.push({ kind, text });
+    }
+  }
+
+  const changedIndices: number[] = [];
+  lines.forEach((line, idx) => {
+    if (line.kind !== DIFF_LINE_KIND.context) changedIndices.push(idx);
+  });
+  if (changedIndices.length === 0) return [];
+
+  const ranges = mergeWithContext(changedIndices, contextLines, lines.length);
+
+  return ranges.map((range, idx) => {
+    const hunkLines = lines.slice(range.start, range.end + 1);
+    const prevEnd = idx === 0 ? -1 : ranges[idx - 1].end;
+    const hiddenBefore = range.start - prevEnd - 1;
+    const hiddenAfter = idx === ranges.length - 1 ? lines.length - 1 - range.end : 0;
+    return { lines: hunkLines, hiddenBefore, hiddenAfter };
+  });
+}
+
+interface Range {
+  start: number;
+  end: number;
+}
+
+function mergeWithContext(changedIndices: number[], contextLines: number, totalLines: number): Range[] {
+  const out: Range[] = [];
+  for (const idx of changedIndices) {
+    const start = Math.max(0, idx - contextLines);
+    const end = Math.min(totalLines - 1, idx + contextLines);
+    const last = out[out.length - 1];
+    // Two ranges merge when their context windows are adjacent or
+    // overlap — the gap-of-zero case (last.end + 1 === start) is a
+    // legitimate merge because there are no hidden lines between.
+    if (last && last.end + 1 >= start) {
+      last.end = Math.max(last.end, end);
+    } else {
+      out.push({ start, end });
+    }
+  }
+  return out;
+}
+
+function splitLines(text: string): string[] {
+  if (text === "") return [];
+  const parts = text.split("\n");
+  // A block that ended with `\n` produces an empty trailing element
+  // from `split` — drop it. A block that did NOT end with `\n` (rare
+  // with diffLines, but possible at EOF) keeps its content.
+  if (parts.length > 0 && parts[parts.length - 1] === "") parts.pop();
+  return parts;
+}
+
+/** Strip the keys that `writeWikiPage` auto-stamps on every save
+ *  so the diff focuses on user-meaningful frontmatter only (Q5). */
+export function stripAutoStampKeys(meta: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(meta)) {
+    if ((AUTO_STAMP_KEYS as readonly string[]).includes(key)) continue;
+    out[key] = value;
+  }
+  return out;
+}
+
+/** Re-serialise `frontmatter + body` for diffing. The result is a
+ *  plain string — the diff library doesn't care about YAML; it
+ *  just needs two strings to compare. We sort frontmatter keys so
+ *  semantic equality (same keys, possibly reordered) doesn't show
+ *  up as a diff. */
+export function joinFrontmatterAndBody(meta: Record<string, unknown>, body: string): string {
+  const sortedKeys = Object.keys(meta).sort();
+  if (sortedKeys.length === 0) return body;
+  const frontmatterLines = ["---"];
+  for (const key of sortedKeys) {
+    frontmatterLines.push(`${key}: ${formatYamlValue(meta[key])}`);
+  }
+  frontmatterLines.push("---");
+  frontmatterLines.push("");
+  return `${frontmatterLines.join("\n")}\n${body}`;
+}
+
+function formatYamlValue(value: unknown): string {
+  if (value === null || value === undefined) return "";
+  if (Array.isArray(value)) return `[${value.map((item) => formatYamlValue(item)).join(", ")}]`;
+  if (typeof value === "object") return JSON.stringify(value);
+  if (typeof value === "string") {
+    // Quote when needed — leading / trailing whitespace, special
+    // YAML chars, or embedded colon-space (which YAML reads as a
+    // mapping). Plain alphanumerics + hyphens stay unquoted.
+    if (/^[A-Za-z0-9_\-./]+$/.test(value)) return value;
+    return JSON.stringify(value);
+  }
+  return String(value);
+}

package/src/plugins/wiki/index.ts

@@ -1,11 +1,18 @@
-import type { ToolPlugin } from "../../tools/types";
-import type { ToolResult } from "gui-chat-protocol";
+import type { PluginEntry, PluginRegistration } from "../../tools/types";
+import { wrapWithScope } from "../scope";
 import View from "./View.vue";
 import Preview from "./Preview.vue";
-import toolDefinition from "./definition";
-import { apiPost } from "../../utils/api";
-import { API_ROUTES } from "../../config/apiRoutes";
-import { makeUuid } from "../../utils/id";
+
+const TOOL_NAME = "manageWiki";
+
+export interface WikiEndpoints {
+  [key: string]: string;
+  base: string;
+  pageHistory: string;
+  pageHistorySnapshot: string;
+  pageHistoryRestore: string;
+  internalSnapshot: string;
+}
 
 export interface WikiPageEntry {
   title: string;
@@ -21,35 +28,38 @@ export interface WikiData {
   pageEntries?: WikiPageEntry[];
   pageName?: string;
   pageExists?: boolean;
+  // ── `page-edit` action (Stage 3a, #963) ──────────────────────
+  // Server emits these when an LLM Write/Edit hits a wiki page.
+  // The View fetches the snapshot body via /api/wiki/pages/<slug>/
+  // history/<stamp> and renders it inline, falling back to
+  // pagePath if the snapshot has been gc'd.
+  slug?: string;
+  stamp?: string;
+  pagePath?: string;
 }
 
-const wikiPlugin: ToolPlugin<WikiData> = {
-  toolDefinition,
-
-  async execute(_context, args) {
-    const result = await apiPost<ToolResult<WikiData>>(API_ROUTES.wiki.base, args);
-    if (!result.ok) {
-      // Return an error ToolResult instead of throwing so execute()
-      // stays symmetric with every other plugin in this repo. Callers
-      // can branch on the `error` field uniformly.
-      const prefix = result.status === 0 ? "Wiki request failed" : `Wiki API error ${result.status}`;
-      return {
-        toolName: "manageWiki",
-        uuid: makeUuid(),
-        message: `${prefix}: ${result.error}`,
-      };
-    }
-    return {
-      ...result.data,
-      toolName: "manageWiki",
-      uuid: result.data.uuid ?? makeUuid(),
-    };
+// View-only registry entry (Stage 3b, #963). The plugin no longer
+// exposes an MCP tool to the LLM, but the canvas dispatch
+// (`getPlugin("manageWiki")`) still finds it so:
+// (a) the server-emitted `page-edit` action toolResult renders
+//     via the same `View.vue` branches the live page action used,
+// (b) historical chat sessions saved with `toolName: "manageWiki"`
+//     continue to replay correctly.
+const wikiPlugin: PluginEntry = {
+  toolDefinition: {
+    type: "function",
+    name: TOOL_NAME,
+    prompt: "[deprecated] Replaced by inline page-edit rendering (#963). Kept registered for historical chat-history rendering only.",
+    description: "[deprecated] Replaced by inline page-edit rendering (#963). Kept registered for historical chat-history rendering only.",
+    parameters: { type: "object", properties: {}, required: [] },
   },
-
-  isEnabled: () => true,
-  generatingMessage: "Loading wiki...",
-  viewComponent: View,
-  previewComponent: Preview,
+  viewComponent: wrapWithScope("wiki", View),
+  previewComponent: wrapWithScope("wiki", Preview),
 };
 
 export default wikiPlugin;
+
+export const REGISTRATION: PluginRegistration = {
+  toolName: TOOL_NAME,
+  entry: wikiPlugin,
+};

package/src/plugins/wiki/meta.ts

@@ -0,0 +1,10 @@
+import { definePluginMeta } from "../meta-types";
+
+// View-only registry entry (Stage 3b, #963). The MCP tool was removed
+// from the LLM but the plugin entry stays so server-emitted
+// `page-edit` toolResults render in chat. No `apiRoutes` here — the
+// /api/wiki host routes (history, snapshots) stay HOST-owned because
+// they're consumed by both the wiki UI and the wiki-write hook.
+export const META = definePluginMeta({
+  toolName: "manageWiki",
+});

package/src/plugins/wiki/pageEditLoader.ts

@@ -0,0 +1,53 @@
+// Loader for the `page-edit` wiki action (Stage 3a, #963). Returns
+// the full markdown content (frontmatter + body) for an LLM-edit
+// inline preview. Tries the snapshot file first; falls back to the
+// live page if the snapshot has been gc'd; reports `deleted` when
+// neither survives.
+
+import { apiGet } from "../../utils/api";
+import { pluginEndpoints } from "../api";
+import type { WikiEndpoints } from "./index";
+import { serializeWithFrontmatter } from "../../utils/markdown/frontmatter";
+
+export type PageEditLoadResult = { kind: "snapshot"; content: string; ts: string } | { kind: "current"; content: string } | { kind: "deleted" };
+
+interface SnapshotResponse {
+  snapshot: {
+    body: string;
+    meta: Record<string, unknown>;
+    ts: string;
+  };
+}
+
+interface CurrentPageResponse {
+  data: {
+    content?: string;
+    pageExists?: boolean;
+  };
+}
+
+/** Fetch the snapshot at `(slug, stamp)`; on 404 fall through to
+ *  the live page (`pagePath` lives at `data/wiki/pages/<slug>.md`
+ *  by convention, but the slug already encodes that — pagePath is
+ *  carried along as audit metadata). */
+export async function loadPageEdit(slug: string, stamp: string): Promise<PageEditLoadResult> {
+  const wikiEndpoints = pluginEndpoints<WikiEndpoints>("wiki");
+  const snap = await apiGet<SnapshotResponse>(`${wikiEndpoints.base}/pages/${encodeURIComponent(slug)}/history/${encodeURIComponent(stamp)}`);
+  if (snap.ok) {
+    const { body, meta, ts } = snap.data.snapshot;
+    return { kind: "snapshot", content: serializeWithFrontmatter(meta, body), ts };
+  }
+  if (snap.status !== 404) {
+    // Network / 5xx: surface as deleted-equivalent for now. The
+    // banner stays neutral ("page deleted") rather than leaking
+    // transient errors into the UI; refresh recovers when the
+    // server is healthy again.
+    return { kind: "deleted" };
+  }
+
+  const current = await apiGet<CurrentPageResponse>(`${wikiEndpoints.base}?slug=${encodeURIComponent(slug)}`);
+  if (current.ok && current.data.data.pageExists && typeof current.data.data.content === "string") {
+    return { kind: "current", content: current.data.data.content };
+  }
+  return { kind: "deleted" };
+}

package/src/plugins/wiki/route.ts

@@ -101,6 +101,10 @@ export function buildWikiRouteParams(target: WikiTarget): Record<string, string>
       return { section: WIKI_ROUTE_SECTION.log, slug: "" };
     case "lint_report":
       return { section: WIKI_ROUTE_SECTION.lintReport, slug: "" };
+    default: {
+      const exhaustive: never = target;
+      throw new Error(`unreachable WikiTarget kind: ${JSON.stringify(exhaustive)}`);
+    }
   }
 }
 
@@ -117,5 +121,9 @@ export function wikiActionFor(target: WikiTarget): WikiAction {
       return WIKI_ACTION.log;
     case "lint_report":
       return WIKI_ACTION.lintReport;
+    default: {
+      const exhaustive: never = target;
+      throw new Error(`unreachable WikiTarget kind: ${JSON.stringify(exhaustive)}`);
+    }
   }
 }

package/src/router/guards.ts

@@ -27,7 +27,7 @@ function isValidSessionId(value: unknown): boolean {
 export function installGuards(router: Router): void {
   router.beforeEach((dest) => {
     if (dest.name === "chat") {
-      const sessionId = dest.params.sessionId;
+      const { sessionId } = dest.params;
       if (isNonEmptyString(sessionId) && !isValidSessionId(sessionId)) {
         return { name: "chat", params: {}, query: {}, replace: true };
       }
@@ -76,5 +76,6 @@ export function installGuards(router: Router): void {
         };
       }
     }
+    return undefined;
   });
 }

package/src/router/index.ts

@@ -15,6 +15,7 @@
 import { defineComponent, h } from "vue";
 import { createRouter, createWebHistory, type RouteRecordRaw } from "vue-router";
 import { PAGE_ROUTES, type PageRouteName } from "./pageRoutes";
+import { HOST_EVENTS } from "../config/hostEvents";
 
 // Re-export the constants so existing `import { PAGE_ROUTES } from
 // "./router"` call sites keep working. The actual definitions live
@@ -66,6 +67,10 @@ const routes: RouteRecordRaw[] = [
   // News viewer (#761). Optional `?source=<slug>` query for the
   // Sources-page deep link.
   { path: "/news", name: PAGE_ROUTES.news, component: Stub },
+  // Debug page (#feat-encore PR 1 follow-up). Standalone playground for
+  // experimental plugin features (notifier engine, etc.). Rendered by
+  // the @mulmoclaude/debug-plugin runtime plugin.
+  { path: "/debug", name: PAGE_ROUTES.debug, component: Stub },
   { path: "/:pathMatch(.*)*", redirect: "/chat" },
 ];
 
@@ -74,4 +79,18 @@ const router = createRouter({
   routes,
 });
 
+// Bridge SPA navigation to a DOM CustomEvent so runtime-loaded plugins
+// (which can't import vue-router without extra plumbing) can react to
+// route changes without polling. Fires on every commit, including
+// query-only changes that don't remount the matched component.
+//
+// Subscriber: `@mulmoclaude/debug-plugin` View, which uses it to
+// re-evaluate `?mode=` and `?notificationId=` params after the host
+// notifier popup pushes a new URL. The event name lives in
+// `src/config/hostEvents.ts` so the contract isn't a magic string
+// duplicated between host and plugin.
+router.afterEach((toRoute) => {
+  window.dispatchEvent(new CustomEvent(HOST_EVENTS.routeChange, { detail: { fullPath: toRoute.fullPath } }));
+});
+
 export default router;

package/src/router/pageRoutes.ts

@@ -18,6 +18,7 @@ export const PAGE_ROUTES = {
   roles: "roles",
   sources: "sources",
   news: "news",
+  debug: "debug",
 } as const;
 
 export type PageRouteName = (typeof PAGE_ROUTES)[keyof typeof PAGE_ROUTES];

package/src/tools/index.ts

@@ -1,59 +1,58 @@
+// Central tool registry. Two stages of lookup:
+//
+//   1. Build-time-bundled plugins (the "built-in" set) — assembled
+//      generically from `BUILT_IN_PLUGINS` exported by
+//      `src/plugins/index.ts`. Each plugin self-registers via a
+//      `REGISTRATION` export co-locating `TOOL_NAMES.x` with its
+//      `PluginEntry`. Adding a new built-in plugin does NOT touch
+//      this file.
+//
+//   2. Runtime-installed plugins (#1043 C-2) — loaded from the
+//      workspace ledger at boot via `runtimeLoader`. Looked up
+//      after the built-in set so a static plugin always wins on
+//      collision (mirrors the server-side collision policy in
+//      `server/plugins/runtime-registry.ts`).
+
 import type { PluginEntry } from "./types";
-import { LEGACY_VIEW_ONLY_PLUGIN_NAMES } from "./legacyPluginNames";
-import textResponsePlugin from "../plugins/textResponse/index";
-import markdownPlugin from "../plugins/markdown/index";
-import spreadsheetPlugin from "../plugins/spreadsheet/index";
-import MindMapPlugin from "@gui-chat-plugin/mindmap/vue";
-import generateImagePlugin from "../plugins/generateImage/index";
-import QuizPlugin from "@mulmochat-plugin/quiz/vue";
-import presentFormPlugin from "../plugins/presentForm/index";
-import canvasPlugin from "../plugins/canvas/index";
-import editImagePlugin from "../plugins/editImage/index";
-import Present3DPlugin from "@gui-chat-plugin/present3d/vue";
-import WeatherPlugin from "@gui-chat-plugin/weather/vue";
-import todoPlugin from "../plugins/todo/index";
-import { manageCalendarPlugin, manageAutomationsPlugin, legacyManageSchedulerEntry } from "../plugins/scheduler/index";
-import manageRolesPlugin from "../plugins/manageRoles/index";
-import manageSkillsPlugin from "../plugins/manageSkills/index";
-import manageSourcePlugin from "../plugins/manageSource/index";
-import wikiPlugin from "../plugins/wiki/index";
-import presentMulmoScriptPlugin from "../plugins/presentMulmoScript/index";
-import presentHtmlPlugin from "../plugins/presentHtml/index";
-import presentChartPlugin from "../plugins/chart/index";
+import { getRuntimePluginEntry, getRuntimeToolNames } from "./runtimeLoader";
+import { BUILT_IN_PLUGINS } from "../plugins";
 
-const plugins: Record<string, PluginEntry> = {
-  "text-response": textResponsePlugin.plugin,
-  manageTodoList: todoPlugin,
-  manageCalendar: manageCalendarPlugin,
-  manageAutomations: manageAutomationsPlugin,
-  // View-only fallback so chat sessions saved before #824
-  // continue to render rich tool-result cards. Not exposed to
-  // the LLM (absent from server/agent/plugin-names.ts and
-  // src/config/toolNames.ts) — strictly historical rendering.
-  manageScheduler: legacyManageSchedulerEntry,
-  manageRoles: manageRolesPlugin,
-  manageSkills: manageSkillsPlugin,
-  manageSource: manageSourcePlugin,
-  manageWiki: wikiPlugin,
-  presentMulmoScript: presentMulmoScriptPlugin,
-  presentDocument: markdownPlugin,
-  presentSpreadsheet: spreadsheetPlugin,
-  createMindMap: MindMapPlugin.plugin,
-  generateImage: generateImagePlugin,
-  putQuestions: QuizPlugin.plugin,
-  presentForm: presentFormPlugin,
-  openCanvas: canvasPlugin,
-  presentHtml: presentHtmlPlugin,
-  presentChart: presentChartPlugin,
-  editImage: editImagePlugin,
-  present3D: Present3DPlugin.plugin,
-  weather: WeatherPlugin.plugin,
-};
+// Build the lookup with explicit duplicate detection. `BUILT_IN_PLUGINS`
+// is the union of generated registrations (one per built-in META) and
+// `EXTERNAL_PLUGIN_REGISTRATIONS` (still-unmigrated plugins). The
+// META aggregator already screens its half for collisions, but a
+// duplicate `toolName` between an external registration and a META
+// would slip past `Object.fromEntries` silently with last-writer-wins.
+// Throwing at boot is the right move — silent dispatch hijack is
+// strictly worse than a hard error during start-up (CR review #1125).
+//
+// Use a null-prototype dictionary so:
+//   1. The `in` / `hasOwn` check doesn't walk a prototype chain — a
+//      legitimate `toolName` like `"toString"` or `"hasOwnProperty"`
+//      can't false-positive as a duplicate.
+//   2. The bracket assign at the end can't trigger `__proto__`
+//      prototype-mutation semantics if a future registration value
+//      ever flows from less-trusted code.
+// Codex review on PR #1156.
+const plugins: Record<string, PluginEntry> = (() => {
+  const out: Record<string, PluginEntry> = Object.create(null);
+  for (const registration of BUILT_IN_PLUGINS) {
+    if (Object.prototype.hasOwnProperty.call(out, registration.toolName)) {
+      throw new Error(`Duplicate built-in plugin registration for "${registration.toolName}"`);
+    }
+    out[registration.toolName] = registration.entry;
+  }
+  return out;
+})();
 
 export function getPlugin(name: string): PluginEntry | null {
-  return plugins[name] ?? null;
+  // Static (build-time) plugins win on collision — runtime plugins
+  // are registered in mcp-server.ts only when their tool name does
+  // not already exist in the static set, so this lookup order keeps
+  // the contracts symmetric across server and frontend.
+  return plugins[name] ?? getRuntimePluginEntry(name);
 }
 
 export function getAllPluginNames(): string[] {
-  return Object.keys(plugins).filter((name) => !LEGACY_VIEW_ONLY_PLUGIN_NAMES.has(name));
+  return [...BUILT_IN_PLUGINS.map((registration) => registration.toolName), ...getRuntimeToolNames()];
 }