mulmoclaude 0.5.2 → 0.6.0

package/src/plugins/accounting/meta.ts

@@ -0,0 +1,91 @@
+// Central-registry-facing metadata that the accounting plugin owns.
+// Imported by host aggregators (`src/config/*` and
+// `server/workspace/paths.ts`) which iterate over every plugin's
+// META and merge automatically. Host code holds zero
+// plugin-specific literals — when a constant is "produced by the
+// plugin", the plugin is the source of truth.
+//
+// Browser-safe: no Vue imports, no server-only imports. Both server
+// and frontend code can import this file.
+
+import { definePluginMeta } from "../meta-types";
+
+/** Single object the host aggregators iterate over. `definePluginMeta`
+ *  type-checks the shape (typo / missing field surfaces at compile
+ *  time) AND preserves nested literal types via TS 5.0+'s `const`
+ *  type parameter. Helper functions / types specific to this plugin
+ *  (e.g. `bookChannel(bookId)`, `BookChannelPayload`) live below as
+ *  separate named exports — the META object only carries the static
+ *  values that aggregate generically. */
+export const META = definePluginMeta({
+  toolName: "manageAccounting",
+  apiNamespace: "accounting",
+  apiRoutes: {
+    /** POST /api/accounting — single dispatch with action discriminator. */
+    dispatch: { method: "POST", path: "" },
+  },
+  mcpDispatch: "dispatch",
+  // Flat keys merged into the central `WORKSPACE_DIRS`. Created
+  // lazily on first `createBook` so default workspaces don't get a
+  // stub `accounting/` they never use.
+  workspaceDirs: {
+    accounting: "data/accounting",
+    // `accounting/books/<bookId>/{accounts.json, journal/YYYY-MM.jsonl,
+    //  snapshots/YYYY-MM.json}` — multi-book layout (#1078).
+    accountingBooks: "data/accounting/books",
+  },
+  // Static pubsub channel names merged into the central
+  // `PUBSUB_CHANNELS`. Per-book data changes ride
+  // `bookChannel(bookId)` (helper below); book-list-level events
+  // (a new book was created, an existing one was deleted) ride
+  // `accountingBooks` so a `JournalList.vue` viewing book A doesn't
+  // repaint when the user creates book B from another window.
+  staticChannels: {
+    accountingBooks: "accounting:books",
+  },
+});
+
+/** Channel factory for per-book event streams. Subscribers:
+ *  `useAccountingChannel(bookId)`. Publisher:
+ *  `server/accounting/eventPublisher.ts`. */
+export function bookChannel(bookId: string): string {
+  return `accounting:${bookId}`;
+}
+
+/** Event kinds that ride `bookChannel(bookId)`. Single source of
+ *  truth for both publishers (server/accounting) and subscribers
+ *  (the View) — anyone branching on event kind imports from here
+ *  and the type system catches drift on either side.
+ *
+ *  - `journal`             — addEntry / voidEntry hit the books at `period`.
+ *                            Refetch the journal list and (if the View is
+ *                            showing balances at or after `period`) the
+ *                            relevant report.
+ *  - `opening`             — setOpeningBalances. Affects every period from
+ *                            the opening date forward; refetch everything.
+ *  - `accounts`            — chart-of-accounts mutation that may affect
+ *                            aggregation (account type changed). Refetch
+ *                            accounts and the active report.
+ *  - `snapshotsRebuilding` / `snapshotsReady` — purely informational;
+ *                            the View can show a "calculating" spinner
+ *                            during rebuild, but the lazy-rebuild safety
+ *                            net means a refetch always returns the right
+ *                            answer regardless. */
+export const BOOK_EVENT_KINDS = {
+  journal: "journal",
+  opening: "opening",
+  accounts: "accounts",
+  snapshotsRebuilding: "snapshots-rebuilding",
+  snapshotsReady: "snapshots-ready",
+} as const;
+
+export type BookEventKind = (typeof BOOK_EVENT_KINDS)[keyof typeof BOOK_EVENT_KINDS];
+
+/** Payload published on `bookChannel(bookId)`. */
+export interface BookChannelPayload {
+  kind: BookEventKind;
+  /** YYYY-MM. Present for `journal` (entry month) and the snapshot
+   *  events (the earliest invalidated month). Absent for `opening`
+   *  (which invalidates everything) and `accounts`. */
+  period?: string;
+}

