mulmoclaude 0.5.2 → 0.6.0

package/src/plugins/scheduler/View.vue

@@ -1,17 +1,10 @@
 <template>
   <div class="h-full bg-white flex flex-col">
-    <!-- API error banner — surfaces POST /api/scheduler failures so a
-         delete/add/replace that silently no-ops becomes diagnosable. -->
+    <!-- Surfaces POST /api/scheduler failures so silent no-ops are diagnosable. -->
     <div v-if="apiError" class="px-4 py-2 bg-red-50 border-b border-red-200 text-sm text-red-700" role="alert" data-testid="scheduler-api-error">
       {{ t("pluginScheduler.apiError", { error: apiError }) }}
     </div>
-    <!-- Top-level tab bar: Calendar / Tasks. Hidden when the
-         component is mounted as a standalone page (`forceTab`
-         set by CalendarView / AutomationsView) — the page itself
-         already identifies which feature the user is on, so a
-         tab bar would duplicate that affordance. Still rendered
-         when the component appears as a `manageScheduler` tool
-         result inside /chat, where the user can switch freely. -->
+    <!-- Hidden when mounted as a standalone page (forceTab) — the page already identifies the feature. -->
     <div v-if="!forceTab" class="flex border-b border-gray-200 px-6">
       <button
         class="px-4 py-2 text-sm font-medium border-b-2 -mb-px"
@@ -31,19 +24,15 @@
       </button>
     </div>
 
-    <!-- Tasks tab -->
     <TasksTab v-if="activeTab === SCHEDULER_TAB.tasks" />
 
-    <!-- Calendar tab (existing content) -->
     <template v-if="activeTab === SCHEDULER_TAB.calendar">
-      <!-- Header -->
       <div class="flex items-center justify-between gap-2 px-3 py-2 border-b border-gray-100">
         <div class="flex items-center gap-2">
           <h2 class="text-lg font-semibold text-gray-800">{{ t("pluginScheduler.heading") }}</h2>
           <span class="text-sm text-gray-500">{{ t("pluginScheduler.itemCount", items.length, { named: { count: items.length } }) }}</span>
         </div>
         <div class="flex items-center gap-2">
-          <!-- Navigation (calendar modes only) -->
           <template v-if="viewMode !== SCHEDULER_VIEW.list">
             <div class="flex gap-0.5">
               <button
@@ -70,7 +59,6 @@
             </div>
             <span class="text-sm text-gray-600 min-w-[140px] text-center">{{ headerLabel }}</span>
           </template>
-          <!-- View mode toggle -->
           <div class="flex border border-gray-300 rounded overflow-hidden">
             <button
               v-for="mode in VIEW_MODES"
@@ -86,7 +74,6 @@
         </div>
       </div>
 
-      <!-- List view -->
       <div v-if="viewMode === SCHEDULER_VIEW.list" class="flex-1 overflow-y-auto min-h-0">
         <div v-if="items.length === 0" class="flex items-center justify-center h-full text-gray-400">{{ t("pluginScheduler.noScheduled") }}</div>
 
@@ -124,11 +111,9 @@
         </ul>
       </div>
 
-      <!-- Week view -->
       <div v-else-if="viewMode === SCHEDULER_VIEW.week" class="flex-1 overflow-y-auto min-h-0">
         <div class="grid grid-cols-7 border-b border-gray-200">
           <div v-for="day in weekDays" :key="day.toISOString()" class="border-r last:border-r-0 border-gray-200 min-h-[200px] flex flex-col">
-            <!-- Day header -->
             <div class="px-2 py-1.5 text-center border-b border-gray-100 sticky top-0 bg-white" :class="isToday(day) ? 'bg-blue-50' : ''">
               <div class="text-xs text-gray-400">{{ dayLabel(day) }}</div>
               <div
@@ -138,7 +123,6 @@
                 {{ day.getDate() }}
               </div>
             </div>
-            <!-- Day items -->
             <div class="flex-1 p-1 space-y-0.5">
               <div
                 v-for="item in itemsForDay(day)"
@@ -153,7 +137,6 @@
             </div>
           </div>
         </div>
