remnote-mcp-server 0.15.0 → 0.16.0

package/dist/tools/index.js

@@ -4,6 +4,9 @@ import { SearchSchema } from '../schemas/remnote-schemas.js';
 import { SearchByTagSchema } from '../schemas/remnote-schemas.js';
 import { ReadNoteSchema } from '../schemas/remnote-schemas.js';
 import { UpdateNoteSchema } from '../schemas/remnote-schemas.js';
+import { SetDocumentStatusSchema } from '../schemas/remnote-schemas.js';
+import { ListChildrenSchema } from '../schemas/remnote-schemas.js';
+import { MoveNoteSchema } from '../schemas/remnote-schemas.js';
 import { InsertChildrenSchema } from '../schemas/remnote-schemas.js';
 import { ReplaceChildrenSchema } from '../schemas/remnote-schemas.js';
 import { UpdateTagsSchema } from '../schemas/remnote-schemas.js';
@@ -11,10 +14,24 @@ import { AppendJournalSchema } from '../schemas/remnote-schemas.js';
 import { ReadTableSchema } from '../schemas/remnote-schemas.js';
 import { checkVersionCompatibility } from '../version-compat.js';
 const NAVIGATION_PRESET = {
-    includeContent: 'structured',
+    contentMode: 'structured',
+    view: 'compact',
     depth: 1,
     childLimit: 500,
 };