package/src/plugins/accounting/timeSeriesEnums.ts

@@ -0,0 +1,16 @@
+// Single source of truth for the `getTimeSeries` action's enum
+// surfaces — kept outside the server module so the frontend tool
+// definition (`definition.ts`) and the server validator
+// (`server/accounting/timeSeries.ts`) can both import without
+// crossing the src ↔ server boundary in the wrong direction.
+//
+// Adding a new metric / granularity: extend the array here, then
+// extend the corresponding switch / aggregation in
+// `server/accounting/timeSeries.ts`. The LLM tool schema picks up
+// the new value automatically via `definition.ts`'s `enum` field.
+
+export const TIME_SERIES_METRICS = ["revenue", "expense", "netIncome", "accountBalance"] as const;
+export type TimeSeriesMetric = (typeof TIME_SERIES_METRICS)[number];
+
+export const TIME_SERIES_GRANULARITIES = ["month", "quarter", "year"] as const;
+export type TimeSeriesGranularity = (typeof TIME_SERIES_GRANULARITIES)[number];

package/src/plugins/api.ts

@@ -0,0 +1,125 @@
+// Plugin-side DI container.
+//
+// Plugins must NOT import from `src/config/*` (the host's URL /
+// constants registry) — the host owns those values and decides
+// when / how to provide them. This file is the indirection: plugins
+// call the getters here; the host wires the actual values once at
+// boot via `installHostContext`.
+//
+// Loose coupling means:
+//
+//   - This file references zero `src/config/*` modules. The
+//     `HostContext` interface declares only the contract — the
+//     host is free to swap in test doubles, runtime overrides, or
+//     a future server-driven config without touching any plugin.
+//   - Plugins import `pluginEndpoints` / `pluginPageRoute` / etc.
+//     from `../api`; they never see `API_ROUTES`, `PAGE_ROUTES`,
+//     `BUILTIN_ROLE_IDS`, or `getAllPluginNames` directly.
+//   - Tests install their own `HostContext` via the same
+//     `installHostContext` entry point (see
+//     `test/helpers/installHostContext.ts`).
+//
+// Adding a new injected capability: add a typed field to
+// `HostContext`, a corresponding getter helper here, and update
+// the host's install call in `src/main.ts`.
+
+import type { ResolvedRoute } from "./meta-types";
+
+/** A flat group of plugin-owned routes (`{ create: { method, url } }`).
+ *  Each plugin scope maps to one of these. The host registry hands
+ *  back resolved-URL records — the plugin author wrote `{ method,
+ *  path }` in `meta.ts`, the host composed `/api/<namespace><path>`. */
+export type EndpointGroup = Readonly<Record<string, ResolvedRoute>>;
+
+/** Host-shared groups (`files`, `imageStore`, `mcpTools`, `wiki`,
+ *  `roles`, `image`) that carry plain string URLs rather than the
+ *  plugin `{ method, url }` shape. Kept around so the same registry
+ *  can host both plugin-owned routes and the cross-cutting host
+ *  endpoints plugins reach for. */
+export type HostEndpointGroup = Readonly<Record<string, string>>;
+
+/** The full registry of plugin endpoint groups, keyed by scope
+ *  name (`"todos"`, `"wiki"`, `"mulmoScript"`, …). Values are either
+ *  plugin-owned `EndpointGroup` records or host-owned
+ *  `HostEndpointGroup` records — `pluginEndpoints<E>` narrows to the
+ *  caller-declared shape. */
+export type EndpointRegistry = Readonly<Record<string, EndpointGroup | HostEndpointGroup>>;
+
+/** Everything the host hands to plugins at boot. Each field is
+ *  read-only — plugins consume, never mutate. */
+export interface HostContext {
+  /** URL maps for each plugin's API namespace. */
+  readonly endpoints: EndpointRegistry;
+  /** Built-in role IDs (e.g. `general`, `engineer`). Used by
+   *  plugins that start a chat with a specific role. */
+  readonly builtinRoleIds: Readonly<Record<string, string>>;
+  /** Vue-router page-name constants. Used by plugins that need to
+   *  branch on the current page or push a navigation. */
+  readonly pageRoutes: Readonly<Record<string, string>>;
+  /** Snapshot of every registered plugin's tool name. Used by
+   *  manageRoles to populate the role-editor's plugin picker. */
+  readonly getAllPluginNames: () => readonly string[];
+}
+
+let installedContext: HostContext | null = null;
+
+/** Host calls this once at boot (`src/main.ts`) BEFORE component
+ *  setup runs. Calling it twice replaces the prior context — useful
+ *  for tests; production should install exactly once. */
+export function installHostContext(context: HostContext): void {
+  installedContext = context;
+}
+
+/** Strict reader — throws if the host hasn't installed yet. The
+ *  intent is fail-fast: a plugin invoked before install is a wiring
+ *  bug, not a state we want to silently paper over. */
+function requireContext(): HostContext {
+  if (installedContext === null) {
+    throw new Error("Plugin host context not installed. Call installHostContext(...) at app boot before mounting any plugin component.");
+  }
+  return installedContext;
+}
+
+/** Returns the URL group for a plugin's scope. The generic `E` lets
+ *  the caller declare the expected shape — plugins typically pass
+ *  their own typed interface so member access is type-checked
+ *  (`pluginEndpoints<TodoEndpoints>("todos").create.url`).
+ *
+ *  Constraint is `object` (not `EndpointGroup` /
+ *  `HostEndpointGroup`) so plugin-owned `Record<string, ResolvedRoute>`
+ *  shapes AND host-shared `Record<string, string>` shapes both
+ *  satisfy it — `pluginEndpoints` is the indirection that lets a
+ *  caller assert the contract it expects. */
+export function pluginEndpoints<E extends object = EndpointGroup>(scope: string): E {
+  const group = requireContext().endpoints[scope];
+  if (!group) {
+    throw new Error(`Unknown plugin endpoint scope: "${scope}"`);
+  }
+  return group as E;
+}
+
+/** Built-in role IDs (e.g. `pluginBuiltinRoleIds().general`). */
+export function pluginBuiltinRoleIds(): Readonly<Record<string, string>> {
+  return requireContext().builtinRoleIds;
+}
+
+/** A specific Vue-router page-name constant
+ *  (`pluginPageRoute("wiki")`). Throws on unknown name. */
+export function pluginPageRoute(name: string): string {
+  const route = requireContext().pageRoutes[name];
+  if (!route) {
+    throw new Error(`Unknown page route: "${name}"`);
+  }
+  return route;
+}
+
+/** Snapshot of every registered plugin's tool name. */
+export function pluginAllPluginNames(): readonly string[] {
+  return requireContext().getAllPluginNames();
+}
+
+/** Test-only: drop the installed context so the next `installHostContext`
+ *  starts from a clean slate. Production code should not call this. */
+export function resetHostContextForTest(): void {
+  installedContext = null;
+}