-        <!-- Unscheduled -->
         <div v-if="unscheduledItems.length > 0" class="p-3 border-t border-gray-200">
           <div class="text-xs text-gray-400 mb-1.5">{{ t("pluginScheduler.unscheduled") }}</div>
           <div class="flex flex-wrap gap-1">
@@ -170,15 +153,12 @@
         </div>
       </div>
 
-      <!-- Month view -->
       <div v-else class="flex-1 overflow-y-auto min-h-0">
-        <!-- Weekday headers -->
         <div class="grid grid-cols-7 border-b border-gray-200 sticky top-0 bg-white z-10">
           <div v-for="label in WEEKDAY_LABELS" :key="label" class="text-xs text-center text-gray-400 py-1.5 border-r last:border-r-0 border-gray-100">
             {{ label }}
           </div>
         </div>
-        <!-- Month grid -->
         <div v-for="(week, wi) in monthGrid" :key="wi" class="grid grid-cols-7 border-b border-gray-100">
           <div
             v-for="day in week"
@@ -206,7 +186,6 @@
             </div>
           </div>
         </div>
-        <!-- Unscheduled -->
         <div v-if="unscheduledItems.length > 0" class="p-3 border-t border-gray-200">
           <div class="text-xs text-gray-400 mb-1.5">{{ t("pluginScheduler.unscheduled") }}</div>
           <div class="flex flex-wrap gap-1">
@@ -223,7 +202,6 @@
         </div>
       </div>
 
-      <!-- Item YAML editor -->
       <div v-if="selectedId" class="border-t border-blue-200 bg-blue-50 shrink-0">
         <div class="flex items-center justify-between px-4 py-2 text-sm font-medium text-blue-700">
           <span>{{ t("pluginScheduler.editItem") }}</span>
@@ -244,7 +222,6 @@
         </div>
       </div>
 
-      <!-- JSON source editor -->
       <details class="border-t border-gray-200 bg-gray-50 shrink-0">
         <summary class="cursor-pointer select-none px-4 py-2 text-sm font-medium text-gray-600 hover:bg-gray-100">
           {{ t("pluginScheduler.editSource") }}
@@ -278,10 +255,12 @@ import type { ToolResultComplete } from "gui-chat-protocol/vue";
 import type { SchedulerData, ScheduledItem } from "./index";
 import { useFreshPluginData } from "../../composables/useFreshPluginData";
 import { apiPost } from "../../utils/api";
-import { API_ROUTES } from "../../config/apiRoutes";
+import { pluginEndpoints } from "../api";
+import type { SchedulerEndpoints } from "./automationsDefinition";
 import TasksTab from "./TasksTab.vue";
 import { isToday } from "../../utils/format/date";
 import { errorMessage } from "../../utils/errors";
+import { SCHEDULER_VIEW, SCHEDULER_VIEW_MODES as VIEW_MODES, SCHEDULER_TAB, type SchedulerViewMode as ViewMode, type SchedulerTab } from "./viewModes";
 
 const { t } = useI18n();
 
@@ -289,10 +268,7 @@ type YamlScalar = string | number | boolean | null;
 
 const props = defineProps<{
   selectedResult?: ToolResultComplete<SchedulerData>;
-  // Standalone page mode: when set, hides the tab bar and locks the
-  // view to the given tab. Used by CalendarView / AutomationsView
-  // wrappers (#758). Undefined in the /chat tool-result context, so
-  // there the tab-switcher stays interactive.
+  // Set by CalendarView / AutomationsView page wrappers (#758) to lock the tab; undefined in /chat tool-result context.
   forceTab?: SchedulerTab;
 }>();
 const emit = defineEmits<{ updateResult: [result: ToolResultComplete] }>();
@@ -306,8 +282,7 @@ function detectInitialTab(result?: ToolResultComplete<SchedulerData>): Scheduler
 }
 
 const activeTab = ref<SchedulerTab>(props.forceTab ?? detectInitialTab(props.selectedResult));