+const ANCESTOR_SCHEMA = {
+    type: 'object',
+    properties: {
+        remId: { type: 'string', description: 'Ancestor Rem ID' },
+        title: { type: 'string', description: 'Rendered ancestor title' },
+        remType: {
+            type: 'string',
+            description: 'Ancestor Rem classification when available',
+        },
+    },
+    required: ['remId', 'title'],
+    additionalProperties: false,
+};
 const TAG_INFO_SCHEMA = {
     type: 'object',
     properties: {
@@ -24,6 +41,57 @@ const TAG_INFO_SCHEMA = {
     required: ['tagRemId', 'name'],
     additionalProperties: false,
 };
+const INLINE_REF_SCHEMA = {
+    type: 'object',
+    properties: {
+        text: { type: 'string', description: 'Rendered target text used in output' },
+        targetRemId: { type: 'string', description: 'Exact target Rem ID' },
+        kind: { type: 'string', enum: ['rem'], description: 'Inline reference kind' },
+    },
+    required: ['text', 'targetRemId', 'kind'],
+    additionalProperties: false,
+};
+const MATCHED_REM_SCHEMA = {
+    type: 'object',
+    properties: {
+        remId: { type: 'string', description: 'Directly tagged Rem ID' },
+        title: { type: 'string', description: 'Rendered title with markdown formatting' },
+        headline: { type: 'string', description: 'Display-oriented full line' },
+        inlineRefs: {
+            type: 'array',
+            items: INLINE_REF_SCHEMA,
+            description: 'Resolvable inline Rem references from the matched Rem title/headline',
+        },
+        remType: {
+            type: 'string',
+            description: 'Rem classification: document, dailyDocument, concept, descriptor, portal, or text',
+        },
+        parentRemId: {
+            type: 'string',
+            description: 'Direct parent Rem ID (omitted for top-level Rems)',
+        },
+        parentTitle: {
+            type: 'string',
+            description: 'Direct parent title/front text (omitted for top-level Rems)',
+        },
+        ancestors: {
+            type: 'array',
+            items: ANCESTOR_SCHEMA,
+            description: 'Parent-first ancestor chain when ancestorDepth is greater than zero',
+        },
+        ancestorsTruncated: {
+            type: 'boolean',
+            description: 'Whether the ancestor chain was capped by ancestorDepth',
+        },
+        tags: {
+            type: 'array',
+            items: TAG_INFO_SCHEMA,
+            description: 'Direct tags applied to the matched Rem as exact tag Rem IDs plus names',
+        },
+    },
+    required: ['remId', 'title', 'headline', 'remType'],
+    additionalProperties: false,
+};
 export const CREATE_NOTE_TOOL = {
     name: 'remnote_create_note',
     description: 'Create a new note in RemNote with optional content, parent, and exact tag Rem IDs. Supports hierarchical markdown in content and flashcard syntax (e.g. "- Term :: Definition"). At least one of title or content must be provided. Recommended preflight once per session: remnote_status.',
@@ -44,6 +112,10 @@ export const CREATE_NOTE_TOOL = {
                 items: { type: 'string' },
                 description: 'Exact tag Rem IDs to apply',
             },
+            asDocument: {
+                type: 'boolean',
+                description: 'Mark the created title/root Rem as a document while preserving any concept/card status',
+            },
         },
         required: [],
         additionalProperties: false,
@@ -67,17 +139,30 @@ export const CREATE_NOTE_TOOL = {
 };
 export const SEARCH_TOOL = {
     name: 'remnote_search',
-    description: 'Search the RemNote knowledge base. For whole-KB orientation, prefer includeContent="structured" with depth=1 and childLimit=500, then follow remIds with remnote_read_note. Use includeContent="markdown" for human-readable summaries.',
+    description: 'Search the RemNote knowledge base. Supports cursor paging through hasMore/nextCursor. For whole-KB orientation, prefer contentMode="structured" with view="compact", depth=1, and childLimit=500. Request ancestorDepth when hierarchy context matters.',
     inputSchema: {
         type: 'object',
         properties: {
             query: { type: 'string', description: 'Search query text' },
             limit: { type: 'number', description: 'Maximum results (1-150, default: 50)' },
-            includeContent: {
+            cursor: {
+                type: 'string',
+                description: 'Opaque cursor returned by a previous remnote_search response',
+            },
+            contentMode: {
                 type: 'string',
                 enum: ['none', 'markdown', 'structured'],
                 description: 'Content rendering mode: "none" omits content (default), "markdown" renders child subtree as indented markdown, "structured" returns nested child objects with remIds',
             },
+            view: {
+                type: 'string',
+                enum: ['compact', 'standard', 'full'],
+                description: 'Output detail level: compact, standard, or full',
+            },
+            ancestorDepth: {
+                type: 'number',
+                description: 'Number of parent Rems to include, direct parent first (0-20, default: 0)',
+            },
             depth: {
                 type: 'number',
                 description: 'Depth of child hierarchy to render for markdown/structured content (0-10, default: 1)',
@@ -108,6 +193,11 @@ export const SEARCH_TOOL = {
                             type: 'string',
                             description: 'Display-oriented full line: title + type-aware delimiter + detail (e.g. "Term :: Definition")',
                         },
+                        inlineRefs: {
+                            type: 'array',
+                            items: INLINE_REF_SCHEMA,
+                            description: 'Resolvable inline Rem references from the rendered title/headline. Markdown text preserves these as [[Target Title]].',
+                        },
                         parentRemId: {
                             type: 'string',
                             description: 'Direct parent Rem ID (omitted for top-level Rems)',
@@ -116,6 +206,15 @@ export const SEARCH_TOOL = {
                             type: 'string',
                             description: 'Direct parent title/front text (omitted for top-level Rems)',
                         },
+                        ancestors: {
+                            type: 'array',
+                            items: ANCESTOR_SCHEMA,
+                            description: 'Parent-first ancestor chain when ancestorDepth is greater than zero',
+                        },
+                        ancestorsTruncated: {
+                            type: 'boolean',
+                            description: 'Whether the ancestor chain was capped by ancestorDepth',
+                        },
                         aliases: {
                             type: 'array',
                             items: { type: 'string' },
@@ -130,17 +229,35 @@ export const SEARCH_TOOL = {
                             type: 'string',
                             description: 'Rem classification: document, dailyDocument, concept, descriptor, portal, or text',
                         },
+                        matchedRems: {
+                            type: 'array',
+                            items: MATCHED_REM_SCHEMA,
+                            description: 'For remnote_search_by_tag context mode, direct Rems carrying the requested tag that produced this context result',
+                        },
+                        contextRemId: {
+                            type: 'string',
+                            description: 'For remnote_search_by_tag tagged mode, resolved ancestor/context Rem ID for this direct match',
+                        },
+                        contextTitle: {
+                            type: 'string',
+                            description: 'For remnote_search_by_tag tagged mode, resolved ancestor/context title for this direct match',
+                        },
+                        contextReason: {
+                            type: 'string',
+                            enum: ['ancestor-document', 'ancestor-concept', 'ancestor-context', 'self'],
+                            description: 'For remnote_search_by_tag tagged mode, why the context Rem was selected',
+                        },
                         cardDirection: {
                             type: 'string',
                             description: 'Flashcard direction: forward, reverse, or bidirectional (omitted if not a flashcard)',
                         },
                         content: {
                             type: 'string',
-                            description: 'Rendered markdown content of child subtree (only when includeContent="markdown")',
+                            description: 'Rendered markdown content of child subtree (only when contentMode="markdown")',
                         },
                         contentStructured: {
                             type: 'array',
-                            description: 'Structured child subtree with nested remIds and metadata (only when includeContent="structured")',
+                            description: 'Structured child subtree with nested remIds and metadata (only when contentMode="structured")',
                             items: {
                                 type: 'object',
                                 properties: {
@@ -150,6 +267,11 @@ export const SEARCH_TOOL = {
                                         type: 'string',
                                         description: 'Display-oriented child line with type-aware delimiter',
                                     },
+                                    inlineRefs: {
+                                        type: 'array',
+                                        items: INLINE_REF_SCHEMA,
+                                        description: 'Resolvable inline Rem references from the child title/headline',
+                                    },
                                     aliases: {
                                         type: 'array',
                                         items: { type: 'string' },
@@ -198,12 +320,29 @@ export const SEARCH_TOOL = {
                     },
                 },
             },
+            hasMore: {
+                type: 'boolean',
+                description: 'Whether more results are available through nextCursor',
+            },
+            nextCursor: {
+                type: 'string',
+                description: 'Opaque cursor for the next page when hasMore is true',
+            },
+            truncated: {
+                type: 'boolean',
+                description: 'Whether search results may be incomplete because the bridge hit its snapshot cap',
+            },
+            truncationReason: {
+                type: 'string',
+                enum: ['cursor_snapshot_limit'],
+                description: 'Reason search results may be incomplete when truncated is true',
+            },
         },
     },
 };
 export const SEARCH_BY_TAG_TOOL = {
     name: 'remnote_search_by_tag',
-    description: 'Find notes by exact tag Rem ID and return resolved ancestor context targets (nearest document/daily document when available, otherwise nearest non-document ancestor). Does not look up tags by name or alias. Supports the same includeContent modes as remnote_search.',
+    description: 'Find notes by exact tag Rem ID. Supports cursor paging through hasMore/nextCursor. Default resultMode="context" returns resolved ancestor context targets with matchedRems; resultMode="tagged" returns directly tagged Rems with context metadata. Request ancestorDepth to include parent-first ancestors on both context results and matchedRems.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -211,12 +350,26 @@ export const SEARCH_BY_TAG_TOOL = {
                 type: 'string',
                 description: 'Exact tag Rem ID to search',
             },
+            resultMode: {
+                type: 'string',
+                enum: ['context', 'tagged'],
+                description: '"context" returns resolved ancestor context targets with matchedRems (default); "tagged" returns directly tagged Rems with context metadata',
+            },
             limit: { type: 'number', description: 'Maximum results (1-150, default: 50)' },
-            includeContent: {
+            contentMode: {
                 type: 'string',
                 enum: ['none', 'markdown', 'structured'],
                 description: 'Content rendering mode: "none" omits content (default), "markdown" renders child subtree as indented markdown, "structured" returns nested child objects with remIds',
             },
+            view: {
+                type: 'string',
+                enum: ['compact', 'standard', 'full'],
+                description: 'Output detail level: compact, standard, or full',
+            },
+            ancestorDepth: {
+                type: 'number',
+                description: 'Number of parent Rems to include, direct parent first (0-20, default: 0)',
+            },
             depth: {
                 type: 'number',
                 description: 'Depth of child hierarchy to render for markdown/structured content (0-10, default: 1)',
@@ -229,14 +382,31 @@ export const SEARCH_BY_TAG_TOOL = {
                 type: 'number',
                 description: 'Maximum character length for rendered content (default: 3000)',
             },
+            cursor: {
+                type: 'string',
+                description: 'Opaque cursor returned by a previous remnote_search_by_tag response',
+            },
+            timeoutMs: {
+                type: 'number',
+                description: 'Per-call bridge wait timeout in milliseconds (1-60000, default: 15000). Does not cancel plugin-side work.',
+            },
         },
         required: ['tagRemId'],
     },
-    outputSchema: SEARCH_TOOL.outputSchema,
+    outputSchema: {
+        type: 'object',
+        properties: {
+            results: SEARCH_TOOL.outputSchema.properties.results,
+            hasMore: SEARCH_TOOL.outputSchema.properties.hasMore,
+            nextCursor: SEARCH_TOOL.outputSchema.properties.nextCursor,
+            truncated: SEARCH_TOOL.outputSchema.properties.truncated,
+            truncationReason: SEARCH_TOOL.outputSchema.properties.truncationReason,
+        },
+    },
 };
 export const READ_NOTE_TOOL = {
     name: 'remnote_read_note',
-    description: 'Read a specific note from RemNote by its Rem ID. For hierarchy traversal, prefer includeContent="structured" and start shallow (depth=1, childLimit=500), then deepen only selected branches. Use includeContent="markdown" for summarization.',
+    description: 'Read a specific note from RemNote by its Rem ID. For hierarchy traversal, prefer contentMode="structured" and start shallow (depth=1, childLimit=500), then deepen only selected branches. Request ancestorDepth when placement context matters.',
     inputSchema: {
         type: 'object',
         properties: {
@@ -245,11 +415,20 @@ export const READ_NOTE_TOOL = {
                 type: 'number',
                 description: 'Depth of child hierarchy to render (0-10, default: 5)',
             },
-            includeContent: {
+            contentMode: {
                 type: 'string',
                 enum: ['none', 'markdown', 'structured'],
                 description: 'Content rendering mode: "markdown" renders child subtree (default), "structured" returns nested child objects with remIds, "none" omits content',
             },
+            view: {
+                type: 'string',
+                enum: ['compact', 'standard', 'full'],
+                description: 'Output detail level: compact, standard, or full',
+            },
+            ancestorDepth: {
+                type: 'number',
+                description: 'Number of parent Rems to include, direct parent first (0-20, default: 0)',
+            },
             childLimit: {
                 type: 'number',
                 description: 'Maximum children per level (1-500, default: 100)',
@@ -270,6 +449,11 @@ export const READ_NOTE_TOOL = {
                 type: 'string',
                 description: 'Display-oriented full line: title + type-aware delimiter + detail (e.g. "Term :: Definition")',
             },
+            inlineRefs: {
+                type: 'array',
+                items: INLINE_REF_SCHEMA,
+                description: 'Resolvable inline Rem references from the rendered title/headline. Markdown text preserves these as [[Target Title]].',
+            },
             parentRemId: {
                 type: 'string',
                 description: 'Direct parent Rem ID (omitted for top-level Rems)',
@@ -278,6 +462,15 @@ export const READ_NOTE_TOOL = {
                 type: 'string',
                 description: 'Direct parent title/front text (omitted for top-level Rems)',
             },
+            ancestors: {
+                type: 'array',
+                items: ANCESTOR_SCHEMA,
+                description: 'Parent-first ancestor chain when ancestorDepth is greater than zero',
+            },
+            ancestorsTruncated: {
+                type: 'boolean',
+                description: 'Whether the ancestor chain was capped by ancestorDepth',
+            },
             aliases: {
                 type: 'array',
                 items: { type: 'string' },
@@ -298,11 +491,11 @@ export const READ_NOTE_TOOL = {
             },
             content: {
                 type: 'string',
-                description: 'Rendered markdown content of child subtree (when includeContent="markdown", which is the default)',
+                description: 'Rendered markdown content of child subtree (when contentMode="markdown", which is the default)',
             },
             contentStructured: {
                 type: 'array',
-                description: 'Structured child subtree with nested remIds and metadata (only when includeContent="structured")',
+                description: 'Structured child subtree with nested remIds and metadata (only when contentMode="structured")',
                 items: {
                     type: 'object',
                     properties: {
@@ -312,6 +505,11 @@ export const READ_NOTE_TOOL = {
                             type: 'string',
                             description: 'Display-oriented child line with type-aware delimiter',
                         },
+                        inlineRefs: {
+                            type: 'array',
+                            items: INLINE_REF_SCHEMA,
+                            description: 'Resolvable inline Rem references from the child title/headline',
+                        },
                         aliases: {
                             type: 'array',
                             items: { type: 'string' },
@@ -360,6 +558,98 @@ export const READ_NOTE_TOOL = {
         },
     },
 };
+export const LIST_CHILDREN_TOOL = {
+    name: 'remnote_list_children',
+    description: 'List direct child Rems under a parent without rendering a subtree. Use for cheap hierarchy traversal; page with nextCursor when hasMore is true.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            parentRemId: { type: 'string', description: 'Parent Rem ID whose direct children to list' },
+            limit: { type: 'number', description: 'Maximum direct children (1-150, default: 50)' },
+            cursor: {
+                type: 'string',
+                description: 'Opaque cursor returned by a previous remnote_list_children response',
+            },
+            view: {
+                type: 'string',
+                enum: ['compact', 'standard', 'full'],
+                description: 'Output detail level for child metadata: compact, standard, or full',
+            },
+            ancestorDepth: {
+                type: 'number',
+                description: 'Number of parent Rems to include for each child, direct parent first',
+            },
+        },
+        required: ['parentRemId'],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: {
+            children: {
+                type: 'array',
+                items: SEARCH_TOOL.outputSchema.properties.results.items,
+            },
+            hasMore: SEARCH_TOOL.outputSchema.properties.hasMore,
+            nextCursor: SEARCH_TOOL.outputSchema.properties.nextCursor,
+            totalChildren: {
+                type: 'number',
+                description: 'Total direct children observed when listing this parent',
+            },
+        },
+    },
+};
+export const MOVE_NOTE_TOOL = {
+    name: 'remnote_move_note',
+    description: 'Safely move an existing Rem and its subtree under a new parent. Defaults to dryRun=true; pass dryRun=false only after user approval. expectedOldParentRemId rejects stale move proposals.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            remId: { type: 'string', description: 'Rem ID to move' },
+            newParentRemId: { type: 'string', description: 'New parent Rem ID' },
+            position: {
+                type: 'string',
+                enum: ['first', 'last', 'before', 'after'],
+                description: 'Where to place the moved Rem under the new parent (default: last)',
+            },
+            siblingRemId: {
+                type: 'string',
+                description: 'Sibling Rem ID required for before/after positioning',
+            },
+            dryRun: {
+                type: 'boolean',
+                description: 'Preview without mutating RemNote (default: true)',
+            },
+            expectedOldParentRemId: {
+                type: 'string',
+                description: 'Reject if the current direct parent differs from this Rem ID',
+            },
+            ancestorDepth: {
+                type: 'number',
+                description: 'Number of parent Rems to include before/after the move',
+            },
+        },
+        required: ['remId', 'newParentRemId'],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: {
+            remId: { type: 'string' },
+            title: { type: 'string' },
+            dryRun: { type: 'boolean' },
+            oldParentRemId: { type: 'string' },
+            oldParentTitle: { type: 'string' },
+            newParentRemId: { type: 'string' },
+            newParentTitle: { type: 'string' },
+            position: { type: 'string', enum: ['first', 'last', 'before', 'after'] },
+            siblingRemId: { type: 'string' },
+            ancestorsBefore: { type: 'array', items: ANCESTOR_SCHEMA },
+            ancestorsBeforeTruncated: { type: 'boolean' },
+            ancestorsAfter: { type: 'array', items: ANCESTOR_SCHEMA },
+            ancestorsAfterTruncated: { type: 'boolean' },
+        },
+        required: ['remId', 'title', 'dryRun', 'newParentRemId', 'newParentTitle', 'position'],
+    },
+};
 export const UPDATE_NOTE_TOOL = {
     name: 'remnote_update_note',
     description: 'Update note metadata in RemNote. Use this tool for title changes only.',
@@ -389,6 +679,100 @@ export const UPDATE_NOTE_TOOL = {
         required: ['remIds', 'titles'],
     },
 };
+export const SET_DOCUMENT_STATUS_TOOL = {
+    name: 'remnote_set_document_status',
+    description: 'Preview or set whether an existing Rem is marked as a document. Uses dryRun=true by default, preserves Rem ID, children, parent, tags, and concept/card status, and requires write operations to be enabled.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            remId: { type: 'string', description: 'The Rem ID whose document status should change' },
+            isDocument: {
+                type: 'boolean',
+                description: 'Whether the Rem should be marked as a document',
+            },
+            dryRun: {
+                type: 'boolean',
+                description: 'Preview the document-status change without mutating RemNote (default: true)',
+            },
+            expectedOldRemType: {
+                type: 'string',
+                enum: ['document', 'dailyDocument', 'concept', 'descriptor', 'portal', 'text'],
+                description: 'Optional stale-context guard; reject if current remType differs from this value',
+            },
+        },
+        required: ['remId', 'isDocument'],
+        additionalProperties: false,
+    },
+    outputSchema: {
+        type: 'object',
+        properties: {
+            remId: { type: 'string', description: 'The Rem ID that was checked or changed' },
+            title: { type: 'string', description: 'Rendered title/front text' },
+            oldRemType: {
+                type: 'string',
+                description: 'Bridge remType before the requested document-status change',
+            },
+            newRemType: {
+                type: 'string',
+                description: 'Bridge remType after the change, or previewed remType for dry runs',
+            },
+            oldIsDocument: {
+                type: 'boolean',
+                description: 'Document status before the requested change',
+            },
+            newIsDocument: {
+                type: 'boolean',
+                description: 'Document status after the change, or previewed status for dry runs',
+            },
+            requestedIsDocument: {
+                type: 'boolean',
+                description: 'Requested document status',
+            },
+            dryRun: {
+                type: 'boolean',
+                description: 'Whether the request was only a preview',
+            },
+            changed: {
+                type: 'boolean',
+                description: 'Whether RemNote was actually mutated by this call',
+            },
+            wouldChange: {
+                type: 'boolean',
+                description: 'Whether the requested status differs from the current status',
+            },
+            sdkSupportsDocumentStatus: {
+                type: 'boolean',
+                description: 'Whether the bridge runtime exposes a safe SDK document-status setter',
+            },
+            warnings: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Important side-effect notes, especially around preserved card status',
+            },
+            cardDirectionBefore: {
+                type: 'string',
+                description: 'Card direction before the change when available',
+            },
+            cardDirectionAfter: {
+                type: 'string',
+                description: 'Card direction after the change when available',
+            },
+        },
+        required: [
+            'remId',
+            'title',
+            'oldRemType',
+            'newRemType',
+            'oldIsDocument',
+            'newIsDocument',
+            'requestedIsDocument',
+            'dryRun',
+            'changed',
+            'wouldChange',
+            'sdkSupportsDocumentStatus',
+        ],
+    },
+};
 export const INSERT_CHILDREN_TOOL = {
     name: 'remnote_insert_children',
     description: 'Insert new child Rems under a parent at a deterministic position without replacing existing children. Use this for tag description nodes and hierarchy maintenance.',
@@ -634,7 +1018,8 @@ export const PLAYBOOK_TOOL = {
                     orientation: {
                         type: 'object',
                         properties: {
-                            includeContent: { type: 'string' },
+                            contentMode: { type: 'string' },
+                            view: { type: 'string' },
                             depth: { type: 'number' },
                             childLimit: { type: 'number' },
                         },
@@ -670,7 +1055,10 @@ export const ALL_TOOLS = [
     SEARCH_TOOL,
     SEARCH_BY_TAG_TOOL,
     READ_NOTE_TOOL,
+    LIST_CHILDREN_TOOL,
     UPDATE_NOTE_TOOL,
+    SET_DOCUMENT_STATUS_TOOL,
+    MOVE_NOTE_TOOL,
     INSERT_CHILDREN_TOOL,
     REPLACE_CHILDREN_TOOL,
     UPDATE_TAGS_TOOL,
@@ -724,7 +1112,8 @@ export function registerAllTools(server, wsServer, logger) {
                 }
                 case 'remnote_search_by_tag': {
                     const args = SearchByTagSchema.parse(request.params.arguments);
-                    result = await wsServer.sendRequest('search_by_tag', args);
+                    const { timeoutMs, ...payload } = args;
+                    result = await wsServer.sendRequest('search_by_tag', payload, timeoutMs);
                     break;
                 }
                 case 'remnote_read_note': {
@@ -732,16 +1121,31 @@ export function registerAllTools(server, wsServer, logger) {
                     result = await wsServer.sendRequest('read_note', args);
                     break;
                 }
+                case 'remnote_list_children': {
+                    const args = ListChildrenSchema.parse(request.params.arguments);
+                    result = await wsServer.sendRequest('list_children', args);
+                    break;
+                }
                 case 'remnote_update_note': {
                     const args = UpdateNoteSchema.parse(request.params.arguments);
                     result = await wsServer.sendRequest('update_note', args);
                     break;
                 }
+                case 'remnote_set_document_status': {
+                    const args = SetDocumentStatusSchema.parse(request.params.arguments);
+                    result = await wsServer.sendRequest('set_document_status', args);
+                    break;
+                }
                 case 'remnote_insert_children': {
                     const args = InsertChildrenSchema.parse(request.params.arguments);
                     result = await wsServer.sendRequest('insert_children', args);
                     break;
                 }
+                case 'remnote_move_note': {
+                    const args = MoveNoteSchema.parse(request.params.arguments);
+                    result = await wsServer.sendRequest('move_note', args);
+                    break;
+                }
                 case 'remnote_replace_children': {
                     const args = ReplaceChildrenSchema.parse(request.params.arguments);
                     result = await wsServer.sendRequest('replace_children', args);
@@ -769,8 +1173,8 @@ export function registerAllTools(server, wsServer, logger) {
                         };
                     }
                     result = {
-                        playbookVersion: '1.1.0',
-                        summary: 'Use this playbook to navigate RemNote efficiently via remIds, and to apply write-safety checks before mutations.',
+                        playbookVersion: '1.5.0',
+                        summary: 'Use this playbook to check RemNote connection and write gates, navigate by remId with paged search/read/list workflows, request nearby ancestors when hierarchy context matters, choose compact/full output views, and apply safe exact-ID writes including dry-run-first document status changes.',
                         recommendedStatusCheck: {
                             tool: 'remnote_status',
                             cadence: 'recommended once per session and before risky writes',
@@ -778,15 +1182,23 @@ export function registerAllTools(server, wsServer, logger) {
                         },
                         decisionTree: [
                             'Need connection/capability context? Call remnote_status first.',
-                            'Need to orient across the KB? Use remnote_search with includeContent="structured", depth=1, childLimit=500.',
-                            'Need tagged-note context? Use remnote_search_by_tag with tagRemId; it does not resolve tag names or aliases.',
-                            'Need to traverse a specific branch? Use remnote_read_note on a chosen remId with includeContent="structured", depth=1, childLimit=500, then recurse by child remIds.',
+                            'Need to orient across the KB? Use remnote_search with contentMode="structured", view="compact", depth=1, childLimit=500.',
+                            'Need broad search enumeration? Continue remnote_search or remnote_search_by_tag with nextCursor while hasMore is true.',
+                            'Need tagged-note context/navigation? Use remnote_search_by_tag with tagRemId and default resultMode="context"; inspect matchedRems to see the direct tagged Rems behind each context result.',
+                            'Need hierarchy placement context? Add ancestorDepth, typically 5, to search/read/search_by_tag/list_children; ancestors are direct-parent first.',
+                            'Need strict tag verification? Use remnote_search_by_tag with resultMode="tagged", or verify the exact Rem in matchedRems from context mode.',
+                            'Need a large tag search to finish? Prefer cursor paging first; use remnote_search_by_tag.timeoutMs only as a bounded wait-time escape hatch.',
+                            'Need to traverse a specific branch cheaply? Use remnote_list_children on the parentRemId and page through direct children.',
+                            'Need to read a selected subtree? Use remnote_read_note on a chosen remId with contentMode="structured", depth=1, childLimit=500, then deepen selected branches.',
+                            'Need to follow inline graph references? Inspect inlineRefs on search/read results and structured child nodes for exact target Rem IDs.',
                             'Need tabular/structured data from an Advanced Table? Use remnote_read_table with either tableTitle or tableRemId. Use propertyFilter to limit columns for large tables.',
-                            'Need a human-readable summary? Switch to includeContent="markdown" on search/read results.',
+                            'Need a human-readable summary? Switch to contentMode="markdown" on search/read results.',
                             'Need to rename a note? Use remnote_update_note with remId and title only.',
-                            'Need to create a note? Use remnote_create_note; pass tagRemIds for exact-ID tag assignment.',
+                            'Need to create a note? Use remnote_create_note; pass tagRemIds for exact-ID tag assignment and asDocument=true when the title/root Rem should be a document.',
+                            'Need to mark an existing Rem as a document? Use remnote_set_document_status dryRun first, include expectedOldRemType for stale-context protection, then rerun with dryRun=false after approval.',
                             'Need to append to today journal? Use remnote_append_journal; pass tagRemIds when the journal entry should be tagged.',
                             'Need to insert children? Use remnote_insert_children with an explicit position.',
+                            'Need to move a note? Use remnote_move_note dryRun first, include expectedOldParentRemId for stale-context protection, then rerun with dryRun=false after approval.',
                             'Need to replace children? Check remnote_status first; remnote_replace_children requires acceptReplaceOperation=true.',
                             'Need to update tags on an existing note? Use remnote_update_tags with exact tag Rem IDs.',
                         ],
@@ -795,18 +1207,25 @@ export function registerAllTools(server, wsServer, logger) {
                             branchTraversal: NAVIGATION_PRESET,
                         },
                         contentModes: {
-                            structured: 'ID-first traversal mode. Returns contentStructured with child remIds for deterministic follow-up reads.',
-                            markdown: 'Summary mode. Returns rendered markdown content for human-facing synthesis, not deterministic child ID traversal.',
+                            structured: 'ID-first traversal mode. Returns contentStructured with child remIds and inlineRefs for deterministic follow-up reads.',
+                            markdown: 'Summary mode. Returns rendered markdown content for human-facing synthesis; inline Rem references render as [[Target Title]].',
                             none: 'Metadata-only mode when content is not needed.',
                         },
+                        outputViews: {
+                            compact: 'Small metadata surface for broad discovery. Omits tags, aliases, inlineRefs, and diagnostic fields unless another option requires them.',
+                            standard: 'Normal discovery metadata for most agent workflows.',
+                            full: 'Verbose metadata for diagnostics or detailed audits.',
+                        },
                         writePolicy: {
                             statusTool: 'remnote_status',
                             requiredFields: ['acceptWriteOperations', 'acceptReplaceOperation'],
                             guidance: [
                                 'Create/update/insert/replace/tag/journal writes require acceptWriteOperations=true.',
                                 'remnote_update_note is metadata-only; use insert_children, replace_children, and update_tags for structural or tag writes.',
+                                'remnote_set_document_status changes only document status; it preserves concept/card status and defaults to dryRun=true.',
                                 'remnote_replace_children requires acceptReplaceOperation=true.',
                                 'remnote_insert_children preserves existing child Rem IDs; remnote_replace_children removes them.',
+                                'remnote_move_note preserves the moved Rem ID and subtree; dryRun defaults to true.',
                                 'All production tag writes use exact tag Rem IDs: create_note.tagRemIds, append_journal.tagRemIds, and update_tags add/remove arrays.',
                             ],
                         },