package/src/plugins/canvas/View.vue

@@ -15,7 +15,7 @@
                 @click="brushSize = size"
               >
                 <div
-                  :class="'bg-gray-800 rounded-full mx-auto'"
+                  class="bg-gray-800 rounded-full mx-auto"
                   :style="{
                     width: Math.max(2, size * 1) + 'px',
                     height: Math.max(2, size * 1) + 'px',
@@ -63,14 +63,14 @@
         :key="`${selectedResult?.uuid || 'default'}-${canvasRenderKey}`"
         :width="canvasWidth"
         :height="canvasHeight"
-        :stroke-type="'dash'"
-        :line-cap="'round'"
-        :line-join="'round'"
+        stroke-type="dash"
+        line-cap="round"
+        line-join="round"
         :fill-shape="false"
         :eraser="false"
         :line-width="brushSize"
         :color="brushColor"
-        :background-color="'#FFFFFF'"
+        background-color="#FFFFFF"
         :background-image="backgroundImage"
         :watermark="undefined"
         save-as="png"
@@ -104,10 +104,12 @@ import VueDrawingCanvas from "vue-drawing-canvas";
 import type { ToolResult } from "gui-chat-protocol/vue";
 import type { ImageToolData } from "./definition";
 import { apiPut } from "../../utils/api";