-// In standalone page mode the tab is locked; swapping routes should
-// re-lock so the view follows. No-op in tool-result mode.
+// Re-lock when forceTab swaps so route navigation follows; no-op in tool-result mode.
 watch(
   () => props.forceTab,
   (next) => {
@@ -316,8 +291,10 @@ watch(
 );
 const items = ref<ScheduledItem[]>(props.selectedResult?.data?.items ?? []);
 
+const endpoints = pluginEndpoints<SchedulerEndpoints>("scheduler");
+
 const { refresh } = useFreshPluginData<ScheduledItem[]>({
-  endpoint: () => API_ROUTES.scheduler.base,
+  endpoint: () => endpoints.list.url,
   extract: (json) => {
     const payload = (json as { data?: { items?: ScheduledItem[] } }).data?.items;
     return Array.isArray(payload) ? payload : null;
@@ -336,18 +313,12 @@ watch(
   },
 );
 
-// ── View mode ──────────────────────────────────────────────────────────────
-
-import { SCHEDULER_VIEW, SCHEDULER_VIEW_MODES as VIEW_MODES, SCHEDULER_TAB, type SchedulerViewMode as ViewMode, type SchedulerTab } from "./viewModes";
-
 const WEEKDAY_LABELS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
 const MAX_MONTH_ITEMS = 3;
 
 const viewMode = ref<ViewMode>(SCHEDULER_VIEW.month);
 const currentDate = ref(new Date());
 
-// ── Calendar utilities ─────────────────────────────────────────────────────
-
 function startOfWeek(date: Date): Date {
   const result = new Date(date);
   const day = result.getDay();
@@ -402,7 +373,7 @@ function itemsForDay(day: Date): ScheduledItem[] {
 const unscheduledItems = computed(() => items.value.filter((item) => !item.props.date));
 
 function itemTime(item: ScheduledItem): string {
-  const time = item.props.time;
+  const { time } = item.props;
   return typeof time === "string" ? time : "";
 }
 
@@ -410,8 +381,6 @@ function dayLabel(date: Date): string {
   return WEEKDAY_LABELS[date.getDay() === 0 ? 6 : date.getDay() - 1];
 }
 
-// ── Navigation ─────────────────────────────────────────────────────────────
-
 const weekDays = computed(() => getWeekDays(currentDate.value));
 
 const monthGrid = computed(() => getMonthGrid(currentDate.value.getFullYear(), currentDate.value.getMonth()));
@@ -452,8 +421,6 @@ function goNext() {
   currentDate.value = next;
 }
 
-// ── YAML helpers ────────────────────────────────────────────────────────────
-
 function yamlStringValue(raw: string): string {
   const needsQuotes = raw === "" || /[:#[\]{},&*?|<>=!%@`]/.test(raw) || /^\s|\s$/.test(raw) || /^(true|false|null|~)$/i.test(raw) || /^\d/.test(raw);
   if (needsQuotes) {
@@ -504,18 +471,20 @@ function parseYaml(text: string): {
     const rawVal = line.slice(colonIdx + 2).trim();
     result[key] = parseYamlValue(rawVal);
   }
-  const title = result["title"];
+  const { title } = result;
   if (typeof title !== "string" || !title) return null;
   const itemProps = { ...result };
   delete itemProps["title"];
   return { title, props: itemProps };
 }
 
-// ── Item selection & YAML edit ───────────────────────────────────────────────
-
 const selectedId = ref<string | null>(null);
 const yamlText = ref("");
 const yamlError = ref("");
+// JSON source editor state (used by the watcher below as well, so
+// declared up here to avoid TDZ ordering with the items-watch handler).
+const editorText = ref("");
+const parseError = ref("");
 
 function selectItem(item: ScheduledItem) {
   if (selectedId.value === item.id) {
@@ -556,21 +525,20 @@ async function applyItemEdit() {
   if (success) selectedId.value = null;
 }
 
-// ── JSON source editor ───────────────────────────────────────────────────────
-
 function toJson(its: ScheduledItem[]) {
   return JSON.stringify(its, null, 2);
 }
 
-const editorText = ref(toJson(items.value));
-const parseError = ref("");
-// Last POST /api/scheduler failure. Cleared on the next successful call
-// so the banner disappears as soon as things recover.
+// Seed editorText now that toJson is in scope; the ref itself was
+// declared earlier so the watcher above can reference it (#920).
+editorText.value = toJson(items.value);
+
+// Cleared on the next successful POST so the banner disappears as soon as things recover.
 const apiError = ref<string | null>(null);
 const isModified = computed(() => editorText.value !== toJson(items.value));
 
 async function callApi(body: Record<string, unknown>): Promise<boolean> {
-  const response = await apiPost<{ data?: { items?: ScheduledItem[] } }>(API_ROUTES.scheduler.base, body);
+  const response = await apiPost<{ data?: { items?: ScheduledItem[] } }>(endpoints.dispatch.url, body);
   if (!response.ok) {
     apiError.value = response.error;
     return false;

package/src/plugins/scheduler/automationsDefinition.ts

@@ -1,18 +1,23 @@
-// MCP tool definition for the automations half of the former
-// `manageScheduler` (#824). Keeps the same backend route
-// (`/api/scheduler`) — server-side dispatch already routes
-// task-prefixed actions through the user-task subsystem via
-// `TASK_ACTIONS`, so the only thing changing here is the LLM
-// prompt and the tool name surfaced in chat.
-
 import type { ToolDefinition } from "gui-chat-protocol";
-import { SCHEDULER_ACTIONS } from "../../config/schedulerActions";
+import { SCHEDULER_ACTIONS } from "./actions";
+import { META as calendarMeta } from "./calendarMeta";
+import type { ResolvedRoute } from "../meta-types";
+
+export const TOOL_NAME = "manageAutomations";
+
+/** Endpoint contract for the scheduler plugin (shared by calendar +
+ *  automations definitions — both dispatch to the same `/api/scheduler`
+ *  via the action enum). Routes are owned by the calendar META; the
+ *  automations META is toolName-only because the binding row in
+ *  `BUILT_IN_SERVER_BINDINGS` points the automations tool at the
+ *  same dispatch URL. */
+export type SchedulerEndpoints = { readonly [K in keyof typeof calendarMeta.apiRoutes]: ResolvedRoute };
 
 const AUTOMATION_ACTIONS = [SCHEDULER_ACTIONS.createTask, SCHEDULER_ACTIONS.listTasks, SCHEDULER_ACTIONS.deleteTask, SCHEDULER_ACTIONS.runTask] as const;
 
 const toolDefinition: ToolDefinition = {
   type: "function",
-  name: "manageAutomations",
+  name: TOOL_NAME,
   prompt:
     "When users want a recurring automated task — something the agent runs on a schedule, not a single calendar event — use manageAutomations. " +
     "Examples: '毎朝8時にニュースまとめて', 'remind me every day', 'run this prompt hourly'. " +

package/src/plugins/scheduler/automationsMeta.ts

@@ -0,0 +1,5 @@
+import { definePluginMeta } from "../meta-types";
+
+export const META = definePluginMeta({
+  toolName: "manageAutomations",
+});

package/src/plugins/scheduler/calendarDefinition.ts

@@ -1,16 +1,13 @@
-// MCP tool definition for the calendar half of the former
-// `manageScheduler` (#824). Keeps the same backend route
-// (`/api/scheduler`) — the action enum is just narrowed to the
-// calendar-only subset so the LLM's prompt is unambiguous.
-
 import type { ToolDefinition } from "gui-chat-protocol";
-import { SCHEDULER_ACTIONS } from "../../config/schedulerActions";
+import { SCHEDULER_ACTIONS } from "./actions";
+
+export const TOOL_NAME = "manageCalendar";
 
 const CALENDAR_ACTIONS = [SCHEDULER_ACTIONS.show, SCHEDULER_ACTIONS.add, SCHEDULER_ACTIONS.update, SCHEDULER_ACTIONS.delete] as const;
 
 const toolDefinition: ToolDefinition = {
   type: "function",
-  name: "manageCalendar",
+  name: TOOL_NAME,
   prompt:
     "When users mention calendar events, appointments, meetings, or one-off reminders that have a date/time, use manageCalendar. " +
     "Use show to display the calendar, add to create an event, update to edit one, delete to remove one. " +

package/src/plugins/scheduler/calendarMeta.ts

@@ -0,0 +1,28 @@
+import { definePluginMeta } from "../meta-types";
+
+export const META = definePluginMeta({
+  toolName: "manageCalendar",
+  apiNamespace: "scheduler",
+  apiRoutes: {
+    /** GET /api/scheduler — read calendar items. */
+    list: { method: "GET", path: "" },
+    /** POST /api/scheduler — calendar / automations action dispatch.
+     *  The server splits calendar item actions from task-related
+     *  actions via the `action` discriminator (see `TASK_ACTIONS`). */
+    dispatch: { method: "POST", path: "" },
+    /** GET /api/scheduler/tasks — list every registered task
+     *  (system + user). */
+    tasksList: { method: "GET", path: "/tasks" },
+    /** POST /api/scheduler/tasks — create a user task. */
+    tasksCreate: { method: "POST", path: "/tasks" },
+    /** PUT /api/scheduler/tasks/:id — update a user task. */
+    taskUpdate: { method: "PUT", path: "/tasks/:id" },
+    /** DELETE /api/scheduler/tasks/:id — delete a user task. */
+    taskDelete: { method: "DELETE", path: "/tasks/:id" },
+    /** POST /api/scheduler/tasks/:id/run — fire a task immediately. */
+    taskRun: { method: "POST", path: "/tasks/:id/run" },
+    /** GET /api/scheduler/logs — newest-first scheduler execution log. */
+    logs: { method: "GET", path: "/logs" },
+  },
+  mcpDispatch: "dispatch",
+});

package/src/plugins/scheduler/formatSchedule.ts

@@ -1,11 +1,5 @@
-// Pure formatters for scheduler-task display. Extracted from
-// TasksTab.vue so the UTC → local conversion can be unit-tested
-// without spinning up Vue.
-//
-// Internally every task stores its daily trigger as `HH:MM` in UTC
-// (that's what the scheduler engine fires on). The UI should show the
-// same moment in the viewer's local timezone so a user in Tokyo sees
-// "Daily 05:00 JST" instead of "Daily 20:00 UTC".
+// Tasks store the daily trigger as `HH:MM` in UTC (that's what the engine fires on); the UI converts to the
+// viewer's local zone so a user in Tokyo sees "Daily 05:00 JST" instead of "Daily 20:00 UTC".
 
 export interface DailySchedule {
   type: "daily";
@@ -21,20 +15,12 @@ export type TaskSchedule = DailySchedule | IntervalSchedule | { type: string; [k
 
 const DAILY_TIME_RE = /^(\d{1,2}):(\d{2})$/;
 
-// Build a Date anchored to `now`'s local calendar day but at the
-// requested UTC wall-clock hour/minute. Using today's date (rather
-// than epoch 1970) makes the DST/TZ conversion accurate for the
-// viewer's current moment — "20:00 UTC every day" in Europe/London
-// can differ by an hour between summer and winter.
+// Anchor to today (not 1970) so DST conversion is accurate — "20:00 UTC daily" can differ by an hour summer/winter in London.
 function buildUtcInstant(utcHour: number, utcMinute: number, now: Date): Date {
   return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), utcHour, utcMinute));
 }
 
-// Intl formatter configured to surface HH:MM + the short timezone
-// name (e.g. "JST", "PDT"). When the browser can't resolve a zone
-// abbreviation it falls back to the offset string ("GMT+9"), which
-// is fine — the point is that the user doesn't have to mentally
-// convert from UTC.
+// Browsers without a zone abbreviation fall back to "GMT+9" — fine; the point is no manual UTC conversion.
 const LOCAL_TIME_FORMATTER = new Intl.DateTimeFormat(undefined, {
   hour: "2-digit",
   minute: "2-digit",
@@ -49,8 +35,7 @@ function extractHourMinuteTz(date: Date): { hourMinute: string; tzLabel: string
     const minute = parts.find((part) => part.type === "minute")?.value ?? "";
     const tzLabel = parts.find((part) => part.type === "timeZoneName")?.value ?? "";
     if (!hour || !minute) return null;
-    // Intl returns "24" for midnight hour under `hour: "2-digit"` on
-    // some runtimes — normalize so "Daily 24:00 JST" never appears.
+    // Some runtimes return "24" for midnight under hour:"2-digit" — normalize so "Daily 24:00 JST" never appears.
     const normalizedHour = hour === "24" ? "00" : hour;
     return { hourMinute: `${normalizedHour}:${minute}`, tzLabel };
   } catch {
@@ -58,10 +43,7 @@ function extractHourMinuteTz(date: Date): { hourMinute: string; tzLabel: string
   }
 }
 
-// Convert a UTC "HH:MM" into "Daily HH:MM <tz>" in the viewer's
-// local zone. Returns the original "Daily HH:MM UTC" string if the
-// input is malformed or the Intl machinery is unavailable — callers
-// never see `null`/throw for a scheduler entry.
+// Falls back to "Daily HH:MM UTC" on malformed input or missing Intl — callers never see null/throw.
 export function formatDailyLocal(utcHHMM: string, now: Date = new Date()): string {
   const match = DAILY_TIME_RE.exec(utcHHMM);
   if (!match) return `Daily ${utcHHMM} UTC`;

package/src/plugins/scheduler/index.ts

@@ -1,23 +1,17 @@
-// Two plugins, one shared backend (#824). Both call /api/scheduler;
-// the server-side dispatcher already routes per-action via
-// TASK_ACTIONS, so the plugins are thin wrappers over the same
-// REST contract — they differ only in tool definition (the action
-// enum the LLM sees) and in the chat-side view (CalendarView vs
-// AutomationsView). The legacy unified `manageScheduler` plugin
-// went away with the rename; see plans/refactor-split-manageScheduler-824.md.
+// #824: two plugins share /api/scheduler — the server already dispatches per-action via TASK_ACTIONS, so each plugin
+// just differs in the tool definition (action enum the LLM sees) and the View component.
 
-import type { PluginEntry } from "../../tools/types";
-import type { ToolPlugin } from "../../tools/types";
+import type { PluginRegistration, ToolPlugin } from "../../tools/types";
 import type { ToolResult } from "gui-chat-protocol";
 import CalendarView from "./CalendarView.vue";
 import AutomationsView from "./AutomationsView.vue";
-import LegacySchedulerView from "./LegacySchedulerView.vue";
 import Preview from "./Preview.vue";
 import AutomationsPreview from "./AutomationsPreview.vue";
-import calendarDefinition from "./calendarDefinition";
-import automationsDefinition from "./automationsDefinition";
-import { apiPost } from "../../utils/api";
-import { API_ROUTES } from "../../config/apiRoutes";
+import calendarDefinition, { TOOL_NAME as MANAGE_CALENDAR } from "./calendarDefinition";
+import automationsDefinition, { TOOL_NAME as MANAGE_AUTOMATIONS, type SchedulerEndpoints } from "./automationsDefinition";
+import { pluginEndpoints } from "../api";
+import { wrapWithScope } from "../scope";
+import { apiCall } from "../../utils/api";
 import { makeUuid } from "../../utils/id";
 
 export interface ScheduledItem {
@@ -31,12 +25,12 @@ export interface SchedulerData {
   items: ScheduledItem[];
 }
 
-// Shared executor for both plugins — backend dispatch is identical.
-// `toolName` is captured by closure so the tool result carries the
-// matching name through to the chat history and the View lookup.
-function makeExecute(toolName: "manageCalendar" | "manageAutomations"): ToolPlugin<SchedulerData>["execute"] {
+// `toolName` is captured so the result carries the matching name through to chat history and View lookup.
+function makeExecute(toolName: typeof MANAGE_CALENDAR | typeof MANAGE_AUTOMATIONS): ToolPlugin<SchedulerData>["execute"] {
   return async function execute(_context, args) {
-    const result = await apiPost<ToolResult<SchedulerData>>(API_ROUTES.scheduler.base, args);
+    const endpoints = pluginEndpoints<SchedulerEndpoints>("scheduler");
+    const { method, url } = endpoints.dispatch;
+    const result = await apiCall<ToolResult<SchedulerData>>(url, { method, body: args });
     if (!result.ok) {
       return {
         toolName,
@@ -54,46 +48,26 @@ function makeExecute(toolName: "manageCalendar" | "manageAutomations"): ToolPlug
 
 export const manageCalendarPlugin: ToolPlugin<SchedulerData> = {
   toolDefinition: calendarDefinition,
-  execute: makeExecute("manageCalendar"),
+  execute: makeExecute(MANAGE_CALENDAR),
   isEnabled: () => true,
   generatingMessage: "Updating calendar...",
-  viewComponent: CalendarView,
-  previewComponent: Preview,
+  viewComponent: wrapWithScope("scheduler", CalendarView),
+  previewComponent: wrapWithScope("scheduler", Preview),
 };
 
 export const manageAutomationsPlugin: ToolPlugin<SchedulerData> = {
   toolDefinition: automationsDefinition,
-  execute: makeExecute("manageAutomations"),
+  execute: makeExecute(MANAGE_AUTOMATIONS),
   isEnabled: () => true,
   generatingMessage: "Managing automations...",
-  viewComponent: AutomationsView,
-  // Previews must not share Preview.vue with manageCalendarPlugin —
-  // Preview.vue auto-refreshes from `/api/scheduler` which returns
-  // calendar items, so the automations sidebar would show calendar
-  // data after the first refresh tick (#828 follow-up).
-  previewComponent: AutomationsPreview,
+  viewComponent: wrapWithScope("scheduler", AutomationsView),
+  // Cannot share Preview.vue with manageCalendar — Preview auto-refreshes from /api/scheduler (calendar items), and
+  // the automations sidebar would otherwise show calendar data after the first refresh tick (#828 follow-up).
+  previewComponent: wrapWithScope("scheduler", AutomationsPreview),
 };
 
-// View-only fallback for tool results saved under the pre-split
-// `manageScheduler` name. Registered in src/tools/index.ts so
-// `getPlugin("manageScheduler")` returns this entry and historical
-// chat sessions still render the rich view (LegacySchedulerView
-// dispatches to CalendarView or AutomationsView by data shape).
-//
-// Deliberately a `PluginEntry` (not a `ToolPlugin`) so the absence
-// of `execute` / `isEnabled` makes its view-only nature explicit:
-// no LLM exposure path, no fresh dispatch, just the historical
-// renderer. The tool name is also absent from
-// server/agent/plugin-names.ts and src/config/toolNames.ts, so
-// new sessions cannot pick it up.
-export const legacyManageSchedulerEntry: PluginEntry = {
-  toolDefinition: {
-    type: "function",
-    name: "manageScheduler",
-    prompt: "[deprecated] Split into manageCalendar + manageAutomations (#824).",
-    description: "[deprecated] Split into manageCalendar + manageAutomations (#824). Kept registered for legacy chat-history rendering only.",
-    parameters: { type: "object", properties: {}, required: [] },
-  },
-  viewComponent: LegacySchedulerView,
-  previewComponent: Preview,
-};
+// One plugin module, two tool registrations — see #824 split.
+export const REGISTRATIONS: PluginRegistration[] = [
+  { toolName: MANAGE_CALENDAR, entry: manageCalendarPlugin },
+  { toolName: MANAGE_AUTOMATIONS, entry: manageAutomationsPlugin },
+];

package/src/plugins/scope.ts

@@ -0,0 +1,57 @@
+// Built-in plugin scope wrapper. Wraps a built-in plugin's View /
+// Preview component in `<PluginScopedRoot>` so descendants can pull
+// the same `BrowserPluginRuntime` (via `useRuntime()` from
+// `gui-chat-protocol/vue`) that runtime-loaded plugins receive.
+//
+// Why: the host's runtime plugin loader already wraps runtime
+// plugins (`src/tools/runtimeLoader.ts#wrapWithScopedRoot`). For
+// built-in plugins to opt into the same `useRuntime()` API — incl.
+// `runtime.endpoints` for multi-URL plugins (gui-chat-protocol
+// 0.3.1+) — they need a similar wrapper. This file is that
+// wrapper, used at plugin-registration time so each plugin's
+// `viewComponent` / `previewComponent` carries the scope provider.
+//
+// Endpoints come from the host's runtime registry at SETUP time
+// (not module load) — `pluginEndpoints(scope)` reads from the
+// `installHostContext` registry which is wired in `src/main.ts`
+// before `app.mount`. By the time a plugin's setup() runs the
+// registry is populated.
+
+import { defineComponent, h, markRaw, type Component } from "vue";
+import PluginScopedRoot from "../components/PluginScopedRoot.vue";
+import { pluginEndpoints } from "./api";
+
+/** Wrap a built-in plugin's component (`viewComponent` /
+ *  `previewComponent`) so its descendants can call `useRuntime()`.
+ *  The wrapped component:
+ *
+ *   - looks up the plugin's endpoint group from the host's DI
+ *     registry at setup time,
+ *   - mounts `<PluginScopedRoot pkg-name=<scope> :endpoints>`,
+ *   - forwards every prop / attr / slot through to the inner
+ *     component verbatim.
+ *
+ *  Returns `undefined` when `inner` is `undefined` — matches the
+ *  `getPlugin().viewComponent` / `previewComponent` shape (presence
+ *  is optional).
+ *
+ *  @param scope    plugin scope name (matches the install registry
+ *                  key, e.g. `"todos"`, `"wiki"`, `"mulmoScript"`).
+ *  @param inner    the plugin's raw View / Preview component. */
+export function wrapWithScope<TInner extends Component | undefined>(scope: string, inner: TInner): TInner {
+  if (!inner) return inner;
+  // `markRaw` so reactive containers don't try to proxy this
+  // component object — Vue warns + the proxy can interfere with
+  // internal component identity tracking. Same pattern as
+  // `runtimeLoader.ts#wrapWithScopedRoot`.
+  return markRaw(
+    defineComponent({
+      name: `BuiltInPluginScope:${scope}`,
+      inheritAttrs: false,
+      setup(_props, { attrs, slots }) {
+        const endpoints = pluginEndpoints<Record<string, unknown>>(scope);
+        return () => h(PluginScopedRoot, { pkgName: scope, endpoints }, () => h(inner, attrs, slots));
+      },
+    }),
+  ) as TInner;
+}

package/src/plugins/server-bindings-types.ts

@@ -0,0 +1,38 @@
+// Server-side MCP binding types + the META→endpoint resolver,
+// extracted so both the codegen-generated barrel
+// (`_generated/server-bindings.ts`) and the user-facing barrel
+// (`server.ts`) can import them without a circular dependency.
+//
+// Browser-safe: no Vue / no Node-only imports — same constraint as
+// `meta-types.ts`. Imported from server-side code via tsx.
+
+import type { ToolDefinition } from "gui-chat-protocol";
+import { API_ROUTES } from "../config/apiRoutes";
+import type { PluginMeta, ResolvedRoute } from "./meta-types";
+
+export interface ServerPluginBinding {
+  /** ToolDefinition object — the plugin's MCP-facing schema. The
+   *  `name` field is the lookup key for the MCP tool registry. */
+  readonly def: ToolDefinition;
+  /** Where the MCP bridge POSTs tool calls for this plugin. */
+  readonly endpoint: string;
+}
+
+/** Resolve a plugin's MCP-dispatch URL from its META: looks up
+ *  `apiNamespace`+`apiRoutes[mcpDispatch]` in the host's API_ROUTES
+ *  registry and returns the composed `url`. Throws on a META that
+ *  doesn't declare both fields — the binding can't dispatch without
+ *  them. The lookup-by-namespace lets the host pick up route shape
+ *  changes (path / verb edits) without `BUILT_IN_SERVER_BINDINGS`
+ *  needing to know the URL. */
+export function mcpEndpoint(meta: PluginMeta): string {
+  if (!meta.apiNamespace || !meta.mcpDispatch) {
+    throw new Error(`Plugin "${meta.toolName}" cannot register MCP binding: missing apiNamespace or mcpDispatch in META`);
+  }
+  const namespaceRecord = (API_ROUTES as unknown as Record<string, Record<string, ResolvedRoute>>)[meta.apiNamespace];
+  const route = namespaceRecord?.[meta.mcpDispatch];
+  if (!route) {
+    throw new Error(`Plugin "${meta.toolName}" mcpDispatch route "${meta.mcpDispatch}" not found under API_ROUTES.${meta.apiNamespace}`);
+  }
+  return route.url;
+}