wizards 0.2.16 → 0.2.18

package/apps/runtime/dist/services/space-origin.js

@@ -0,0 +1,164 @@
+import { and, eq } from "drizzle-orm";
+import { db, schema } from "../db/client.js";
+import { UnreadableDocument } from "../documents/parse.js";
+import { ServiceError } from "./errors.js";
+import { filePaths, pageTree, tablePaths } from "./knowledge.js";
+import { convertDocument, fillCategories, summarizeValues } from "./knowledge-model.js";
+import { putOriginFile } from "./project-files.js";
+import { queueIndex } from "./project-index.js";
+import { putCategory, setItemCategories } from "./space-categories.js";
+import { listOrigin, putOriginPage, putOriginTable, removeOrigin } from "./space-data.js";
+/**
+ * `server.spaceData` of a plugin: Wissen it writes under keys of its own, with Kategorien. The
+ * plugin's id is the origin of everything it writes; a person who changes an item keeps it.
+ */
+export function originData(origin) {
+    return {
+        async putCategories({ space, categories, proposed }) {
+            for (const c of categories) {
+                let tableId = null;
+                if (c.column) {
+                    const table = await db.query.spaceTable.findFirst({
+                        where: and(eq(schema.spaceTable.projectId, space), eq(schema.spaceTable.origin, origin), eq(schema.spaceTable.originKey, c.column.table)),
+                        columns: { id: true },
+                    });
+                    if (!table) {
+                        throw new ServiceError("invalid", `There is no table with the key "${c.column.table}".`);
+                    }
+                    tableId = table.id;
+                }
+                await putCategory(space, {
+                    name: c.name,
+                    type: c.type,
+                    unit: c.unit,
+                    multiple: c.multiple,
+                    ordered: c.ordered,
+                    hint: c.hint,
+                    values: c.values,
+                    tableId,
+                    columnId: c.column?.column ?? null,
+                }, { origin, proposed });
+            }
+        },
+        async putPage(input) {
+            const written = await putOriginPage(origin, {
+                ...input,
+                categories: input.categories,
+            });
+            if (input.fill && written.state === "written") {
+                const changed = await fillCategories(input.space, { pageId: written.id }, input.markdown, input.title).catch((err) => {
+                    console.error(`[plugin ${origin}] Kategorien`, err);
+                    return false;
+                });
+                if (changed) {
+                    queueIndex(`P:${written.id}`);
+                }
+            }
+            return { ...written, path: (await pageTree(input.space)).get(written.id)?.path ?? "" };
+        },
+        async putTable(input) {
+            const written = await putOriginTable(origin, {
+                ...input,
+                categories: input.categories,
+            });
+            return { ...written, path: (await tablePaths(input.space)).get(written.id) ?? "" };
+        },
+        async putFile(input) {
+            const id = await putOriginFile(origin, {
+                ...input,
+                categories: input.categories,
+            });
+            return { id, path: (await filePaths(input.space)).get(id) ?? "" };
+        },
+        async putDocument(input) {
+            const id = await putOriginFile(origin, { ...input, categories: undefined });
+            const file = await db.query.projectFile.findFirst({ where: eq(schema.projectFile.id, id) });
+            if (!file) {
+                throw new ServiceError("not_found", "The document went while it was read.");
+            }
+            const path = (await filePaths(input.space)).get(id) ?? "";
+            const kept = (await db.query.spacePage.findFirst({
+                where: and(eq(schema.spacePage.fileId, id), eq(schema.spacePage.kept, true)),
+                columns: { id: true },
+            })) ??
+                (await db.query.spaceTable.findFirst({
+                    where: and(eq(schema.spaceTable.fileId, id), eq(schema.spaceTable.kept, true)),
+                    columns: { id: true },
+                }));
+            if (kept) {
+                return { id, path, state: "kept", items: [], review: null };
+            }
+            let converted;
+            try {
+                converted = await convertDocument(file, input.data);
+            }
+            catch (err) {
+                if (err instanceof UnreadableDocument) {
+                    queueIndex(`f:${id}`);
+                    return { id, path, state: "written", items: [], review: err.message };
+                }
+                throw err;
+            }
+            await db
+                .update(schema.projectFile)
+                .set({
+                textHash: converted.textHash,
+                pages: converted.pages,
+                chars: converted.chars,
+                updatedAt: new Date(),
+            })
+                .where(eq(schema.projectFile.id, id));
+            const [tree, tables] = await Promise.all([pageTree(input.space), tablePaths(input.space)]);
+            const items = await Promise.all(converted.items.map(async (key) => {
+                const itemId = key.slice(2);
+                if (key[0] === "p") {
+                    const node = tree.get(itemId);
+                    return {
+                        kind: "page",
+                        id: itemId,
+                        path: node?.path ?? "",
+                        title: node?.title ?? "",
+                    };
+                }
+                const table = await db.query.spaceTable.findFirst({
+                    where: eq(schema.spaceTable.id, itemId),
+                    columns: { title: true },
+                });
+                return {
+                    kind: "table",
+                    id: itemId,
+                    path: tables.get(itemId) ?? "",
+                    title: table?.title ?? "",
+                };
+            }));
+            const first = items[0];
+            const ref = first
+                ? first.kind === "page"
+                    ? { pageId: first.id }
+                    : { tableId: first.id }
+                : { fileId: id };
+            if (input.categories) {
+                await setItemCategories(input.space, ref, input.categories, "origin");
+            }
+            if (input.fill) {
+                await fillCategories(input.space, ref, converted.text, input.name).catch((err) => {
+                    console.error(`[plugin ${origin}] Kategorien`, err);
+                    return false;
+                });
+            }
+            if (input.categories || input.fill) {
+                queueIndex(first ? `${first.kind === "page" ? "P" : "t"}:${first.id}` : `f:${id}`);
+            }
+            const review = first?.kind === "page"
+                ? ((await db.query.spacePage.findFirst({
+                    where: eq(schema.spacePage.id, first.id),
+                    columns: { review: true },
+                }))?.review ?? null)
+                : null;
+            return { id, path, state: "written", items, review };
+        },
+        list: (space) => listOrigin(origin, space),
+        remove: (space, key) => removeOrigin(origin, space, key),
+        summarize: (space, category, value) => summarizeValues(space, category, value),
+    };
+}