-import { API_ROUTES } from "../../config/apiRoutes";
+import { pluginEndpoints } from "../api";
 import { resolveImageSrc } from "../../utils/image/resolve";
 import { bumpImage } from "../../utils/image/cacheBust";
 
+const imageStoreEndpoints = pluginEndpoints<{ update: string }>("imageStore");
+
 const { t } = useI18n();
 
 const props = defineProps<{
@@ -130,10 +132,6 @@ const artStyles = [
   { id: "pixelart", label: "Pixel Art" },
 ];
 
-const applyStyle = (style: { id: string; label: string }) => {
-  props.sendTextMessage?.(`Turn my drawing on the canvas into a ${style.label} style image.`);
-};
-
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const canvasRef = ref<any>(null);
 const containerRef = ref<HTMLDivElement | null>(null);
@@ -158,6 +156,16 @@ const imagePath = computed(() => {
   return stored;
 });
 
+const applyStyle = (style: { id: string; label: string }) => {
+  // Embed the canvas image's workspace path directly so the LLM has
+  // it in plain text and can quote it back as `imagePaths` to the
+  // editImages tool. Falls back to the path-less phrasing only when
+  // openCanvas hasn't been linked to a saved file yet.
+  const path = imagePath.value;
+  const text = path ? t("pluginCanvas.stylePromptWithPath", { path, style: style.label }) : t("pluginCanvas.stylePromptNoPath", { style: style.label });
+  props.sendTextMessage?.(text);
+};
+
 // Per-mount cache buster for the VueDrawingCanvas child. The URL
 // must be stable for the lifetime of one canvas instance — if it
 // changes while the child is alive (e.g. from a post-save bump),
@@ -177,25 +185,12 @@ const backgroundImage = computed(() => {
 let uploadInFlight = false;
 let pendingSave = false;
 
-// Undo/redo kick off the library's async redraw; give it a tick to
-// composite before we snapshot-and-upload.
-const undo = () => {
-  canvasRef.value?.undo();
-  setTimeout(saveDrawing, 50);
-};
-const redo = () => {
-  canvasRef.value?.redo();
-  setTimeout(saveDrawing, 50);
-};
-const clear = () => {
-  canvasRef.value?.reset();
-  saveDrawing();
-};
-
 // Snapshot the current bitmap and PUT it back to the pre-allocated
 // file. No result mutation — the path is fixed from canvas creation,
-// so nothing upstream needs to know about saves.
-const saveDrawing = async (): Promise<void> => {
+// so nothing upstream needs to know about saves. `function` (not
+// `const`) so the undo/redo/clear handlers below can reference it
+// without TDZ ordering problems.
+async function saveDrawing(): Promise<void> {
   if (!canvasRef.value || !imagePath.value) return;
   if (uploadInFlight) {
     pendingSave = true;
@@ -204,7 +199,7 @@ const saveDrawing = async (): Promise<void> => {
   uploadInFlight = true;
   try {
     const imageDataUri: string = await canvasRef.value.save();
-    const result = await apiPut<{ path: string }>(API_ROUTES.image.update, {
+    const result = await apiPut<{ path: string }>(imageStoreEndpoints.update, {
       relativePath: imagePath.value,
       imageData: imageDataUri,
     });
@@ -219,6 +214,21 @@ const saveDrawing = async (): Promise<void> => {
       void saveDrawing();
     }
   }
+}
+
+// Undo/redo kick off the library's async redraw; give it a tick to
+// composite before we snapshot-and-upload.
+const undo = () => {
+  canvasRef.value?.undo();
+  setTimeout(saveDrawing, 50);
+};
+const redo = () => {
+  canvasRef.value?.redo();
+  setTimeout(saveDrawing, 50);
+};
+const clear = () => {
+  canvasRef.value?.reset();
+  saveDrawing();
 };
 
 const updateCanvasSize = () => {

package/src/plugins/canvas/definition.ts

@@ -1,6 +1,9 @@
 import type { ToolDefinition } from "gui-chat-protocol";
+import { META } from "./meta";
+import type { ResolvedRoute } from "../meta-types";
 
-export const TOOL_NAME = "openCanvas";
+export const TOOL_NAME = META.toolName;
+export type CanvasEndpoints = { readonly [K in keyof typeof META.apiRoutes]: ResolvedRoute };
 
 export interface ImageToolData {
   imageData: string;
@@ -21,10 +24,9 @@ const toolDefinition: ToolDefinition = {
 
 export default toolDefinition;
 
-export const executeOpenCanvas = async () => {
-  return {
-    message: "Drawing canvas opened",
-    instructions: "Tell the user that you are able to turn the drawing into a photographic image, a manga or any other art style.",
-    title: "Drawing Canvas",
-  };
-};
+export const executeOpenCanvas = async (imagePath: string) => ({
+  message: `Drawing canvas opened. The drawing will be saved to: ${imagePath}`,
+  instructions:
+    "The drawing canvas is now displayed and the user is about to draw on it. Tell them you can turn their drawing into a photographic image, manga, or any other art style once they're done.",
+  title: "Drawing Canvas",
+});

package/src/plugins/canvas/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 { ImageToolData } from "./definition";
+import toolDefinition, { TOOL_NAME, type CanvasEndpoints, type ImageToolData } 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 canvasPlugin: ToolPlugin<ImageToolData> = {
   toolDefinition,
 
   async execute(_context, args) {
-    const result = await apiPost<ToolResult<ImageToolData>>(API_ROUTES.plugins.canvas, args);
+    const endpoints = pluginEndpoints<CanvasEndpoints>("canvas");
+    const { method, url } = endpoints.dispatch;
+    const result = await apiCall<ToolResult<ImageToolData>>(url, { method, body: args });
     if (!result.ok) {
       return {
         toolName: TOOL_NAME,
@@ -29,9 +31,14 @@ const canvasPlugin: ToolPlugin<ImageToolData> = {
 
   isEnabled: () => true,
   generatingMessage: "Opening drawing canvas...",
-  viewComponent: View,
-  previewComponent: Preview,
+  viewComponent: wrapWithScope("canvas", View),
+  previewComponent: wrapWithScope("canvas", Preview),
 };
 
 export default canvasPlugin;
 export { TOOL_NAME };
+
+export const REGISTRATION: PluginRegistration = {
+  toolName: TOOL_NAME,
+  entry: canvasPlugin,
+};

package/src/plugins/canvas/meta.ts

@@ -0,0 +1,12 @@
+import { definePluginMeta } from "../meta-types";
+
+export const META = definePluginMeta({
+  toolName: "openCanvas",
+  apiNamespace: "canvas",
+  apiRoutes: {
+    /** POST /api/canvas — open a drawing canvas the user can sketch
+     *  on. Result carries the workspace-relative image path. */
+    dispatch: { method: "POST", path: "" },
+  },
+  mcpDispatch: "dispatch",
+});

package/src/plugins/chart/Preview.vue

@@ -36,7 +36,7 @@ const hint = computed(() => {
 });
 
 function inferTypeFromOption(option: Record<string, unknown>): string | null {
-  const series = option.series;
+  const { series } = option;
   if (Array.isArray(series) && series.length > 0) {
     const first = series[0] as { type?: unknown };
     if (typeof first.type === "string") return first.type;

package/src/plugins/chart/View.vue

@@ -52,7 +52,7 @@ const data = computed(() => props.selectedResult.data);
 const charts = computed<ChartEntry[]>(() => data.value?.document?.charts ?? []);
 const title = computed(() => data.value?.title ?? data.value?.document?.title);
 
-const containers = ref<Array<HTMLDivElement | null>>([]);
+const containers = ref<(HTMLDivElement | null)[]>([]);
 // Kept as a plain array (not `ref`): ECharts instances are managed
 // imperatively and should not trigger Vue re-renders on mutation.
 const instances: echarts.ECharts[] = [];
@@ -74,7 +74,7 @@ function disposeAll(): void {
 // (zoomOnMouseWheel=true), which traps the scroll over the canvas.
 // Toolbox/slider/drag zoom still work — only the wheel is disabled.
 function disableWheelZoom(option: Record<string, unknown>): Record<string, unknown> {
-  const dataZoom = option.dataZoom;
+  const { dataZoom } = option;
   if (dataZoom === undefined || dataZoom === null) return option;
   const normalise = (entry: unknown): unknown => {
     if (!isRecord(entry)) return entry;

package/src/plugins/chart/definition.ts

@@ -1,10 +1,20 @@
 import type { ToolDefinition } from "gui-chat-protocol";
+import { META } from "./meta";
+import type { ResolvedRoute } from "../meta-types";
 
-export const TOOL_NAME = "presentChart";
+// Re-export so existing `import { TOOL_NAME } from "./definition"`
+// callers (server/agent/plugin-names.ts ledger, scope wrapper, …)
+// keep compiling — META.toolName is the source of truth.
+export const TOOL_NAME = META.toolName;
+
+/** Resolved-URL view of the chart plugin's routes. Plugin code reads
+ *  `endpoints.create.{method, url}` to drive `apiCall`. Auto-derived
+ *  from META so adding a route in `meta.ts` is the only edit. */
+export type ChartEndpoints = { readonly [K in keyof typeof META.apiRoutes]: ResolvedRoute };
 
 const toolDefinition: ToolDefinition = {
   type: "function",
-  name: TOOL_NAME,
+  name: META.toolName,
   description:
     "Save and present one or more Apache ECharts visualizations as a single document. Use this for line, bar, area, scatter, pie, candlestick, heatmap, sankey, or graph/network charts — anything ECharts supports. Pass ECharts option object(s) directly; the plugin calls setOption on each one. Use `charts: []` array form even for a single chart so multi-chart dashboards share the same slug.",
   parameters: {

package/src/plugins/chart/index.ts

@@ -1,10 +1,11 @@
-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 toolDefinition, { TOOL_NAME, type ChartEndpoints } 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";
 
 export interface ChartEntry {
@@ -28,7 +29,9 @@ const presentChartPlugin: ToolPlugin<PresentChartData> = {
   toolDefinition,
 
   async execute(_context, args) {
-    const result = await apiPost<ToolResult<PresentChartData>>(API_ROUTES.chart.present, args);
+    const endpoints = pluginEndpoints<ChartEndpoints>("chart");
+    const { method, url } = endpoints.create;
+    const result = await apiCall<ToolResult<PresentChartData>>(url, { method, body: args });
     if (!result.ok) {
       return {
         toolName: TOOL_NAME,
@@ -45,9 +48,14 @@ const presentChartPlugin: ToolPlugin<PresentChartData> = {
 
   isEnabled: () => true,
   generatingMessage: "Rendering chart…",
-  viewComponent: View,
-  previewComponent: Preview,
+  viewComponent: wrapWithScope("chart", View),
+  previewComponent: wrapWithScope("chart", Preview),
 };
 
 export default presentChartPlugin;
 export { TOOL_NAME };
+
+export const REGISTRATION: PluginRegistration = {
+  toolName: TOOL_NAME,
+  entry: presentChartPlugin,
+};

package/src/plugins/chart/meta.ts

@@ -0,0 +1,18 @@
+// Central-registry-facing metadata for the chart plugin. Imported by
+// host aggregators (`src/plugins/metas.ts`) which iterate every
+// plugin's META and merge per-dimension records — host code holds
+// zero plugin-specific literals.
+//
+// Browser-safe: no Vue / no Node-only imports.
+
+import { definePluginMeta } from "../meta-types";
+
+export const META = definePluginMeta({
+  toolName: "presentChart",
+  apiNamespace: "chart",
+  apiRoutes: {
+    /** POST /api/chart — render and save a chart document. */
+    create: { method: "POST", path: "" },
+  },
+  mcpDispatch: "create",
+});

package/src/plugins/editImages/definition.ts

@@ -0,0 +1,44 @@
+import type { ToolDefinition } from "gui-chat-protocol";
+
+export const TOOL_NAME = "editImages";
+
+/** Endpoint contract — both `editImages` and `generateImage` plugins
+ *  share the host's `image` scope (the host's `API_ROUTES.image.*`).
+ *  Each picks the URL it needs (`edit` / `generate` / `update`). */
+export interface ImageEndpoints {
+  [key: string]: string;
+  generate: string;
+  edit: string;
+  upload: string;
+  update: string;
+}
+
+export interface ImageToolData {
+  imageData: string;
+  prompt: string;
+}
+
+const toolDefinition: ToolDefinition = {
+  type: "function",
+  name: TOOL_NAME,
+  description: "Edit one or more existing images based on a text prompt. Returns a single new image.",
+  prompt: `When the user asks to transform or restyle an existing image (e.g. "turn this into a Ghibli-style image", "combine these two photos"), call ${TOOL_NAME} with the workspace-relative paths of the source images in \`imagePaths\` and the edit instructions in \`prompt\`. Use a single-element array for one image; pass two or more paths to combine multiple images.`,
+  parameters: {
+    type: "object",
+    properties: {
+      prompt: {
+        type: "string",
+        description: "Description of the edits to be made to the image(s) in English",
+      },
+      imagePaths: {
+        type: "array",
+        items: { type: "string" },
+        description:
+          'Workspace-relative paths of the source images to edit (e.g. ["artifacts/images/2026/04/abc.png"]). Pass at least one path. Multiple paths are combined into a single result image.',
+      },
+    },
+    required: ["prompt", "imagePaths"],
+  },
+};
+
+export default toolDefinition;

package/src/plugins/editImages/index.ts

@@ -0,0 +1,43 @@
+import type { PluginRegistration, ToolPlugin } from "../../tools/types";
+import type { ToolResult } from "gui-chat-protocol";
+import toolDefinition, { TOOL_NAME, type ImageEndpoints, type ImageToolData } 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 { makeUuid } from "../../utils/id";
+
+const editImagesPlugin: ToolPlugin<ImageToolData> = {
+  toolDefinition,
+
+  async execute(_context, args) {
+    const endpoints = pluginEndpoints<ImageEndpoints>("image");
+    const result = await apiPost<ToolResult<ImageToolData>>(endpoints.edit, args);
+    if (!result.ok) {
+      return {
+        toolName: TOOL_NAME,
+        uuid: makeUuid(),
+        message: result.error,
+      };
+    }
+    return {
+      ...result.data,
+      toolName: TOOL_NAME,
+      uuid: makeUuid(),
+    };
+  },
+
+  isEnabled: () => true,
+  generatingMessage: "Editing images...",
+  viewComponent: wrapWithScope("image", View),
+  previewComponent: wrapWithScope("image", Preview),
+};
+
+export default editImagesPlugin;
+export { TOOL_NAME };
+
+export const REGISTRATION: PluginRegistration = {
+  toolName: TOOL_NAME,
+  entry: editImagesPlugin,
+};

package/src/plugins/editImages/meta.ts

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