@abraca/mcp 2.8.0 → 2.10.0

package/dist/abracadabra-mcp.esm.js

@@ -12800,10 +12800,10 @@ var StdioServerTransport = class {
 * fields (status, activeToolCall) so the cou-sh dashboard shows real-time activity.
 */
 /** Per-field cap for detail strings (chars). Keeps awareness lean. */
-const DETAIL_MAX = 4e3;
-function cap(s) {
+const DETAIL_MAX$1 = 4e3;
+function cap$1(s) {
 	if (typeof s !== "string") return void 0;
-	return s.length > DETAIL_MAX ? `${s.slice(0, DETAIL_MAX)}\n… (truncated)` : s;
+	return s.length > DETAIL_MAX$1 ? `${s.slice(0, DETAIL_MAX$1)}\n… (truncated)` : s;
 }
 /** Map Claude Code tool names to awareness-friendly names + target + detail. */
 function mapToolCall(toolName, toolInput) {
@@ -12813,7 +12813,7 @@ function mapToolCall(toolName, toolInput) {
 			target: truncate(toolInput.command ?? toolInput.description, 60),
 			detail: {
 				kind: "command",
-				text: cap(toolInput.command)
+				text: cap$1(toolInput.command)
 			}
 		};
 		case "Read": return {
@@ -12837,8 +12837,8 @@ function mapToolCall(toolName, toolInput) {
 				detail: {
 					kind: "diff",
 					file: toolInput.file_path,
-					old: cap(oldText),
-					new: cap(newText)
+					old: cap$1(oldText),
+					new: cap$1(newText)
 				}
 			};
 		}
@@ -12848,7 +12848,7 @@ function mapToolCall(toolName, toolInput) {
 			detail: {
 				kind: "code",
 				file: toolInput.file_path,
-				text: cap(toolInput.content)
+				text: cap$1(toolInput.content)
 			}
 		};
 		case "Grep": return {
@@ -12872,7 +12872,7 @@ function mapToolCall(toolName, toolInput) {
 			target: toolInput.description || toolInput.subagent_type || "agent",
 			detail: {
 				kind: "text",
-				text: cap(toolInput.prompt)
+				text: cap$1(toolInput.prompt)
 			}
 		};
 		case "WebFetch": return {
@@ -21419,8 +21419,16 @@ function stripMention(text, aliases) {
 //#region packages/mcp/src/utils.ts
 /**
 * Wait for a provider's `synced` event with a timeout.
+*
+* Mirrors `@abraca/dabra`'s `DocUtils.waitForSync`: the `isSynced` short-circuit
+* is load-bearing. `synced` is emitted once per sync transition (and deferred a
+* microtask), so a provider that has ALREADY synced — e.g. the cached child
+* provider that `loadChild` returns on a repeat read/write of the same doc —
+* will never re-emit. Without this guard those callers block for the full
+* `timeoutMs` ("works once, then every later op on that doc times out at 15s").
 */
 function waitForSync(provider, timeoutMs = 15e3) {
+	if (provider.isSynced) return Promise.resolve();
 	return new Promise((resolve, reject) => {
 		const timer = setTimeout(() => {
 			provider.off("synced", handler);
@@ -21428,6 +21436,7 @@ function waitForSync(provider, timeoutMs = 15e3) {
 		}, timeoutMs);
 		function handler() {
 			clearTimeout(timer);
+			provider.off("synced", handler);
 			resolve();
 		}
 		provider.on("synced", handler);
@@ -21608,6 +21617,46 @@ var AbracadabraMCPServer = class AbracadabraMCPServer {
 		await this._connectToSpace(docId);
 		console.error(`[abracadabra-mcp] Switched active space to ${docId}`);
 	}
+	/**
+	* Make the space that OWNS `targetId` the active connection before a tree
+	* read/write, so the op targets the right space's `doc-tree` map.
+	*
+	* Without this, every tree tool used `getTreeMap()` (the single active
+	* space) and treated `rootId`/`parentId` as a mere filter — so reading a
+	* non-active space returned stale/empty trees, and *writing* to one
+	* silently orphaned the entry into the active space's map (a real
+	* data-loss path: docs built "in Ideas" while Development was active
+	* landed in Development under a non-node parent and never reached Ideas).
+	*
+	* Resolution order:
+	*  - falsy or already the active root → no-op.
+	*  - a known Space id → connect/activate it (cheap; `_spaceConnections`
+	*    caches the provider so re-activation is free).
+	*  - present in the active space's tree → no-op (a normal child doc).
+	*  - present in an already-connected *other* space's tree → activate that.
+	*  - otherwise unresolved → returns `false`; callers decide (reads report
+	*    not-found/empty, writes refuse rather than orphan).
+	*
+	* Switching uses {@link _connectToSpace} (not {@link switchSpace}) so the
+	* child-content provider cache survives — content docs are keyed by global
+	* guid, independent of which space is active.
+	*/
+	async ensureSpaceActive(targetId) {
+		if (!targetId || targetId === this._rootDocId) return true;
+		if (this._spaces.some((s) => s.id === targetId)) {
+			await this._connectToSpace(targetId);
+			return true;
+		}
+		if (this.getTreeMap()?.has(targetId)) return true;
+		for (const [spaceId, conn] of this._spaceConnections) {
+			if (spaceId === this._rootDocId) continue;
+			if (conn.doc.getMap("doc-tree").has(targetId)) {
+				await this._connectToSpace(spaceId);
+				return true;
+			}
+		}
+		return false;
+	}
 	/** Get the root doc-tree Y.Map of the active space. */
 	getTreeMap() {
 		return this._activeConnection?.doc.getMap("doc-tree") ?? null;
@@ -22145,6 +22194,28 @@ var AbracadabraMCPServer = class AbracadabraMCPServer {
 		}
 	}
 	/**
+	* Attach expandable `detail` (arguments + result summary) to the most recent
+	* tool-history entry for `toolName`, then re-broadcast `toolHistory`.
+	*
+	* Called by the central tool wrapper in index.ts *after* a tool resolves, so
+	* the dashboard's tool cards can expand to show what the tool was called with
+	* and what it returned — the same affordance built-in Claude tools (bash /
+	* read / edit) already get via the hook-bridge. Tools that never emitted a
+	* pill (no `setActiveToolCall`) have no entry to attach to, so this no-ops.
+	*/
+	recordToolDetail(toolName, detail) {
+		const provider = this._activeConnection?.provider;
+		if (!provider) return;
+		for (let i = this._toolHistory.length - 1; i >= 0; i--) {
+			const h = this._toolHistory[i];
+			if (h.tool === toolName && h.detail == null) {
+				h.detail = detail;
+				provider.awareness.setLocalStateField("toolHistory", [...this._toolHistory]);
+				return;
+			}
+		}
+	}
+	/**
 	* Send a typing indicator to a chat channel. Pass the channel doc id
 	* (or for legacy callers, a `group:<docId>` string — we strip the prefix).
 	*/
@@ -22192,6 +22263,123 @@ var AbracadabraMCPServer = class AbracadabraMCPServer {
 	}
 };
 
+//#endregion
+//#region packages/mcp/src/tool-detail.ts
+/**
+* tool-detail — central enrichment of abracadabra MCP tool cards.
+*
+* Built-in Claude tools (Bash/Read/Edit/…) flow through the hook-bridge, which
+* attaches an expandable `detail` (command text, file path, diff) that the
+* cou-sh chat renders as a click-to-expand block. abracadabra's own MCP tools
+* are explicitly skipped by the hook-bridge and only ever emitted a bare
+* name+target pill — so their cards had nothing to expand ("no idea what docs
+* it sees or what the tree was").
+*
+* `wrapToolsWithDetail` patches `McpServer.tool` ONCE, before any tool is
+* registered, so every tool invocation records an expandable detail onto its
+* tool-history entry (via `server.recordToolDetail`). The detail leads with the
+* human-readable title + id of any document the call referenced (resolved from
+* the live tree), then the remaining arguments, then the text the tool returned
+* (e.g. the full document tree for `get_document_tree`). The pill itself is
+* still emitted by each tool's own `setActiveToolCall`; this only fills in the
+* expandable detail afterwards.
+*/
+/** Per-field cap (chars) — keeps the awareness payload bounded. Mirrors the
+*  hook-bridge's DETAIL_MAX so built-in and MCP tool cards behave alike. */
+const DETAIL_MAX = 4e3;
+/** Argument keys that hold a document id, in the order we surface them. */
+const DOC_ID_KEYS = [
+	"docId",
+	"id",
+	"rootId",
+	"parentId",
+	"newParentId",
+	"uploadId"
+];
+function cap(s) {
+	return s.length > DETAIL_MAX ? `${s.slice(0, DETAIL_MAX)}\n… (truncated)` : s;
+}
+function safeJson(value) {
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+/** Pull the joined text content out of a tool result, if any. */
+function resultText(result) {
+	const content = result?.content;
+	if (!Array.isArray(content)) return "";
+	return content.filter((c) => c && c.type === "text").map((c) => c.text ?? "").join("\n").trim();
+}
+/**
+* Build the expandable detail shown when a tool card is clicked:
+*   1. one `id — "Title"` line per document the args referenced (title resolved
+*      from the live tree when available),
+*   2. the remaining arguments as compact JSON,
+*   3. the text the tool returned (document tree, content, confirmation, …).
+* Rendered by cou-sh's ChatActionCard as a `kind: "text"` block.
+*/
+function buildToolDetail(toolArgs, result, resolveLabel) {
+	const lines = [];
+	const rest = toolArgs && typeof toolArgs === "object" ? { ...toolArgs } : {};
+	for (const key of DOC_ID_KEYS) {
+		const v = rest[key];
+		if (typeof v === "string" && v.length > 0) {
+			const label = resolveLabel?.(v);
+			lines.push(label ? `${key}: ${v} — "${label}"` : `${key}: ${v}`);
+			delete rest[key];
+		}
+	}
+	const restStr = Object.keys(rest).length > 0 ? safeJson(rest) : "";
+	if (restStr && restStr !== "{}") lines.push(`args: ${restStr}`);
+	if (lines.length === 0) lines.push("args: (no arguments)");
+	const text = resultText(result);
+	if (text) {
+		lines.push("");
+		lines.push(text);
+	}
+	return {
+		kind: "text",
+		text: cap(lines.join("\n"))
+	};
+}
+/**
+* Monkey-patch `mcp.tool` so each registered tool's handler is wrapped to record
+* arguments + result detail after it resolves. Call once at startup, before the
+* register* functions run. Errors in detail-recording are swallowed — they must
+* never break the underlying tool.
+*/
+function wrapToolsWithDetail(mcp, server) {
+	const resolveLabel = (id) => {
+		try {
+			const raw = server.getTreeMap()?.get(id);
+			if (!raw) return void 0;
+			const label = toPlain(raw)?.label;
+			return typeof label === "string" && label.length > 0 ? label : void 0;
+		} catch {
+			return;
+		}
+	};
+	const original = mcp.tool.bind(mcp);
+	mcp.tool = (...args) => {
+		const name = args[0];
+		const cbIndex = args.length - 1;
+		const cb = args[cbIndex];
+		if (typeof name === "string" && typeof cb === "function") {
+			const handler = cb;
+			args[cbIndex] = async (...handlerArgs) => {
+				const result = await handler(...handlerArgs);
+				try {
+					server.recordToolDetail(name, buildToolDetail(handlerArgs[0], result, resolveLabel));
+				} catch {}
+				return result;
+			};
+		}
+		return original(...args);
+	};
+}
+
 //#endregion
 //#region packages/mcp/src/tools/awareness.ts
 function registerAwarenessTools(mcp, server) {
@@ -22424,6 +22612,7 @@ function registerContentTools(mcp, server) {
 				name: "read_document",
 				target: docId
 			});
+			await server.ensureSpaceActive(docId);
 			const fragment = (await server.getChildProvider(docId)).document.getXmlFragment("default");
 			server.setFocusedDoc(docId);
 			server.setDocCursor(docId, 0);
@@ -22487,6 +22676,7 @@ function registerContentTools(mcp, server) {
 				name: "write_document",
 				target: docId
 			});
+			await server.ensureSpaceActive(docId);
 			const writeMode = mode ?? "replace";
 			const doc = (await server.getChildProvider(docId)).document;
 			const fragment = doc.getXmlFragment("default");
@@ -22513,7 +22703,9 @@ function registerContentTools(mcp, server) {
 			if (writeMode === "replace") doc.transact(() => {
 				while (fragment.length > 0) fragment.delete(0);
 			});
-			populateYDocFromMarkdown(fragment, body || markdown, title || "Untitled");
+			const contentToWrite = body || markdown;
+			const existingLabel = server.getDocSummary(docId)?.label;
+			populateYDocFromMarkdown(fragment, contentToWrite, title || existingLabel || "Untitled");
 			server.setFocusedDoc(docId);
 			server.setDocCursor(docId, fragment.length);
 			return { content: [{
@@ -22694,6 +22886,7 @@ function registerMetaTools(mcp, server, validator = null) {
 			name: "get_metadata",
 			target: docId
 		});
+		await server.ensureSpaceActive(docId);
 		const treeMap = server.getTreeMap();
 		if (!treeMap) return { content: [{
 			type: "text",
@@ -22723,6 +22916,7 @@ function registerMetaTools(mcp, server, validator = null) {
 			name: "update_metadata",
 			target: docId
 		});
+		await server.ensureSpaceActive(docId);
 		const treeMap = server.getTreeMap();
 		if (!treeMap) return { content: [{
 			type: "text",
@@ -23679,9 +23873,22 @@ function normalizeRootId(id, server) {
 function toPlain$1(val) {
 	return val instanceof Y.Map ? val.toJSON() : val;
 }
-function readEntries(treeMap) {
+/**
+* Read every doc-tree entry, optionally skipping the space's self-descriptor.
+*
+* A space's own `doc-tree` Y.Map holds an entry keyed by the space's OWN id
+* (the connected root doc), with `parentId: null` and `order: -1`. It stores
+* the space root's own icon/color/type/label — it is NOT a child document.
+* Because its `parentId` is null it otherwise shows up alongside real
+* top-level docs, making the space render as a phantom first child of itself
+* ("Health space's first document is 'Development'"). Pass `selfId =
+* server.rootDocId` to drop it. cou-sh's DocumentTree applies the same guard
+* (`if (id === spaceDocId) continue`).
+*/
+function readEntries(treeMap, selfId) {
 	const entries = [];
 	treeMap.forEach((raw, id) => {
+		if (selfId && id === selfId) return;
 		const value = toPlain$1(raw);
 		if (typeof value !== "object" || value === null) return;
 		entries.push({
@@ -23733,13 +23940,14 @@ function registerTreeTools(mcp, server, validator = null) {
 	mcp.tool("list_documents", "List direct children of a document (defaults to root). Returns id, label, type, meta, order. NOTE: Only returns ONE level. Use find_document to search by name across the full tree, or get_document_tree to see the complete hierarchy.", { parentId: z.string().optional().describe("Parent document ID. Omit for root-level documents.") }, async ({ parentId }) => {
 		server.setAutoStatus("reading");
 		server.setActiveToolCall({ name: "list_documents" });
+		await server.ensureSpaceActive(parentId);
 		const treeMap = server.getTreeMap();
 		if (!treeMap) return { content: [{
 			type: "text",
 			text: "Not connected"
 		}] };
 		const targetId = normalizeRootId(parentId, server);
-		const children = childrenOf(readEntries(treeMap), targetId);
+		const children = childrenOf(readEntries(treeMap, server.rootDocId), targetId);
 		return { content: [{
 			type: "text",
 			text: JSON.stringify(children, null, 2)
@@ -23751,6 +23959,7 @@ function registerTreeTools(mcp, server, validator = null) {
 	}, async ({ rootId, depth }) => {
 		server.setAutoStatus("reading");
 		server.setActiveToolCall({ name: "get_document_tree" });
+		await server.ensureSpaceActive(rootId);
 		const treeMap = server.getTreeMap();
 		if (!treeMap) return { content: [{
 			type: "text",
@@ -23758,7 +23967,7 @@ function registerTreeTools(mcp, server, validator = null) {
 		}] };
 		const targetId = normalizeRootId(rootId, server);
 		const maxDepth = depth ?? 3;
-		const tree = buildTree(readEntries(treeMap), targetId, maxDepth);
+		const tree = buildTree(readEntries(treeMap, server.rootDocId), targetId, maxDepth);
 		return { content: [{
 			type: "text",
 			text: JSON.stringify(tree, null, 2)
@@ -23773,12 +23982,13 @@ function registerTreeTools(mcp, server, validator = null) {
 			name: "find_document",
 			target: query
 		});
+		await server.ensureSpaceActive(rootId);
 		const treeMap = server.getTreeMap();
 		if (!treeMap) return { content: [{
 			type: "text",
 			text: "Not connected"
 		}] };
-		const entries = readEntries(treeMap);
+		const entries = readEntries(treeMap, server.rootDocId);
 		const lowerQuery = query.toLowerCase();
 		const normalizedRoot = normalizeRootId(rootId, server);
 		const matches = (normalizedRoot ? descendantsOf(entries, normalizedRoot) : entries).filter((e) => e.label.toLowerCase().includes(lowerQuery));
@@ -23859,6 +24069,7 @@ function registerTreeTools(mcp, server, validator = null) {
 			name: "create_document",
 			target: label
 		});
+		await server.ensureSpaceActive(parentId);
 		const treeMap = server.getTreeMap();
 		const rootDoc = server.rootDocument;
 		if (!treeMap || !rootDoc) return { content: [{
@@ -23878,6 +24089,30 @@ function registerTreeTools(mcp, server, validator = null) {
 		const id = crypto.randomUUID();
 		const normalizedParent = normalizeRootId(parentId, server);
 		const now = Date.now();
+		if (normalizedParent && !treeMap.has(normalizedParent)) return {
+			content: [{
+				type: "text",
+				text: `Parent "${parentId}" was not found in any space the MCP can currently reach (active space: ${server.rootDocId}). Refusing to create — writing here would orphan the document. If the parent lives in another space, call switch_space to that space first, then retry.`
+			}],
+			isError: true
+		};
+		const restParent = normalizedParent ?? server.rootDocId;
+		if (restParent) try {
+			await server.client.createChild(restParent, {
+				child_id: id,
+				label,
+				doc_type: type,
+				kind: "page"
+			});
+		} catch (e) {
+			return {
+				content: [{
+					type: "text",
+					text: `Failed to register document ${id} under ${restParent}: ${e instanceof Error ? e.message : String(e)}`
+				}],
+				isError: true
+			};
+		}
 		rootDoc.transact(() => {
 			treeMap.set(id, makeEntryMap({
 				label,
@@ -23909,6 +24144,7 @@ function registerTreeTools(mcp, server, validator = null) {
 			name: "rename_document",
 			target: id
 		});
+		await server.ensureSpaceActive(id);
 		const treeMap = server.getTreeMap();
 		if (!treeMap) return { content: [{
 			type: "text",
@@ -23922,9 +24158,15 @@ function registerTreeTools(mcp, server, validator = null) {
 			label,
 			updatedAt: Date.now()
 		});
+		let restNote = "";
+		try {
+			await server.client.updateDocumentMeta(id, { label });
+		} catch (e) {
+			restNote = ` (registry update failed: ${e instanceof Error ? e.message : String(e)})`;
+		}
 		return { content: [{
 			type: "text",
-			text: `Renamed to "${label}"`
+			text: `Renamed to "${label}"${restNote}`
 		}] };
 	});
 	mcp.tool("move_document", "Move a document to a new parent and/or reorder it.", {
@@ -23937,6 +24179,7 @@ function registerTreeTools(mcp, server, validator = null) {
 			name: "move_document",
 			target: id
 		});
+		await server.ensureSpaceActive(id);
 		const treeMap = server.getTreeMap();
 		if (!treeMap) return { content: [{
 			type: "text",
@@ -23946,14 +24189,29 @@ function registerTreeTools(mcp, server, validator = null) {
 			type: "text",
 			text: `Document ${id} not found`
 		}] };
+		const normalizedParent = normalizeRootId(newParentId, server);
+		if (normalizedParent && !treeMap.has(normalizedParent)) return {
+			content: [{
+				type: "text",
+				text: `New parent "${newParentId}" is not in the same space as "${id}" (active space: ${server.rootDocId}). Cross-space moves aren't supported — refusing to avoid orphaning the document.`
+			}],
+			isError: true
+		};
 		patchEntry(treeMap, id, {
-			parentId: normalizeRootId(newParentId, server),
+			parentId: normalizedParent,
 			order: order ?? Date.now(),
 			updatedAt: Date.now()
 		});
+		const restParent = normalizedParent ?? server.rootDocId;
+		let restNote = "";
+		if (restParent) try {
+			await server.client.updateDocumentMeta(id, { parent_id: restParent });
+		} catch (e) {
+			restNote = ` (registry reparent failed: ${e instanceof Error ? e.message : String(e)})`;
+		}
 		return { content: [{
 			type: "text",
-			text: `Moved ${id} to parent ${newParentId}`
+			text: `Moved ${id} to parent ${newParentId}${restNote}`
 		}] };
 	});
 	mcp.tool("delete_document", "Soft-delete a document and its descendants (moves to trash).", { id: z.string().describe("Document ID to delete.") }, async ({ id }) => {
@@ -23962,6 +24220,7 @@ function registerTreeTools(mcp, server, validator = null) {
 			name: "delete_document",
 			target: id
 		});
+		await server.ensureSpaceActive(id);
 		const treeMap = server.getTreeMap();
 		const trashMap = server.getTrashMap();
 		const rootDoc = server.rootDocument;
@@ -23969,7 +24228,7 @@ function registerTreeTools(mcp, server, validator = null) {
 			type: "text",
 			text: "Not connected"
 		}] };
-		const toDelete = [id, ...descendantsOf(readEntries(treeMap), id).map((e) => e.id)];
+		const toDelete = [id, ...descendantsOf(readEntries(treeMap, server.rootDocId), id).map((e) => e.id)];
 		const now = Date.now();
 		rootDoc.transact(() => {
 			for (const nid of toDelete) {
@@ -23987,9 +24246,15 @@ function registerTreeTools(mcp, server, validator = null) {
 				treeMap.delete(nid);
 			}
 		});
+		let restNote = "";
+		try {
+			await server.client.deleteDoc(id);
+		} catch (e) {
+			restNote = ` (registry delete failed: ${e instanceof Error ? e.message : String(e)})`;
+		}
 		return { content: [{
 			type: "text",
-			text: `Deleted ${toDelete.length} document(s)`
+			text: `Deleted ${toDelete.length} document(s)${restNote}`
 		}] };
 	});
 	mcp.tool("change_document_type", "Change the page type view of a document (data is preserved).", {
@@ -24001,6 +24266,7 @@ function registerTreeTools(mcp, server, validator = null) {
 			name: "change_document_type",
 			target: id
 		});
+		await server.ensureSpaceActive(id);
 		const treeMap = server.getTreeMap();
 		if (!treeMap) return { content: [{
 			type: "text",
@@ -24020,6 +24286,7 @@ function registerTreeTools(mcp, server, validator = null) {
 		}] };
 	});
 	mcp.tool("list_spaces", "List all Spaces available on the server. Spaces are top-level documents (direct children of the server root) tagged with kind=\"space\". Returns id, label, public_access, and active flag. Use switch_space to navigate.", {}, async () => {
+		server.setActiveToolCall({ name: "list_spaces" });
 		const spaces = server.spaces;
 		if (!spaces.length) return { content: [{
 			type: "text",
@@ -24036,6 +24303,10 @@ function registerTreeTools(mcp, server, validator = null) {
 		}] };
 	});
 	mcp.tool("switch_space", "Switch the active Space. All subsequent tree operations will target the new Space. Use list_spaces to discover available ids.", { docId: z.string().describe("The id of the Space to switch to (from list_spaces).") }, async ({ docId }) => {
+		server.setActiveToolCall({
+			name: "switch_space",
+			target: docId
+		});
 		await server.switchSpace(docId);
 		return { content: [{
 			type: "text",
@@ -24043,6 +24314,11 @@ function registerTreeTools(mcp, server, validator = null) {
 		}] };
 	});
 	mcp.tool("duplicate_document", "Shallow-clone a document with \" (copy)\" suffix. Returns new document ID.", { id: z.string().describe("Document ID to duplicate.") }, async ({ id }) => {
+		server.setActiveToolCall({
+			name: "duplicate_document",
+			target: id
+		});
+		await server.ensureSpaceActive(id);
 		const treeMap = server.getTreeMap();
 		if (!treeMap) return { content: [{
 			type: "text",
@@ -24070,6 +24346,10 @@ function registerTreeTools(mcp, server, validator = null) {
 		}] };
 	});
 	mcp.tool("list_page_types", "Enumerate all known Abracadabra page types with their metadata schemas. Returns an array of { key, label, icon, description, core, plugin, supportsChildren, childLabel, grandchildLabel, defaultDepth, metaSchema, defaultMetaFields }. `metaSchema` describes fields that apply to DESCENDANTS (children, grandchildren, ...) of a page of this type. `defaultMetaFields` are view-config fields on the page doc itself. Plugin types (core: false) require the named plugin to be enabled on the server. Use this to discover what meta keys a given renderer supports instead of guessing.", { key: z.string().optional().describe("Filter to a single type by key (e.g. \"kanban\", \"calendar\"). Aliases are resolved (e.g. \"desktop\" → \"dashboard\"). Omit to list all types.") }, async ({ key }) => {
+		server.setActiveToolCall({
+			name: "list_page_types",
+			target: key
+		});
 		if (key) {
 			const resolved = resolvePageType(key);
 			if (!resolved) return { content: [{
@@ -24197,6 +24477,7 @@ The user CANNOT see your plain text output — they only see messages sent via M
 ## Full Reference
 Read the resource at abracadabra://agent-guide for the complete guide covering page type schemas, metadata reference, awareness/presence, content structure, and detailed examples.`
 	});
+	wrapToolsWithDetail(mcp, server);
 	registerTreeTools(mcp, server, schemaValidator);
 	registerContentTools(mcp, server);
 	registerMetaTools(mcp, server, schemaValidator);