package/apps/runtime/dist/services/spaces.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { tableColumnsSchema } from "@engenty-wizards/shared/engenty/data-tables";
+import { CATEGORY_TYPES } from "@engenty-wizards/shared/knowledge";
 import { PROJECT_LIMITS } from "@engenty-wizards/shared/projects";
 import { SPACE_DATA_LIMITS } from "@engenty-wizards/shared/space-data";
 import { WORKSPACE_LIMITS } from "@engenty-wizards/shared/workspace";
@@ -17,6 +18,7 @@ import { emitDraftChanged } from "./draft-events.js";
 import { notFound, ServiceError } from "./errors.js";
 import { keepFiles, replaceFiles } from "./files.js";
 import { addProjectFile, projectFiles, removeProjectFile } from "./project-files.js";
+import { reindexSpace } from "./project-index.js";
 import { brandColorSchema, projectFactSchema, projectLimit, removeProject, } from "./projects.js";
 import { deleteWizard, draftIssues, parseDraft, rotateShareLink, shareUrl } from "./wizards.js";
 /**
@@ -411,11 +413,15 @@ export async function removeSyncedSpace(rawSpaceId) {
 // --- the space's own tables and pages --------------------------------------------
 // What the admin made under Space → Daten on the install, not what a wizard keeps: those stay
 // where their runs write them. Sent as a whole, it replaces what came before.
+// Since Wissen: sub-pages, where an item came from, Kategorien and what has them. An install of
+// before sends none of it.
 export const syncDataSchema = z.object({
     tables: z
         .array(z.object({
         id: syncedId,
         title: z.string().min(1).max(120),
+        format: z.enum(["faq"]).nullish(),
+        originLabel: z.string().max(120).nullish(),
         columns: tableColumnsSchema,
         rows: z
             .array(z.object({ id: syncedId, cells: z.record(z.string(), z.unknown()) }))
@@ -427,8 +433,48 @@ export const syncDataSchema = z.object({
         id: syncedId,
         title: z.string().min(1).max(200),
         markdown: z.string().max(SPACE_DATA_LIMITS.pageChars),
+        parentId: syncedId.nullish(),
+        position: z.number().int().min(0).optional(),
+        originLabel: z.string().max(120).nullish(),
     }))
         .max(SPACE_DATA_LIMITS.pages),
+    categories: z
+        .array(z.object({
+        id: syncedId,
+        name: z.string().min(1).max(80),
+        type: z.enum(CATEGORY_TYPES),
+        unit: z.string().max(20).nullish(),
+        multiple: z.boolean(),
+        ordered: z.boolean(),
+        hint: z.string().max(120).nullish(),
+        tableId: syncedId.nullish(),
+        columnId: z.string().max(64).nullish(),
+        position: z.number().int().min(0),
+        values: z
+            .array(z.object({
+            id: syncedId,
+            value: z.string().min(1).max(200),
+            position: z.number().int().min(0),
+            summary: z.string().max(20_000).nullish(),
+        }))
+            .max(2000),
+    }))
+        .max(60)
+        .optional(),
+    /** `p:<page>`, `t:<table>`, `r:<row>`: files stay with the install. */
+    assignments: z
+        .array(z.object({
+        categoryId: syncedId,
+        item: z.string().regex(/^[ptr]:[A-Za-z0-9_-]{8,40}$/),
+        valueId: syncedId.nullish(),
+        text: z.string().max(300).nullish(),
+        num: z.number().nullish(),
+        at: z.number().int().nullish(),
+        bool: z.boolean().nullish(),
+        by: z.enum(["person", "origin", "model"]),
+    }))
+        .max(200_000)
+        .optional(),
 });
 /**
  * Takes the space's own tables and pages a local install sent: those it no longer has go, the
@@ -491,12 +537,120 @@ export async function syncSpaceData(rawSpaceId, input) {
             }
         }
         for (const page of input.pages) {
-            const values = { title: page.title, markdown: page.markdown, updatedAt: now };
+            const values = {
+                title: page.title,
+                markdown: page.markdown,
+                position: page.position ?? 0,
+                originLabel: page.originLabel ?? null,
+                // Its place comes after every page is there.
+                parentId: null,
+                slug: null,
+                updatedAt: now,
+            };
             await db
                 .insert(schema.spacePage)
                 .values({ id: page.id, tenantId: currentTenant(), projectId: spaceId, ...values })
                 .onConflictDoUpdate({ target: schema.spacePage.id, set: values });
         }
+        const pagesThere = new Set(pageIds);
+        for (const page of input.pages) {
+            if (page.parentId && pagesThere.has(page.parentId) && page.parentId !== page.id) {
+                await db
+                    .update(schema.spacePage)
+                    .set({ parentId: page.parentId })
+                    .where(eq(schema.spacePage.id, page.id));
+            }
+        }
+        for (const table of input.tables) {
+            await db
+                .update(schema.spaceTable)
+                .set({ format: table.format ?? null, originLabel: table.originLabel ?? null, slug: null })
+                .where(eq(schema.spaceTable.id, table.id));
+        }
+        if (input.categories) {
+            await syncCategories(spaceId, input.categories, input.assignments ?? []);
+        }
     });
+    await reindexSpace(spaceId);
     return { tables: input.tables.length, pages: input.pages.length };
 }
+/** The Kategorien a local install sent, their values, and what has them: they replace these here. */
+async function syncCategories(spaceId, categories, assignments) {
+    const ids = categories.map((c) => c.id);
+    const taken = ids.length
+        ? await db.query.spaceCategory.findMany({
+            where: inArray(schema.spaceCategory.id, ids),
+            columns: { id: true, projectId: true },
+        })
+        : [];
+    if (taken.some((c) => c.projectId !== spaceId)) {
+        throw new ServiceError("refused", "Eine Kennung ist hier schon vergeben.", {
+            reason: "id_taken",
+        });
+    }
+    await db
+        .delete(schema.spaceCategory)
+        .where(and(eq(schema.spaceCategory.projectId, spaceId), ids.length ? notInArray(schema.spaceCategory.id, ids) : undefined));
+    await db.delete(schema.spaceItemCategory).where(eq(schema.spaceItemCategory.projectId, spaceId));
+    const tables = new Set((await db.query.spaceTable.findMany({
+        where: eq(schema.spaceTable.projectId, spaceId),
+        columns: { id: true },
+    })).map((t) => t.id));
+    const values = new Set();
+    for (const c of categories) {
+        const row = {
+            name: c.name,
+            type: c.type,
+            unit: c.unit ?? null,
+            multiple: c.multiple,
+            ordered: c.ordered,
+            hint: c.hint ?? null,
+            proposed: false,
+            tableId: c.tableId && tables.has(c.tableId) ? c.tableId : null,
+            columnId: c.tableId && tables.has(c.tableId) ? (c.columnId ?? null) : null,
+            position: c.position,
+            updatedAt: new Date(),
+        };
+        await db
+            .insert(schema.spaceCategory)
+            .values({ id: c.id, tenantId: currentTenant(), projectId: spaceId, ...row })
+            .onConflictDoUpdate({ target: schema.spaceCategory.id, set: row });
+        const valueIds = c.values.map((v) => v.id);
+        await db
+            .delete(schema.spaceCategoryValue)
+            .where(and(eq(schema.spaceCategoryValue.categoryId, c.id), valueIds.length ? notInArray(schema.spaceCategoryValue.id, valueIds) : undefined));
+        for (const v of c.values) {
+            const set = {
+                value: v.value,
+                position: v.position,
+                summary: v.summary ?? null,
+                summaryAt: v.summary ? new Date() : null,
+            };
+            await db
+                .insert(schema.spaceCategoryValue)
+                .values({ id: v.id, categoryId: c.id, ...set })
+                .onConflictDoUpdate({ target: schema.spaceCategoryValue.id, set });
+            values.add(v.id);
+        }
+    }
+    const known = new Set(ids);
+    const rows = assignments.filter((a) => known.has(a.categoryId) && (!a.valueId || values.has(a.valueId)));
+    for (let i = 0; i < rows.length; i += 200) {
+        await db.insert(schema.spaceItemCategory).values(rows.slice(i, i + 200).map((a) => {
+            const id = a.item.slice(2);
+            return {
+                projectId: spaceId,
+                categoryId: a.categoryId,
+                pageId: a.item[0] === "p" ? id : null,
+                tableId: a.item[0] === "t" ? id : null,
+                rowId: a.item[0] === "r" ? id : null,
+                valueId: a.valueId ?? null,
+                text: a.text ?? null,
+                num: a.num ?? null,
+                at: a.at ?? null,
+                bool: a.bool ?? null,
+                by: a.by,
+            };
+        }));
+    }
+}

