@abraca/mcp 2.3.0 → 2.5.0

package/dist/index.d.ts

@@ -42,6 +42,17 @@ declare class AbracadabraMCPServer {
   /** Rolling buffer of the last N tool calls in the current turn, surfaced via awareness. */
   private _toolHistory;
   private static readonly TOOL_HISTORY_MAX;
+  private _inboxStarted;
+  private _inboxDocId;
+  private _inboxDoc;
+  private _inboxProvider;
+  private _inboxDisposers;
+  private _inboxInitialized;
+  private _seenInboxIds;
+  /** Shared message-id dedupe so the inbox path and `_handleStatelessChat`
+   *  (subscribed-doc broadcast) never dispatch the same message twice. */
+  private _dispatchedMessageIds;
+  private static readonly DEDUPE_MAX;
   constructor(config: MCPServerConfig);
   get agentName(): string;
   get agentColor(): string;
@@ -89,6 +100,36 @@ declare class AbracadabraMCPServer {
   private evictIdle;
   /** Wire up real-time channel notifications via awareness observation and stateless chat. */
   startChannelNotifications(mcpServer: McpServer): void;
+  /**
+   * Bootstrap inbox observation. Sends `messages:inbox_fetch` over the active
+   * provider; the server's `messages:inbox_history` reply carries the
+   * `inbox_doc_id`. We then open a dedicated provider on that doc and observe
+   * its `entries` Y.Array for live DM/mention dispatch. Mirrors the
+   * dashboard's `useNotifications` pattern.
+   */
+  private _startInboxNotifications;
+  /**
+   * Open a dedicated provider on the agent's inbox doc and observe its
+   * `entries` Y.Array. The server is the only writer; we only read.
+   */
+  private _ensureInboxObserver;
+  /**
+   * Diff the inbox `entries` array against what we've already seen. On the
+   * first pump we only record a baseline (don't replay history). New entries
+   * are classified by their authoritative `kind` and dispatched.
+   */
+  private _pumpInbox;
+  /** Classify + dispatch one inbox entry as a channel notification. */
+  private _dispatchInboxEntry;
+  /**
+   * Resolve full message content. The inbox `preview` is truncated to ≤200
+   * bytes (and null for E2E), so for fidelity we read the actual record from
+   * the channel/DM doc's active period — same shape the dashboard reads.
+   * Falls back to the preview, then a short notice.
+   */
+  private _resolveInboxContent;
+  private _rememberDispatched;
+  private _trimSet;
   /** Attach awareness observer to detect `ai:task` fields from human users. */
   private _observeRootAwareness;
   /** Dispatch an ai:task as a channel notification. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abraca/mcp",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "MCP server for Abracadabra — AI agent collaboration on CRDT documents",
   "license": "MIT",
   "type": "module",
@@ -36,7 +36,7 @@
     "y-protocols": "^1.0.6",
     "yjs": "^13.6.8",
     "zod": "^4.3.6",
-    "@abraca/convert": "2.3.0"
+    "@abraca/convert": "2.5.0"
   },
   "scripts": {
     "test": "node --no-warnings --conditions=source --experimental-transform-types --test 'tests/*.test.ts'"

package/src/resources/tree-resource.ts

@@ -1,13 +1,18 @@
 /**
  * Dynamic resource: document tree as navigable JSON.
  */
+import { toPlain } from '@abraca/dabra'
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import type { AbracadabraMCPServer } from '../server.ts'
 import type { TreeEntry } from '../converters/types.ts'
 
 function readEntries(treeMap: any): TreeEntry[] {
   const entries: TreeEntry[] = []
-  treeMap.forEach((value: any, id: string) => {
+  treeMap.forEach((raw: any, id: string) => {
+    // Entries are nested Y.Map values — raw field access returns undefined;
+    // resolve via toPlain first (mirrors tree.ts:readEntries).
+    const value = toPlain(raw) as any
+    if (typeof value !== 'object' || value === null) return // skip non-entry keys (e.g. ":updatedAt")
     entries.push({
       id,
       label: value.label || 'Untitled',

package/src/server.ts

@@ -6,7 +6,15 @@
  * one; use switchSpace(docId) to change.
  */
 import * as Y from 'yjs'
-import { AbracadabraProvider, AbracadabraClient, Kind, SERVER_ROOT_ID } from '@abraca/dabra'
+import {
+  AbracadabraProvider,
+  AbracadabraClient,
+  Kind,
+  SERVER_ROOT_ID,
+  foldRecords,
+  recordFromYAny,
+  isEncryptedContent,
+} from '@abraca/dabra'
 import type { ServerInfo, DocumentMeta } from '@abraca/dabra'
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import type { Server } from '@modelcontextprotocol/sdk/server/index.js'
@@ -69,6 +77,25 @@ export class AbracadabraMCPServer {
   private _toolHistory: Array<{ tool: string; target?: string; ts: number; channel: string | null }> = []
   private static readonly TOOL_HISTORY_MAX = 20
 
+  // ── Inbox-driven dispatch ──────────────────────────────────────────────────
+  // The server fans DMs + @mentions out as entries on this agent's per-user
+  // `kind="inbox"` doc (server is the only writer). That is the *only*
+  // recipient-correct signal for a DM the agent isn't subscribed to — the
+  // `messages:new_message` stateless broadcast only reaches subscribers of the
+  // channel/DM doc, and the agent never subscribes to DM docs. So we observe
+  // the inbox's `entries` Y.Array and dispatch from there.
+  private _inboxStarted = false
+  private _inboxDocId: string | null = null
+  private _inboxDoc: Y.Doc | null = null
+  private _inboxProvider: AbracadabraProvider | null = null
+  private _inboxDisposers: Array<() => void> = []
+  private _inboxInitialized = false
+  private _seenInboxIds = new Set<string>()
+  /** Shared message-id dedupe so the inbox path and `_handleStatelessChat`
+   *  (subscribed-doc broadcast) never dispatch the same message twice. */
+  private _dispatchedMessageIds = new Set<string>()
+  private static readonly DEDUPE_MAX = 1000
+
   constructor(config: MCPServerConfig) {
     this.config = config
     this.client = new AbracadabraClient({
@@ -374,6 +401,232 @@ export class AbracadabraMCPServer {
         this._handleStatelessChat(payload)
       })
       console.error('[abracadabra-mcp] Stateless chat listener attached')
+      void this._startInboxNotifications()
+    }
+  }
+
+  /**
+   * Bootstrap inbox observation. Sends `messages:inbox_fetch` over the active
+   * provider; the server's `messages:inbox_history` reply carries the
+   * `inbox_doc_id`. We then open a dedicated provider on that doc and observe
+   * its `entries` Y.Array for live DM/mention dispatch. Mirrors the
+   * dashboard's `useNotifications` pattern.
+   */
+  private async _startInboxNotifications(): Promise<void> {
+    if (this._inboxStarted) return
+    const provider = this._activeConnection?.provider
+    if (!provider) return
+    this._inboxStarted = true
+
+    provider.on('stateless', ({ payload }: { payload: string }) => {
+      if (!payload.includes('"messages:inbox_history"')) return
+      try {
+        const data = JSON.parse(payload)
+        if (data?.type !== 'messages:inbox_history') return
+        const inboxDocId = typeof data.inbox_doc_id === 'string' ? data.inbox_doc_id : null
+        if (inboxDocId) void this._ensureInboxObserver(inboxDocId)
+      } catch {
+        /* ignore malformed */
+      }
+    })
+
+    // Elicit the inbox_history (and thus inbox_doc_id). unread_only:false so a
+    // fresh agent learns its inbox doc even with no unread entries.
+    provider.sendStateless(JSON.stringify({
+      type: 'messages:inbox_fetch',
+      limit: 50,
+      unread_only: false,
+    }))
+    console.error('[abracadabra-mcp] Inbox bootstrap sent (messages:inbox_fetch)')
+  }
+
+  /**
+   * Open a dedicated provider on the agent's inbox doc and observe its
+   * `entries` Y.Array. The server is the only writer; we only read.
+   */
+  private async _ensureInboxObserver(inboxDocId: string): Promise<void> {
+    if (this._inboxDocId) return // already observing
+    this._inboxDocId = inboxDocId
+
+    // Re-authenticate if the JWT expired (mirrors _connectToSpace).
+    if (!this.client.isTokenValid() && this._signFn && this._userId) {
+      await this.client.loginWithKey(this._userId, this._signFn)
+    }
+
+    const doc = new Y.Doc({ guid: inboxDocId })
+    const provider = new AbracadabraProvider({
+      name: inboxDocId,
+      document: doc,
+      client: this.client,
+      disableOfflineStore: true,
+      subdocLoading: 'lazy',
+    })
+    this._inboxDoc = doc
+    this._inboxProvider = provider
+
+    try {
+      await waitForSync(provider)
+    } catch (err: any) {
+      console.error(`[abracadabra-mcp] Inbox sync failed: ${err?.message ?? err}`)
+      return
+    }
+
+    const entriesArr = doc.getArray('entries')
+    const readMap = doc.getMap('read')
+    const onChange = () => { void this._pumpInbox(entriesArr, readMap) }
+    entriesArr.observe(onChange)
+    readMap.observe(onChange)
+    this._inboxDisposers.push(() => entriesArr.unobserve(onChange))
+    this._inboxDisposers.push(() => readMap.unobserve(onChange))
+
+    await this._pumpInbox(entriesArr, readMap)
+    console.error(`[abracadabra-mcp] Inbox observer attached (${inboxDocId})`)
+  }
+
+  /**
+   * Diff the inbox `entries` array against what we've already seen. On the
+   * first pump we only record a baseline (don't replay history). New entries
+   * are classified by their authoritative `kind` and dispatched.
+   */
+  private async _pumpInbox(entriesArr: Y.Array<any>, readMap: Y.Map<any>): Promise<void> {
+    const raw = entriesArr.toArray() as any[]
+    const entries = raw.map((e) => (typeof e?.toJSON === 'function' ? e.toJSON() : e))
+
+    if (!this._inboxInitialized) {
+      for (const e of entries) if (e?.id) this._seenInboxIds.add(e.id)
+      this._inboxInitialized = true
+      console.error(`[abracadabra-mcp] Inbox baseline: ${this._seenInboxIds.size} existing entries (not replayed)`)
+      return
+    }
+
+    for (const e of entries) {
+      const id: string | undefined = e?.id
+      if (!id || this._seenInboxIds.has(id)) continue
+      this._seenInboxIds.add(id)
+      if (readMap.get(id)) continue // already read elsewhere
+      try {
+        await this._dispatchInboxEntry(e)
+      } catch (err: any) {
+        console.error(`[abracadabra-mcp] Inbox dispatch failed for ${id}: ${err?.message ?? err}`)
+      }
+    }
+    this._trimSet(this._seenInboxIds)
+  }
+
+  /** Classify + dispatch one inbox entry as a channel notification. */
+  private async _dispatchInboxEntry(entry: any): Promise<void> {
+    if (!this._serverRef) return
+    const kind = typeof entry?.kind === 'string' ? entry.kind : ''
+    const channelDocId = typeof entry?.channel_doc_id === 'string' ? entry.channel_doc_id : ''
+    const messageId = typeof entry?.message_id === 'string' ? entry.message_id : null
+    const senderId = typeof entry?.sender_id === 'string' ? entry.sender_id : ''
+    if (!channelDocId) return
+    if (senderId && senderId === this._userId) return // own message (defensive)
+
+    // Authoritative trigger gate — `kind` comes from the server, no guessing.
+    //   dm            → always dispatch (DMs trigger regardless of mode)
+    //   mention/reply → dispatch unless mode === 'task' (chat-ignoring)
+    //   system/other  → skip
+    const mode = this.triggerMode
+    if (kind === 'mention' || kind === 'reply') {
+      if (mode === 'task') return
+    } else if (kind !== 'dm') {
+      return
+    }
+
+    // Cross-path dedupe: a mention on a doc the agent is also subscribed to
+    // arrives via both the inbox and `_handleStatelessChat`. First one wins.
+    if (messageId && this._rememberDispatched(messageId)) return
+
+    const content = await this._resolveInboxContent(channelDocId, messageId, entry?.preview)
+
+    this._lastChatChannel = channelDocId
+    this._beginTurn()
+    this.setAutoStatus('thinking')
+
+    await this._serverRef.notification({
+      method: 'notifications/claude/channel',
+      params: {
+        content,
+        instructions: `You MUST use send_chat_message with channel_doc_id="${channelDocId}" for ALL responses — both progress updates and final answers. The user CANNOT see plain text output; they only see messages sent via send_chat_message. When doing multi-step work, send brief status updates via send_chat_message (e.g. "Looking into that..." or "Found it, writing up results...") so the user knows you're working. Never output plain text as a substitute for send_chat_message.`,
+        meta: {
+          source: 'abracadabra',
+          type: kind === 'dm' ? 'dm_message' : 'chat_message',
+          channel_doc_id: channelDocId,
+          sender: entry?.sender_name ?? 'Unknown',
+          sender_id: senderId,
+          doc_id: channelDocId,
+        },
+      },
+    })
+    console.error(`[abracadabra-mcp] Dispatched ${kind} on ${channelDocId} from ${entry?.sender_name ?? (senderId || 'unknown')}`)
+
+    // Mark the inbox entry read so it doesn't re-pump on reconnect.
+    this._activeConnection?.provider?.sendStateless(JSON.stringify({
+      type: 'messages:inbox_mark_read',
+      id: entry.id,
+    }))
+  }
+
+  /**
+   * Resolve full message content. The inbox `preview` is truncated to ≤200
+   * bytes (and null for E2E), so for fidelity we read the actual record from
+   * the channel/DM doc's active period — same shape the dashboard reads.
+   * Falls back to the preview, then a short notice.
+   */
+  private async _resolveInboxContent(
+    channelDocId: string,
+    messageId: string | null,
+    preview: unknown,
+  ): Promise<string> {
+    const previewStr = typeof preview === 'string' && preview.length > 0 ? preview : null
+    const root = this._activeConnection?.provider
+    if (root && messageId) {
+      try {
+        const wrapper = await root.loadChild(channelDocId)
+        if (!wrapper.synced) await waitForSync(wrapper)
+        const periods = wrapper.document.getArray('periods')
+        const len = periods.length
+        // Scan the last two periods (resilient to a rollover between send + read).
+        for (let i = len - 1; i >= 0 && i >= len - 2; i--) {
+          const p: any = periods.get(i)
+          const periodId: string | undefined = p?.id ?? p?.get?.('id')
+          if (!periodId) continue
+          const period = await root.loadChild(periodId)
+          if (!period.synced) await waitForSync(period)
+          const records = (period.document.getArray('messages').toArray() as unknown[])
+            .map((v) => recordFromYAny(v))
+            .filter((r): r is NonNullable<ReturnType<typeof recordFromYAny>> => r !== null)
+          const folded = foldRecords(records)
+          const hit = folded.find((f) => f.id === messageId)
+          if (hit) {
+            if (isEncryptedContent(hit.content)) {
+              return previewStr ?? '[encrypted message — this agent is not provisioned to read this channel]'
+            }
+            return hit.content
+          }
+        }
+      } catch (err: any) {
+        console.error(`[abracadabra-mcp] content read failed for ${channelDocId}/${messageId}: ${err?.message ?? err}`)
+      }
+    }
+    return previewStr ?? '[message content unavailable]'
+  }
+
+  private _rememberDispatched(messageId: string): boolean {
+    if (this._dispatchedMessageIds.has(messageId)) return true
+    this._dispatchedMessageIds.add(messageId)
+    this._trimSet(this._dispatchedMessageIds)
+    return false
+  }
+
+  private _trimSet(s: Set<string>): void {
+    if (s.size <= AbracadabraMCPServer.DEDUPE_MAX) return
+    const excess = s.size - AbracadabraMCPServer.DEDUPE_MAX
+    let i = 0
+    for (const v of s) {
+      if (i++ >= excess) break
+      s.delete(v)
     }
   }
 
@@ -477,12 +730,17 @@ export class AbracadabraMCPServer {
       const channelDocId = data.channel_doc_id as string | undefined
       if (!channelDocId) return
 
-      // Look up the channel kind (channel vs dm) via the doc tree, since the
-      // new model has no synthetic channel string. Caller-side filtering of
-      // DMs (only dispatch when the agent is a participant) relies on the
-      // permissions on the dm doc — server enforces; nothing to check here.
-      const isDM = false // Without a kind lookup, treat all as group for trigger semantics.
-      const isGroup = !isDM
+      // Cross-path dedupe: DMs + @mentions also arrive via the inbox observer
+      // (the authoritative, recipient-correct path that knows `kind`). If the
+      // inbox already dispatched this message id, don't fire it again here.
+      if (data.id && this._rememberDispatched(data.id)) return
+
+      // This path only ever sees docs the agent is *subscribed* to (the active
+      // space root + lazily-loaded children) — i.e. group/channel/space chat,
+      // never a DM doc (the agent never subscribes to those). DM correctness
+      // lives entirely in the inbox observer, so group trigger semantics are
+      // correct here.
+      const isGroup = true
 
       // ── Trigger mode gate ─────────────────────────────────────────────
       const mode = this.triggerMode
@@ -680,6 +938,14 @@ export class AbracadabraMCPServer {
       this.evictionTimer = null
     }
 
+    for (const dispose of this._inboxDisposers) {
+      try { dispose() } catch { /* ignore */ }
+    }
+    this._inboxDisposers = []
+    this._inboxProvider?.destroy()
+    this._inboxProvider = null
+    this._inboxDoc = null
+
     for (const [, cached] of this.childCache) {
       cached.provider.destroy()
     }

package/src/tools/awareness.ts

@@ -94,7 +94,7 @@ export function registerAwarenessTools(mcp: McpServer, server: AbracadabraMCPSer
         const resolvedInboxId: string = inboxId
         const provider = await server.getChildProvider(resolvedInboxId)
         const fragment = provider.document.getXmlFragment('default')
-        const { markdown } = yjsToMarkdown(fragment)
+        const markdown = yjsToMarkdown(fragment, 'AI Inbox')
 
         // Collect direct children of inbox (pending task sub-docs)
         const pendingTasks: Array<{ id: string; label: string }> = []

package/src/tools/channel.ts

@@ -4,6 +4,7 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { z } from 'zod'
 import type { AbracadabraMCPServer } from '../server.ts'
+import { makeEntryMap } from '@abraca/dabra'
 import { populateYDocFromMarkdown } from '../converters/markdownToYjs.ts'
 
 export function registerChannelTools(mcp: McpServer, server: AbracadabraMCPServer) {
@@ -33,18 +34,19 @@ export function registerChannelTools(mcp: McpServer, server: AbracadabraMCPServe
         const now = Date.now()
 
         rootDoc.transact(() => {
-          treeMap.set(replyId, {
+          treeMap.set(replyId, makeEntryMap({
             label,
             parentId: doc_id,
             order: now,
             type: 'doc',
             createdAt: now,
             updatedAt: now,
-          })
+          }))
         })
 
         const replyProvider = await server.getChildProvider(replyId)
-        populateYDocFromMarkdown(replyProvider.document, text)
+        const fragment = replyProvider.document.getXmlFragment('default')
+        populateYDocFromMarkdown(fragment, text)
 
         if (task_id) {
           server.clearAiTask(task_id)

package/src/tools/content.ts

@@ -7,6 +7,7 @@ import { z } from 'zod'
 import type { AbracadabraMCPServer } from '../server.ts'
 import { populateYDocFromMarkdown, parseFrontmatter } from '../converters/markdownToYjs.ts'
 import { yjsToMarkdown } from '../converters/yjsToMarkdown.ts'
+import { toPlain, patchEntry } from '@abraca/dabra'
 
 export function registerContentTools(mcp: McpServer, server: AbracadabraMCPServer) {
   mcp.tool(
@@ -23,34 +24,43 @@ export function registerContentTools(mcp: McpServer, server: AbracadabraMCPServe
         const provider = await server.getChildProvider(docId)
         const fragment = provider.document.getXmlFragment('default')
 
-        const { title, markdown } = yjsToMarkdown(fragment)
-
         // Auto-update presence: mark this doc as focused and place cursor at start
         server.setFocusedDoc(docId)
         server.setDocCursor(docId, 0)
 
         // Get tree metadata + immediate children
         const treeMap = server.getTreeMap()
-        let label = title
+        let label = 'Untitled'
         let type: string | undefined
         let meta: Record<string, unknown> | undefined
         let children: Array<{ id: string; label: string; type?: string; meta?: unknown }> = []
         if (treeMap) {
-          const entry = treeMap.get(docId)
-          if (entry) {
-            label = entry.label || title
+          // Entries are nested Y.Map values — raw field access returns
+          // undefined; resolve via toPlain first (mirrors tree.ts:readEntries).
+          const entry = toPlain(treeMap.get(docId)) as any
+          if (entry && typeof entry === 'object') {
+            label = entry.label || label
             type = entry.type
             meta = entry.meta
           }
           // Collect immediate children sorted by order
-          treeMap.forEach((value: any, id: string) => {
+          const collected: Array<{ id: string; label: string; type?: string; meta?: unknown; order: number }> = []
+          treeMap.forEach((raw: any, id: string) => {
+            const value = toPlain(raw) as any
+            if (typeof value !== 'object' || value === null) return // skip non-entry keys (e.g. ":updatedAt")
             if (value.parentId === docId) {
-              children.push({ id, label: value.label || 'Untitled', type: value.type, meta: value.meta })
+              collected.push({ id, label: value.label || 'Untitled', type: value.type, meta: value.meta, order: value.order ?? 0 })
             }
           })
-          children.sort((a: any, b: any) => ((treeMap.get(a.id)?.order ?? 0) - (treeMap.get(b.id)?.order ?? 0)))
+          collected.sort((a, b) => a.order - b.order)
+          children = collected.map(({ order, ...rest }) => rest)
         }
 
+        // yjsToMarkdown returns a string and takes the resolved label/meta/type
+        // so frontmatter round-trips. (Older code destructured an object and
+        // passed only the fragment — that silently produced `undefined`.)
+        const markdown = yjsToMarkdown(fragment, label, meta as any, type)
+
         const result: Record<string, unknown> = { label, type, meta, markdown, children }
         return {
           content: [{
@@ -93,15 +103,16 @@ export function registerContentTools(mcp: McpServer, server: AbracadabraMCPServe
           const treeMap = server.getTreeMap()
           const rootDoc = server.rootDocument
           if (treeMap && rootDoc) {
-            const entry = treeMap.get(docId)
-            if (entry) {
+            const rawEntry = treeMap.get(docId)
+            if (rawEntry) {
+              const cur = toPlain(rawEntry) as { meta?: Record<string, unknown> }
               rootDoc.transact(() => {
-                const updates: Record<string, unknown> = { ...entry, updatedAt: Date.now() }
-                if (title) updates.label = title
+                const patch: Record<string, unknown> = { updatedAt: Date.now() }
+                if (title) patch.label = title
                 if (Object.keys(meta).length > 0) {
-                  updates.meta = { ...(entry.meta ?? {}), ...meta }
+                  patch.meta = { ...(cur.meta ?? {}), ...meta }
                 }
-                treeMap.set(docId, updates)
+                patchEntry(treeMap, docId, patch)
               })
             }
           }

package/src/tools/meta.ts

@@ -5,6 +5,7 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { z } from 'zod'
 import type { AbracadabraMCPServer } from '../server.ts'
 import type { SchemaBundleValidator } from '../schema/validator.ts'
+import { toPlain, patchEntry } from '@abraca/dabra'
 
 export function registerMetaTools(
   mcp: McpServer,
@@ -59,10 +60,14 @@ export function registerMetaTools(
         return { content: [{ type: 'text', text: 'Not connected' }] }
       }
 
-      const entry = treeMap.get(docId)
-      if (!entry) {
+      const rawEntry = treeMap.get(docId)
+      if (!rawEntry) {
         return { content: [{ type: 'text', text: `Document ${docId} not found` }] }
       }
+      // Read via toPlain: entries are nested Y.Maps (the Rust provider
+      // already writes them so), so raw `.meta`/`.type` access would be
+      // undefined — skipping validation and dropping existing meta.
+      const entry = toPlain(rawEntry) as { meta?: Record<string, unknown>; type?: string }
 
       const mergedMeta = { ...(entry.meta ?? {}), ...meta }
 
@@ -80,8 +85,7 @@ export function registerMetaTools(
         }
       }
 
-      treeMap.set(docId, {
-        ...entry,
+      patchEntry(treeMap, docId, {
         meta: mergedMeta,
         updatedAt: Date.now(),
       })

package/src/tools/tree.ts

@@ -8,6 +8,7 @@ import type { AbracadabraMCPServer } from '../server.ts'
 import type { TreeEntry, PageMeta } from '../converters/types.ts'
 import { PAGE_TYPES, TYPE_ALIASES, resolvePageType } from '../converters/page-types.ts'
 import type { SchemaBundleValidator } from '../schema/validator.ts'
+import { makeEntryMap, patchEntry } from '@abraca/dabra'
 
 /**
  * Normalize a document ID so the hub/root doc ID is treated as the tree root (null).
@@ -284,15 +285,18 @@ export function registerTreeTools(
       const normalizedParent = normalizeRootId(parentId, server)
       const now = Date.now()
       rootDoc.transact(() => {
-        treeMap.set(id, {
-          label,
-          parentId: normalizedParent,
-          order: now,
-          type,
-          meta: meta as PageMeta,
-          createdAt: now,
-          updatedAt: now,
-        })
+        treeMap.set(
+          id,
+          makeEntryMap({
+            label,
+            parentId: normalizedParent,
+            order: now,
+            type,
+            meta: meta as PageMeta,
+            createdAt: now,
+            updatedAt: now,
+          }),
+        )
       })
 
       server.setFocusedDoc(id)
@@ -326,8 +330,7 @@ export function registerTreeTools(
         return { content: [{ type: 'text', text: `Document ${id} not found` }] }
       }
 
-      const entry = toPlain(raw)
-      treeMap.set(id, { ...entry, label, updatedAt: Date.now() })
+      patchEntry(treeMap, id, { label, updatedAt: Date.now() })
       return { content: [{ type: 'text', text: `Renamed to "${label}"` }] }
     }
   )
@@ -353,9 +356,7 @@ export function registerTreeTools(
         return { content: [{ type: 'text', text: `Document ${id} not found` }] }
       }
 
-      const entry = toPlain(raw)
-      treeMap.set(id, {
-        ...entry,
+      patchEntry(treeMap, id, {
         parentId: normalizeRootId(newParentId, server),
         order: order ?? Date.now(),
         updatedAt: Date.now(),
@@ -425,8 +426,7 @@ export function registerTreeTools(
         return { content: [{ type: 'text', text: `Document ${id} not found` }] }
       }
 
-      const entry = toPlain(raw)
-      treeMap.set(id, { ...entry, type, updatedAt: Date.now() })
+      patchEntry(treeMap, id, { type, updatedAt: Date.now() })
       return { content: [{ type: 'text', text: `Changed type to "${type}"` }] }
     }
   )
@@ -473,11 +473,14 @@ export function registerTreeTools(
 
       const entry = toPlain(raw)
       const newId = crypto.randomUUID()
-      treeMap.set(newId, {
-        ...entry,
-        label: (entry.label || 'Untitled') + ' (copy)',
-        order: Date.now(),
-      })
+      treeMap.set(
+        newId,
+        makeEntryMap({
+          ...entry,
+          label: (entry.label || 'Untitled') + ' (copy)',
+          order: Date.now(),
+        }),
+      )
 
       server.setFocusedDoc(newId)