package/apps/runtime/dist/tools/browser.js

@@ -141,7 +141,7 @@ export function browserTools(ctx, assets, files) {
         inputSchema: z.object({ url: z.string() }),
         execute: ({ url }) => inTurn(async () => {
             const safe = await assertPublicUrl(url);
-            await ctx.emit("tool", `Öffnet ${safe.hostname}`);
+            await ctx.emit("tool", { code: "opens", params: { name: safe.hostname } });
             const p = await page();
             await p.goto(safe.toString(), { waitUntil: "domcontentloaded", timeout: 30_000 });
             await p.waitForLoadState("networkidle", { timeout: 5000 }).catch(() => undefined);
@@ -154,7 +154,7 @@ export function browserTools(ctx, assets, files) {
         inputSchema: z.object({ ref: z.number() }),
         execute: ({ ref: n }) => inTurn(async () => {
             const p = await page();
-            await ctx.emit("tool", "Klickt im Browser");
+            await ctx.emit("tool", { code: "clicks" });
             const popup = p
                 .context()
                 .waitForEvent("page", { timeout: 3000 })
@@ -176,7 +176,7 @@ export function browserTools(ctx, assets, files) {
         inputSchema: z.object({ ref: z.number(), text: z.string(), submit: z.boolean().optional() }),
         execute: ({ ref: n, text, submit }) => inTurn(async () => {
             const p = await page();
-            await ctx.emit("tool", "Tippt im Browser");
+            await ctx.emit("tool", { code: "types" });
             const el = p.locator(ref(n)).first();
             await el.fill(text, { timeout: 10_000 });
             if (submit) {
@@ -192,7 +192,7 @@ export function browserTools(ctx, assets, files) {
         inputSchema: z.object({ save: z.boolean().optional(), name: z.string().optional() }),
         execute: ({ save, name }) => inTurn(async () => {
             const p = await page();
-            await ctx.emit("tool", "Sieht sich die Seite an");
+            await ctx.emit("tool", { code: "looksAtPage" });
             const png = await p.screenshot({ type: "png" });
             let saved;
             if (save) {
@@ -235,7 +235,10 @@ export function browserTools(ctx, assets, files) {
                 };
             }
         }
-        await ctx.emit("tool", `Wartet auf deine Anmeldung bei ${new URL(origin).hostname}`);
+        await ctx.emit("tool", {
+            code: "waitsForSignIn",
+            params: { name: new URL(origin).hostname },
+        });
         const answer = await ctx.ask({
             kind: "login",
             reason: input.reason,
@@ -321,7 +324,10 @@ export function browserTools(ctx, assets, files) {
         }),
         execute: ({ ref: n, url, path, source }) => inTurn(async () => {
             const p = await page();
-            await ctx.emit("tool", `Lädt ${path.split("/").pop()} herunter`);
+            await ctx.emit("tool", {
+                code: "downloads",
+                params: { name: path.split("/").pop() ?? "" },
+            });
             let data;
             let mime;
             if (url) {

package/apps/runtime/dist/tools/index.js

@@ -49,7 +49,7 @@ export async function buildStepTools(step, ctx, resolved, uploads) {
             inputSchema: z.object({ url: z.string().describe("Absolute http(s) URL") }),
             execute: async ({ url }) => {
                 const safe = await assertPublicUrl(url);
-                await ctx.emit("tool", `Liest ${safe.hostname}`);
+                await ctx.emit("tool", { code: "reads", params: { name: safe.hostname } });
                 const res = await safeFetch(safe.toString(), {
                     signal: AbortSignal.any([ctx.signal, AbortSignal.timeout(20_000)]),
                     headers: { "user-agent": "Mozilla/5.0 (compatible; engenty-wizards/0.1)" },
@@ -115,7 +115,7 @@ export async function buildStepTools(step, ctx, resolved, uploads) {
             description: shellToolDescription(sandbox),
             inputSchema: z.object({ command: z.string(), timeoutSeconds: z.number().optional() }),
             execute: async ({ command, timeoutSeconds }) => {
-                await ctx.emit("tool", `Führt aus: ${command.slice(0, 80)}`);
+                await ctx.emit("tool", { code: "runs", params: { command: command.slice(0, 80) } });
                 return report(await ctx.resources
                     .sandboxHandle()
                     .exec(command, { timeoutMs: timeoutMs(timeoutSeconds) }));
@@ -131,7 +131,7 @@ export async function buildStepTools(step, ctx, resolved, uploads) {
                     timeoutSeconds: z.number().optional(),
                 }),
                 execute: async ({ code, packages, timeoutSeconds }) => {
-                    await ctx.emit("tool", "Führt Python aus");
+                    await ctx.emit("tool", { code: "python" });
                     return report(await ctx.resources.sandboxHandle().runPython(code, {
                         packages,
                         timeoutMs: timeoutMs(timeoutSeconds),
@@ -174,7 +174,7 @@ export async function buildStepTools(step, ctx, resolved, uploads) {
                 aspectRatio: z.enum(["1:1", "16:9", "9:16", "4:5", "3:2", "2:3"]).optional(),
             }),
             execute: async ({ prompt, aspectRatio }) => {
-                await ctx.emit("tool", "Zeichnet ein Bild");
+                await ctx.emit("tool", { code: "drawing" });
                 const media = await generateImageMedia({
                     call: ctx.call,
                     prompt,
@@ -225,10 +225,16 @@ export async function buildStepTools(step, ctx, resolved, uploads) {
         });
         try {
             Object.assign(tools, await mcp.listTools());
-            await ctx.emit("tool", `Verbunden mit ${servers.map((s) => s.name).join(", ")}`);
+            await ctx.emit("tool", {
+                code: "mcpConnected",
+                params: { names: servers.map((s) => s.name).join(", ") },
+            });
         }
         catch (err) {
-            await ctx.emit("info", `MCP-Server nicht erreichbar: ${err.message}`);
+            await ctx.emit("info", {
+                code: "mcpUnreachable",
+                params: { detail: err.message },
+            });
         }
     }
     return {

package/apps/runtime/dist/tools/mail.js

@@ -29,7 +29,7 @@ export function mailTools(step, ctx, files) {
         inputSchema: mailSearchInput,
         execute: (input) => attempt(async () => {
             const { connector, ctx: actionCtx, label } = await open();
-            await ctx.emit("tool", `Durchsucht ${label}`);
+            await ctx.emit("tool", { code: "searchesMail", params: { label } });
             const { mails } = await mailAction(connector, "search", input, actionCtx);
             return {
                 mailbox: label,
@@ -64,7 +64,10 @@ export function mailTools(step, ctx, files) {
         }),
         execute: ({ items }) => attempt(async () => {
             const { connector, ctx: actionCtx, label } = await open();
-            await ctx.emit("tool", `Speichert ${items.length} Belege aus ${label}`);
+            await ctx.emit("tool", {
+                code: "savesReceipts",
+                params: { count: items.length, label },
+            });
             const saved = [];
             for (const item of items) {
                 try {

package/apps/runtime/dist/tools/pages.js

@@ -1,11 +1,12 @@
 import { createTool } from "@mastra/core/tools";
 import { z } from "zod";
 import { runPages, writeRunPage } from "../services/space-data.js";
+import { pageReadInput, readKnowledgePage } from "./project.js";
 import { attempt, clip } from "./shared.js";
 /**
- * Pages of the space for a step that lists "pages": Markdown its wizard keeps for every run —
- * notes, a log, a summary that grows — and the space's own pages to read. They stand in the
- * studio under Space → Daten.
+ * Pages for a step that lists "pages": Markdown its wizard keeps for every run — notes, a log, a
+ * summary that grows — shown in the studio under Space → Daten. Its page_read also reads the
+ * pages of Wissen, by path.
  */
 export function pageTools(ctx) {
     const projectId = ctx.project.id;
@@ -13,29 +14,33 @@ export function pageTools(ctx) {
     return {
         page_read: createTool({
             id: "page_read",
-            description: "Read a page of the space: one this wizard wrote, or one of the space's own. Without a title it lists the pages there are.",
-            inputSchema: z.object({ title: z.string().optional() }),
-            execute: ({ title }) => attempt(async () => {
-                const pages = await runPages(projectId, wizardId);
-                const of = (p) => (p.wizardId ? "wizard" : "space");
-                if (!title?.trim()) {
-                    return {
-                        pages: pages.map((p) => ({ title: p.title, of: of(p), chars: p.markdown.length })),
-                    };
-                }
-                const page = pages.find((p) => p.title.toLowerCase() === title.trim().toLowerCase());
-                if (!page) {
-                    return {
-                        error: `No page "${title}".`,
-                        pages: pages.map((p) => p.title),
-                    };
-                }
-                return { title: page.title, of: of(page), markdown: clip(page.markdown, 40_000) };
+            description: "Read a page: one this wizard wrote, by its title, or a page of Wissen, by its path (pages/…). Without either it lists the wizard's pages.",
+            inputSchema: z.object({
+                title: z.string().optional().describe("A page this wizard wrote"),
+                path: pageReadInput.path.optional(),
+                section: pageReadInput.section,
+                from: pageReadInput.from,
             }),
+            execute: ({ title, path, section, from }) => {
+                if (path?.trim()) {
+                    return readKnowledgePage(ctx, { path, section, from });
+                }
+                return attempt(async () => {
+                    const pages = await runPages(projectId, wizardId);
+                    if (!title?.trim()) {
+                        return { pages: pages.map((p) => ({ title: p.title, chars: p.markdown.length })) };
+                    }
+                    const page = pages.find((p) => p.title.toLowerCase() === title.trim().toLowerCase());
+                    if (!page) {
+                        return { error: `No page "${title}".`, pages: pages.map((p) => p.title) };
+                    }
+                    return { title: page.title, markdown: clip(page.markdown, 40_000) };
+                });
+            },
         }),
         page_write: createTool({
             id: "page_write",
-            description: "Write a page of this wizard in Markdown, kept for every later run and shown to the admin in the studio. A page with the same title is replaced — or added to with append: true (a log, a list that grows). The space's own pages are read-only.",
+            description: "Write a page of this wizard in Markdown, kept for every later run and shown to the admin in the studio. A page with the same title is replaced — or added to with append: true (a log, a list that grows). Pages of Wissen are read-only.",
             inputSchema: z.object({
                 title: z.string().min(1).max(200),
                 markdown: z.string().max(200_000),
@@ -43,7 +48,7 @@ export function pageTools(ctx) {
             }),
             execute: (input) => attempt(async () => {
                 const page = await writeRunPage(projectId, wizardId, input);
-                await ctx.emit("tool", `Schreibt die Seite „${page.title}“`);
+                await ctx.emit("tool", { code: "writesPage", params: { title: page.title } });
                 return page;
             }),
         }),