@noteplanco/noteplan-mcp 1.1.1

package/dist/server.js

@@ -0,0 +1,2468 @@
+// MCP Server with tool registration
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+// Import tool implementations
+import * as noteTools from './tools/notes.js';
+import * as searchTools from './tools/search.js';
+import * as taskTools from './tools/tasks.js';
+import * as calendarTools from './tools/calendar.js';
+import * as spaceTools from './tools/spaces.js';
+import * as filterTools from './tools/filters.js';
+import * as eventTools from './tools/events.js';
+import * as reminderTools from './tools/reminders.js';
+import * as embeddingsTools from './tools/embeddings.js';
+import * as memoryTools from './tools/memory.js';
+import * as uiTools from './tools/ui.js';
+import * as pluginTools from './tools/plugins.js';
+import * as themeTools from './tools/themes.js';
+import { parseFlexibleDate } from './utils/date-utils.js';
+import { upgradeMessage, getNotePlanVersion, MIN_BUILD_ADVANCED_FEATURES } from './utils/version.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PLUGIN_API_DOCS_DIR = path.join(__dirname, '../docs/plugin-api');
+const PLUGIN_API_RESOURCES = [
+    { file: 'plugin-api-condensed.md', name: 'Plugin API Reference (Condensed)', desc: 'Complete NotePlan plugin API — all signatures, types, and patterns in one reference. Read this first.' },
+    { file: 'getting-started.md', name: 'Getting Started Guide', desc: 'How to create NotePlan plugins — structure, setup, first plugin, testing, HTML views' },
+    { file: 'Editor.md', name: 'Editor API', desc: 'Note manipulation — insertText, paragraphs, selection, themes, openNoteByTitle' },
+    { file: 'DataStore.md', name: 'DataStore API', desc: 'Data access — folders, notes, preferences, teamspaces, hashtags' },
+    { file: 'NoteObject.md', name: 'Note Object', desc: 'Note properties/methods — content, paragraphs, frontmatter, dates' },
+    { file: 'Calendar.md', name: 'Calendar API', desc: 'Calendar events and reminders — add, update, query' },
+    { file: 'NotePlan.md', name: 'NotePlan API', desc: 'Core globals — environment, AI, themes, settings' },
+    { file: 'CommandBar.md', name: 'CommandBar API', desc: 'User interaction — showOptions, showInput, showLoading, textPrompt' },
+    { file: 'HTMLView.md', name: 'HTMLView API', desc: 'HTML views — showWindow, showInMainWindow, showInSplitView, JS bridge' },
+    { file: 'CalendarItem.md', name: 'CalendarItem Object', desc: 'Calendar event/reminder structure and properties' },
+    { file: 'ParagraphObject.md', name: 'Paragraph Object', desc: 'Paragraph structure — type, content, heading level, indents, links' },
+    { file: 'Clipboard.md', name: 'Clipboard API', desc: 'Read/write system clipboard' },
+    { file: 'RangeObject.md', name: 'Range Object', desc: 'Text range — start, end, length for selections' },
+    { file: 'plugin.json', name: 'Demo plugin.json', desc: 'Example plugin manifest — ID, name, commands, settings, dependencies' },
+    { file: 'script.js', name: 'Demo script.js', desc: 'Example plugin implementation with multiple API usage examples' },
+];
+function normalizeToolName(name) {
+    const separatorIndex = name.lastIndexOf(':');
+    if (separatorIndex === -1)
+        return name;
+    const normalized = name.slice(separatorIndex + 1).trim();
+    return normalized || name;
+}
+function outputSchemaWithErrors(properties = {}) {
+    return {
+        type: 'object',
+        properties: {
+            success: { type: 'boolean' },
+            durationMs: { type: 'number' },
+            stageTimings: {
+                type: 'object',
+                additionalProperties: { type: 'number' },
+            },
+            performanceHints: {
+                type: 'array',
+                items: { type: 'string' },
+            },
+            suggestedNextTools: {
+                type: 'array',
+                items: { type: 'string' },
+            },
+            memoryHints: {
+                type: 'object',
+                properties: {
+                    storedMemories: { type: 'number' },
+                    tip: { type: 'string' },
+                },
+            },
+            ...properties,
+            error: { type: 'string' },
+            code: { type: 'string' },
+            hint: { type: 'string' },
+            suggestedTool: { type: 'string' },
+            retryable: { type: 'boolean' },
+        },
+        required: ['success'],
+    };
+}
+const GENERIC_TOOL_OUTPUT_SCHEMA = outputSchemaWithErrors();
+const MESSAGE_OUTPUT_SCHEMA = outputSchemaWithErrors({ message: { type: 'string' } });
+const NOTE_OUTPUT_SCHEMA = outputSchemaWithErrors({
+    note: { type: 'object' },
+    created: { type: 'boolean' },
+    contentIncluded: { type: 'boolean' },
+    contentLength: { type: 'number' },
+    lineCount: { type: 'number' },
+    preview: { type: 'string' },
+    previewTruncated: { type: 'boolean' },
+    rangeStartLine: { type: 'number' },
+    rangeEndLine: { type: 'number' },
+    rangeLineCount: { type: 'number' },
+    returnedLineCount: { type: 'number' },
+    offset: { type: 'number' },
+    limit: { type: 'number' },
+    hasMore: { type: 'boolean' },
+    nextCursor: { type: ['string', 'null'] },
+    content: { type: 'string' },
+    lines: { type: 'array', items: { type: 'object' } },
+});
+const NOTES_LIST_OUTPUT_SCHEMA = outputSchemaWithErrors({
+    count: { type: 'number' },
+    totalCount: { type: 'number' },
+    offset: { type: 'number' },
+    limit: { type: 'number' },
+    hasMore: { type: 'boolean' },
+    nextCursor: { type: ['string', 'null'] },
+    notes: { type: 'array', items: { type: 'object' } },
+});
+const RESOLVE_NOTE_OUTPUT_SCHEMA = outputSchemaWithErrors({
+    query: { type: 'string' },
+    count: { type: 'number' },
+    exactMatch: { type: 'boolean' },
+    ambiguous: { type: 'boolean' },
+    confidence: { type: 'number' },
+    confidenceDelta: { type: 'number' },
+    resolved: { type: ['object', 'null'] },
+    suggestedGetNoteArgs: { type: ['object', 'null'] },
+    candidates: { type: 'array', items: { type: 'object' } },
+});
+const SEARCH_NOTES_OUTPUT_SCHEMA = outputSchemaWithErrors({
+    query: { type: 'string' },
+    searchField: { type: 'string' },
+    queryMode: { type: 'string' },
+    effectiveQuery: { type: 'string' },
+    tokenTerms: { type: 'array', items: { type: 'string' } },
+    minTokenMatches: { type: 'number' },
+    count: { type: 'number' },
+    propertyFilters: { type: 'object', additionalProperties: { type: 'string' } },
+    propertyCaseSensitive: { type: 'boolean' },
+    partialResults: { type: 'boolean' },
+    searchBackend: { type: 'string' },
+    warnings: { type: 'array', items: { type: 'string' } },
+    results: { type: 'array', items: { type: 'object' } },
+});
+const RANGE_NOTES_OUTPUT_SCHEMA = outputSchemaWithErrors({
+    period: { type: 'string' },
+    startDate: { type: 'string' },
+    endDate: { type: 'string' },
+    noteCount: { type: 'number' },
+    totalDays: { type: 'number' },
+    scannedDays: { type: 'number' },
+    truncatedByMaxDays: { type: 'boolean' },
+    maxDays: { type: 'number' },
+    offset: { type: 'number' },
+    limit: { type: 'number' },
+    hasMore: { type: 'boolean' },
+    nextCursor: { type: ['string', 'null'] },
+    notes: { type: 'array', items: { type: 'object' } },
+});
+const FOLDER_NOTES_OUTPUT_SCHEMA = outputSchemaWithErrors({
+    folder: { type: 'string' },
+    noteCount: { type: 'number' },
+    totalInFolder: { type: 'number' },
+    offset: { type: 'number' },
+    limit: { type: 'number' },
+    hasMore: { type: 'boolean' },
+    nextCursor: { type: ['string', 'null'] },
+    notes: { type: 'array', items: { type: 'object' } },
+});
+const SPACES_OUTPUT_SCHEMA = outputSchemaWithErrors({
+    count: { type: 'number' },
+    totalCount: { type: 'number' },
+    offset: { type: 'number' },
+    limit: { type: 'number' },
+    hasMore: { type: 'boolean' },
+    nextCursor: { type: ['string', 'null'] },
+    spaces: { type: 'array', items: { type: 'object' } },
+});
+const TAGS_OUTPUT_SCHEMA = outputSchemaWithErrors({
+    count: { type: 'number' },
+    totalCount: { type: 'number' },
+    offset: { type: 'number' },
+    limit: { type: 'number' },
+    hasMore: { type: 'boolean' },
+    nextCursor: { type: ['string', 'null'] },
+    tags: { type: 'array', items: { type: 'string' } },
+});
+function getToolOutputSchema(toolName) {
+    switch (toolName) {
+        case 'noteplan_search':
+            return SEARCH_NOTES_OUTPUT_SCHEMA;
+        // Consolidated tools — use GENERIC since return shape varies by action/route
+        case 'noteplan_get_notes':
+        case 'noteplan_manage_note':
+        case 'noteplan_edit_content':
+        case 'noteplan_paragraphs':
+        case 'noteplan_folders':
+        case 'noteplan_filters':
+        case 'noteplan_eventkit':
+        case 'noteplan_memory':
+        case 'noteplan_ui':
+        case 'noteplan_plugins':
+        case 'noteplan_themes':
+        case 'noteplan_embeddings':
+            return GENERIC_TOOL_OUTPUT_SCHEMA;
+        default:
+            return GENERIC_TOOL_OUTPUT_SCHEMA;
+    }
+}
+function resolveScheduleDate(dateInput) {
+    const compact = parseFlexibleDate(dateInput); // returns YYYYMMDD
+    // Convert YYYYMMDD → YYYY-MM-DD for NotePlan scheduling syntax
+    const match = compact.match(/^(\d{4})(\d{2})(\d{2})$/);
+    if (!match)
+        return dateInput; // fallback: use as-is
+    return `${match[1]}-${match[2]}-${match[3]}`;
+}
+function appendScheduleDate(content, scheduleDate) {
+    if (!scheduleDate)
+        return content;
+    const formatted = resolveScheduleDate(scheduleDate);
+    return `${content} >${formatted}`;
+}
+const PERIOD_TYPE_MAP = {
+    week: 'weekly',
+    month: 'monthly',
+    quarter: 'quarterly',
+    year: 'yearly',
+};
+function dispatchGetNotes(args) {
+    const { resolve, resolveQuery, id, title, filename, date, period, count, rangePeriod, startDate, endDate, folder, space, types, query, limit, offset, cursor, minScore, ambiguityDelta, 
+    // periodic note params
+    week, month, quarter, year, fromDate, includeContent, includeMissing, maxLookback, 
+    // range params
+    maxDays, } = args;
+    // 1. resolve mode
+    if (resolve) {
+        return noteTools.resolveNote({
+            query: resolveQuery ?? query,
+            space, folder, types, limit, minScore, ambiguityDelta,
+        });
+    }
+    // 2. single note by identifier
+    if (id || title || filename) {
+        return noteTools.getNote(args);
+    }
+    // 3. recent periodic notes (period + count)
+    if (period && count) {
+        const periodicType = PERIOD_TYPE_MAP[period] ?? period;
+        return calendarTools.getRecentPeriodicNotes({
+            type: periodicType, count, fromDate, includeContent, includeMissing, maxLookback, space,
+        });
+    }
+    // 4. single periodic note (period, no count)
+    if (period && !count) {
+        const periodicType = PERIOD_TYPE_MAP[period] ?? period;
+        return calendarTools.getPeriodicNote({
+            type: periodicType, date, week, month, quarter, year, space,
+        });
+    }
+    // 5. date range
+    if (rangePeriod || (startDate && endDate)) {
+        return calendarTools.getNotesInRange({
+            period: rangePeriod ?? 'custom', startDate, endDate, includeContent, maxDays, limit, offset, cursor, space,
+        });
+    }
+    // 6. folder listing (no id/title/filename/date)
+    if (folder && !date) {
+        return calendarTools.getNotesInFolder({
+            folder, includeContent, limit, offset, cursor, space,
+        });
+    }
+    // 7. calendar note by date
+    if (date) {
+        return calendarTools.getCalendarNote({ date, space });
+    }
+    // 8. fallback: list notes
+    return noteTools.listNotes({
+        folder, space, types, query, limit, offset, cursor,
+    });
+}
+function toBoundedInt(value, defaultValue, min, max) {
+    const numeric = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(numeric))
+        return defaultValue;
+    return Math.min(max, Math.max(min, Math.floor(numeric)));
+}
+function isDebugTimingsEnabled(args) {
+    if (!args || typeof args !== 'object')
+        return false;
+    const rawValue = args.debugTimings;
+    if (typeof rawValue === 'boolean')
+        return rawValue;
+    if (typeof rawValue === 'string') {
+        const normalized = rawValue.trim().toLowerCase();
+        return normalized === 'true' || normalized === '1';
+    }
+    return false;
+}
+function withDebugTimingsInputSchema(inputSchema) {
+    const schema = { ...inputSchema };
+    const properties = schema.properties && typeof schema.properties === 'object'
+        ? { ...schema.properties }
+        : {};
+    if (!('debugTimings' in properties)) {
+        properties.debugTimings = {
+            type: 'boolean',
+            description: 'Include durationMs timing metadata in response (default: false)',
+        };
+    }
+    schema.properties = properties;
+    return schema;
+}
+function compactDescription(description, maxLength = 120) {
+    const firstLine = description
+        .split('\n')
+        .map((line) => line.trim())
+        .find((line) => line.length > 0) ?? '';
+    if (firstLine.length <= maxLength)
+        return firstLine;
+    return `${firstLine.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+function stripDescriptions(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => stripDescriptions(item));
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const input = value;
+    const output = {};
+    for (const [key, nested] of Object.entries(input)) {
+        if (key === 'description')
+            continue;
+        output[key] = stripDescriptions(nested);
+    }
+    return output;
+}
+function compactToolDefinition(tool, maxDescLength = 120) {
+    return {
+        name: tool.name,
+        description: compactDescription(tool.description, maxDescLength),
+        inputSchema: stripDescriptions(tool.inputSchema),
+        annotations: tool.annotations,
+    };
+}
+function getToolAnnotations(toolName) {
+    // Read-only tools
+    const readOnlyTools = new Set([
+        'noteplan_get_notes',
+        'noteplan_search',
+    ]);
+    // Consolidated tools with mixed read+write actions get pessimistic annotations
+    const destructiveTools = new Set([
+        'noteplan_manage_note',
+        'noteplan_edit_content',
+        'noteplan_paragraphs',
+        'noteplan_folders',
+        'noteplan_filters',
+        'noteplan_eventkit',
+        'noteplan_memory',
+        'noteplan_plugins',
+        'noteplan_themes',
+        'noteplan_embeddings',
+    ]);
+    const nonIdempotentTools = new Set([
+        'noteplan_manage_note',
+        'noteplan_edit_content',
+        'noteplan_paragraphs',
+        'noteplan_folders',
+        'noteplan_filters',
+        'noteplan_eventkit',
+        'noteplan_memory',
+        'noteplan_ui',
+        'noteplan_plugins',
+        'noteplan_themes',
+        'noteplan_embeddings',
+    ]);
+    const openWorldTools = new Set([
+        'noteplan_eventkit',
+        'noteplan_embeddings',
+        'noteplan_plugins',
+    ]);
+    return {
+        readOnlyHint: readOnlyTools.has(toolName),
+        destructiveHint: destructiveTools.has(toolName),
+        idempotentHint: !nonIdempotentTools.has(toolName),
+        openWorldHint: openWorldTools.has(toolName),
+    };
+}
+const QUERY_SYNONYMS = {
+    todo: ['task', 'tasks', 'reminder', 'reminders', 'checklist'],
+    tasks: ['task', 'todo', 'reminder'],
+    meeting: ['calendar', 'event', 'schedule', 'appointment'],
+    events: ['event', 'calendar', 'schedule', 'meeting'],
+    workspace: ['space', 'spaces', 'teamspace'],
+    teamspace: ['space', 'workspace', 'spaces'],
+    folder: ['folders', 'directory', 'path', 'project'],
+    projects: ['project', 'folder'],
+    resolve: ['disambiguate', 'canonical', 'match'],
+    disambiguate: ['resolve', 'canonical', 'match'],
+    edit: ['update', 'modify', 'change'],
+    delete: ['remove', 'erase', 'clear'],
+    restore: ['recover', 'undo', 'undelete'],
+    create: ['add', 'new', 'make'],
+    paragraph: ['line', 'block', 'section', 'text'],
+    lines: ['line', 'paragraph', 'content'],
+    embeddings: ['semantic', 'vector', 'similarity', 'meaning'],
+    semantic: ['embeddings', 'vector', 'similarity'],
+};
+function getToolSearchAliases(toolName) {
+    const aliases = [];
+    switch (toolName) {
+        case 'noteplan_get_notes':
+            aliases.push('notes', 'documents', 'markdown', 'resolve note', 'canonical note', 'disambiguate note', 'today', 'daily note', 'journal', 'calendar note', 'date note', 'weekly notes', 'monthly notes', 'periodic notes', 'quarterly', 'date range', 'this week', 'last week', 'folder notes', 'browse folder', 'list notes');
+            break;
+        case 'noteplan_search':
+            aliases.push('search notes', 'find notes', 'full-text search', 'tags', 'hashtags');
+            break;
+        case 'noteplan_manage_note':
+            aliases.push('create note', 'update note', 'delete note', 'move note', 'rename note', 'restore note', 'frontmatter', 'property', 'set property');
+            break;
+        case 'noteplan_edit_content':
+            aliases.push('insert', 'append', 'edit line', 'delete lines', 'replace lines', 'edit content', 'today', 'daily note');
+            break;
+        case 'noteplan_paragraphs':
+            aliases.push('paragraphs', 'lines', 'line numbers', 'search paragraph', 'find paragraph', 'tasks', 'todos', 'checklist', 'add task', 'complete task', 'update task', 'search tasks', 'global tasks');
+            break;
+        case 'noteplan_folders':
+            aliases.push('folders', 'directory', 'create folder', 'move folder', 'rename folder', 'delete folder', 'resolve folder', 'find folder', 'spaces', 'workspaces', 'teamspaces');
+            break;
+        case 'noteplan_filters':
+            aliases.push('filters', 'saved filters', 'task filters', 'filter parameters', 'run filter');
+            break;
+        case 'noteplan_eventkit':
+            aliases.push('calendar', 'event', 'events', 'schedule', 'meeting', 'appointment', 'create event', 'delete event', 'reminder', 'reminders', 'todo', 'checklist', 'create reminder', 'complete reminder');
+            break;
+        case 'noteplan_memory':
+            aliases.push('memory', 'memories', 'preference', 'preferences', 'remember', 'correction');
+            break;
+        case 'noteplan_ui':
+            aliases.push('ui', 'open note', 'open today', 'search ui', 'run plugin', 'sidebar', 'toggle sidebar');
+            break;
+        case 'noteplan_plugins':
+            aliases.push('plugin', 'plugins', 'extension', 'command', 'addon', 'create plugin', 'install plugin', 'plugin log', 'plugin source', 'screenshot');
+            break;
+        case 'noteplan_themes':
+            aliases.push('theme', 'themes', 'colors', 'dark mode', 'light mode', 'appearance');
+            break;
+        case 'noteplan_embeddings':
+            aliases.push('embeddings', 'semantic search', 'vector search', 'similarity');
+            break;
+    }
+    return aliases;
+}
+function expandQueryTokens(query) {
+    const tokens = query
+        .toLowerCase()
+        .split(/\s+/)
+        .map((token) => token.trim())
+        .filter(Boolean);
+    const expanded = new Set(tokens);
+    for (const token of tokens) {
+        const synonyms = QUERY_SYNONYMS[token];
+        if (!synonyms)
+            continue;
+        synonyms.forEach((synonym) => expanded.add(synonym));
+    }
+    return Array.from(expanded);
+}
+function scoreToolMatch(tool, query) {
+    const q = query.toLowerCase();
+    const name = tool.name.toLowerCase();
+    const description = tool.description.toLowerCase();
+    const aliases = getToolSearchAliases(tool.name);
+    const aliasText = aliases.join(' ').toLowerCase();
+    const searchable = `${name} ${description} ${aliasText}`;
+    const queryTokens = expandQueryTokens(q);
+    if (name === q)
+        return 1.0;
+    if (name.startsWith(q))
+        return 0.95;
+    if (name.includes(q))
+        return 0.9;
+    if (aliases.some((alias) => alias.toLowerCase() === q))
+        return 0.88;
+    if (description.includes(q))
+        return 0.75;
+    if (aliasText.includes(q))
+        return 0.74;
+    if (queryTokens.length === 0)
+        return 0;
+    const tokenHits = queryTokens.filter((token) => searchable.includes(token)).length;
+    return tokenHits > 0 ? tokenHits / queryTokens.length * 0.62 : 0;
+}
+function searchToolDefinitions(tools, query, limit) {
+    return tools
+        .map((tool) => ({ tool, score: scoreToolMatch(tool, query) }))
+        .filter((entry) => entry.score > 0)
+        .sort((a, b) => {
+        if (Math.abs(a.score - b.score) > 0.001)
+            return b.score - a.score;
+        return a.tool.name.localeCompare(b.tool.name);
+    })
+        .slice(0, limit);
+}
+function inferToolErrorMeta(toolName, errorMessage, registeredToolNames) {
+    const message = errorMessage.toLowerCase();
+    if (message.includes('unknown tool')) {
+        const toolList = registeredToolNames?.join(', ') ?? 'noteplan_get_notes, noteplan_search, noteplan_manage_note, noteplan_edit_content, noteplan_paragraphs, noteplan_folders, noteplan_filters, noteplan_eventkit, noteplan_memory';
+        return {
+            code: 'ERR_UNKNOWN_TOOL',
+            hint: `Check tool name spelling. Available tools: ${toolList}.`,
+        };
+    }
+    if (message.includes('query is required')) {
+        return {
+            code: 'ERR_QUERY_REQUIRED',
+            hint: 'Provide a non-empty query string to run this operation.',
+        };
+    }
+    if (message.includes('requires a newer version of noteplan')) {
+        return {
+            code: 'ERR_VERSION_GATE',
+            hint: 'Update NotePlan to the latest version, then retry.',
+        };
+    }
+    if (message.includes('embeddings are disabled')) {
+        return {
+            code: 'ERR_EMBEDDINGS_DISABLED',
+            hint: 'Enable embeddings in MCP env: NOTEPLAN_EMBEDDINGS_ENABLED=true.',
+            suggestedTool: 'noteplan_embeddings',
+        };
+    }
+    if (message.includes('embeddings api key is missing')) {
+        return {
+            code: 'ERR_EMBEDDINGS_NOT_CONFIGURED',
+            hint: 'Set NOTEPLAN_EMBEDDINGS_API_KEY (and optionally provider/model/base URL), then retry sync/search.',
+            suggestedTool: 'noteplan_embeddings',
+        };
+    }
+    if (message.includes('provide one note reference')) {
+        return {
+            code: 'ERR_INVALID_ARGUMENT',
+            hint: 'Pass one of: id, filename, title, or date to identify the note target.',
+            suggestedTool: 'noteplan_get_notes',
+        };
+    }
+    if (message.includes('provide lineindex') ||
+        message.includes('lineindex must be') ||
+        message.includes('line must be') ||
+        message.includes('line and lineindex reference different')) {
+        return {
+            code: 'ERR_INVALID_ARGUMENT',
+            hint: 'For task updates, pass either lineIndex (0-based) or line (1-based).',
+            suggestedTool: 'noteplan_paragraphs',
+        };
+    }
+    if (message.includes('provide at least one field to update')) {
+        return {
+            code: 'ERR_INVALID_ARGUMENT',
+            hint: 'For noteplan_paragraphs(action=update), pass content, status, or both.',
+            suggestedTool: 'noteplan_paragraphs',
+        };
+    }
+    if (message.includes('empty content is blocked') || message.includes('empty line content is blocked') || message.includes('empty task content is blocked')) {
+        return {
+            code: 'ERR_EMPTY_CONTENT_BLOCKED',
+            hint: 'Use allowEmptyContent=true for intentional clears, or use noteplan_edit_content(action=delete_lines).',
+            suggestedTool: 'noteplan_edit_content',
+        };
+    }
+    if (message.includes('empty replacement content is blocked')) {
+        return {
+            code: 'ERR_EMPTY_CONTENT_BLOCKED',
+            hint: 'Use noteplan_edit_content(action=delete_lines) for deletion, or set allowEmptyContent=true.',
+            suggestedTool: 'noteplan_edit_content',
+        };
+    }
+    if (message.includes('supported for local notes only') || message.includes('supported for project notes only')) {
+        return {
+            code: 'ERR_UNSUPPORTED_TARGET',
+            hint: 'These tools currently operate on local project notes under Notes/.',
+            suggestedTool: 'noteplan_get_notes',
+        };
+    }
+    if (message.includes('not in teamspace @trash') || message.includes('local note is not in @trash')) {
+        return {
+            code: 'ERR_NOT_IN_TRASH',
+            hint: 'Restore only works for notes currently in trash.',
+            suggestedTool: 'noteplan_manage_note',
+        };
+    }
+    if (message.includes('note is in trash')) {
+        return {
+            code: 'ERR_NOTE_IN_TRASH',
+            hint: 'Use noteplan_manage_note(action=restore) to recover this note, then retry.',
+            suggestedTool: 'noteplan_manage_note',
+        };
+    }
+    if (message.includes('full note replacement is blocked')) {
+        return {
+            code: 'ERR_FULL_REPLACE_CONFIRMATION_REQUIRED',
+            hint: 'Set fullReplace=true only for intentional whole-note rewrites; otherwise use noteplan_edit_content.',
+            suggestedTool: 'noteplan_paragraphs',
+        };
+    }
+    if (message.includes('confirmation token is required')) {
+        return {
+            code: 'ERR_CONFIRMATION_REQUIRED',
+            hint: 'Run the same destructive tool with dryRun=true to get a confirmationToken, then retry with that token.',
+            suggestedTool: toolName,
+        };
+    }
+    if (message.includes('confirmation token is invalid') || message.includes('confirmation token is expired')) {
+        return {
+            code: 'ERR_CONFIRMATION_INVALID',
+            hint: 'Regenerate the token by rerunning the same tool with dryRun=true, then retry promptly.',
+            suggestedTool: toolName,
+        };
+    }
+    if (message.includes('line') && (message.includes('does not exist') || message.includes('invalid line index'))) {
+        return {
+            code: 'ERR_INVALID_LINE_REFERENCE',
+            hint: 'Fetch valid line numbers first with noteplan_paragraphs.',
+            suggestedTool: 'noteplan_paragraphs',
+        };
+    }
+    if (message.includes('ambiguous')) {
+        return {
+            code: 'ERR_AMBIGUOUS_TARGET',
+            hint: 'Resolve the target first, then retry with the canonical identifier.',
+            suggestedTool: toolName.includes('folder') ? 'noteplan_folders' : 'noteplan_get_notes',
+        };
+    }
+    if (message.includes('not found') && toolName.includes('filter')) {
+        return {
+            code: 'ERR_NOT_FOUND',
+            hint: 'List filters first, then retry with an exact filter name.',
+            suggestedTool: 'noteplan_filters',
+        };
+    }
+    if (message.includes('not found')) {
+        if (toolName.includes('folder')) {
+            return {
+                code: 'ERR_NOT_FOUND',
+                hint: 'Resolve the folder first to a canonical path, then retry.',
+                suggestedTool: 'noteplan_folders',
+            };
+        }
+        return {
+            code: 'ERR_NOT_FOUND',
+            hint: 'Resolve the note first to a canonical ID/filename, then retry.',
+            suggestedTool: 'noteplan_get_notes',
+        };
+    }
+    if (message.includes('timed out') || message.includes('timeout')) {
+        return {
+            code: 'ERR_TIMEOUT',
+            hint: 'Try a narrower query or smaller range and retry.',
+            retryable: true,
+        };
+    }
+    return {
+        code: 'ERR_TOOL_EXECUTION',
+    };
+}
+function enrichErrorResult(result, toolName, registeredToolNames) {
+    if (!result || typeof result !== 'object')
+        return result;
+    const typed = result;
+    if (typed.success !== false)
+        return result;
+    if (typeof typed.error !== 'string')
+        return result;
+    const meta = inferToolErrorMeta(toolName, typed.error, registeredToolNames);
+    return {
+        ...typed,
+        code: typeof typed.code === 'string' ? typed.code : meta.code,
+        hint: typeof typed.hint === 'string' ? typed.hint : meta.hint,
+        suggestedTool: typeof typed.suggestedTool === 'string' ? typed.suggestedTool : meta.suggestedTool,
+        retryable: typeof typed.retryable === 'boolean' ? typed.retryable : meta.retryable,
+    };
+}
+function withSuggestedNextTools(result, toolName, availableToolNames) {
+    if (!result || typeof result !== 'object' || Array.isArray(result))
+        return result;
+    const typed = result;
+    if (typed.success !== true)
+        return result;
+    if (Array.isArray(typed.suggestedNextTools) && typed.suggestedNextTools.length > 0)
+        return result;
+    let suggestedNextTools = [];
+    switch (toolName) {
+        case 'noteplan_get_notes':
+            suggestedNextTools = ['noteplan_paragraphs', 'noteplan_edit_content'];
+            break;
+        case 'noteplan_paragraphs':
+            suggestedNextTools = ['noteplan_edit_content', 'noteplan_get_notes'];
+            break;
+        case 'noteplan_edit_content':
+            suggestedNextTools = ['noteplan_paragraphs', 'noteplan_get_notes'];
+            break;
+        case 'noteplan_search':
+            suggestedNextTools = ['noteplan_get_notes', 'noteplan_paragraphs'];
+            break;
+        case 'noteplan_manage_note':
+            suggestedNextTools = ['noteplan_get_notes'];
+            break;
+        case 'noteplan_folders':
+            suggestedNextTools = ['noteplan_manage_note', 'noteplan_get_notes'];
+            break;
+        case 'noteplan_filters':
+            suggestedNextTools = ['noteplan_paragraphs', 'noteplan_filters'];
+            break;
+        case 'noteplan_eventkit':
+            suggestedNextTools = ['noteplan_eventkit'];
+            break;
+        case 'noteplan_memory':
+            suggestedNextTools = ['noteplan_memory'];
+            break;
+        case 'noteplan_embeddings':
+            suggestedNextTools = ['noteplan_get_notes', 'noteplan_embeddings'];
+            break;
+        case 'noteplan_plugins':
+            suggestedNextTools = ['noteplan_plugins', 'noteplan_ui'];
+            break;
+        case 'noteplan_themes':
+            suggestedNextTools = ['noteplan_themes'];
+            break;
+        default:
+            suggestedNextTools = [];
+    }
+    const filtered = availableToolNames
+        ? suggestedNextTools.filter((t) => availableToolNames.has(t))
+        : suggestedNextTools;
+    if (filtered.length === 0)
+        return result;
+    return {
+        ...typed,
+        suggestedNextTools: filtered.slice(0, 3),
+    };
+}
+const MEMORY_HINT_TOOLS = new Set([
+    'noteplan_edit_content',
+    'noteplan_paragraphs',
+    'noteplan_manage_note',
+]);
+function withMemoryHints(result, toolName) {
+    if (!MEMORY_HINT_TOOLS.has(toolName))
+        return result;
+    if (!result || typeof result !== 'object' || Array.isArray(result))
+        return result;
+    const typed = result;
+    if (typed.success !== true)
+        return result;
+    try {
+        const count = memoryTools.getMemoryCount();
+        if (count === 0)
+            return result; // Skip hint noise when no memories stored
+        return {
+            ...typed,
+            memoryHints: {
+                storedMemories: count,
+                tip: `You have ${count} stored memory/memories. Consider checking noteplan_memory (action: list) before making formatting or style decisions.`,
+            },
+        };
+    }
+    catch {
+        return result;
+    }
+}
+function withDuration(result, durationMs, includeTiming) {
+    if (!includeTiming)
+        return result;
+    if (result && typeof result === 'object' && !Array.isArray(result)) {
+        return {
+            ...result,
+            durationMs,
+        };
+    }
+    return {
+        success: true,
+        data: result,
+        durationMs,
+    };
+}
+// Create the server
+export function createServer() {
+    const server = new Server({
+        name: 'noteplan-mcp',
+        version: '1.0.0',
+    }, {
+        capabilities: {
+            tools: {},
+            resources: {},
+        },
+    });
+    const embeddingsToolsEnabled = embeddingsTools.areEmbeddingsToolsEnabled();
+    const versionInfo = getNotePlanVersion();
+    const advancedFeaturesEnabled = versionInfo.build >= MIN_BUILD_ADVANCED_FEATURES;
+    console.error(`[noteplan-mcp] Detected NotePlan ${versionInfo.version} (build ${versionInfo.build}, source: ${versionInfo.source}). Advanced features: ${advancedFeaturesEnabled ? 'enabled' : 'disabled'}.`);
+    const toolDefinitions = [
+        // ── Consolidated tools (16 — action/param-based dispatch) ──
+        {
+            name: 'noteplan_get_notes',
+            description: 'Unified note retrieval: get a single note, list notes, resolve references, fetch today/calendar/periodic notes, date ranges, or folder contents.\n\nRouting:\n- resolve=true + resolveQuery → resolve a note reference to canonical target\n- id/title/filename → get single note (metadata + optional content)\n- period + count → recent periodic notes (e.g., last 6 weekly notes)\n- period (no count) → single periodic note (week/month/quarter/year)\n- rangePeriod or startDate+endDate → daily notes in date range\n- folder (no id/title/filename/date) → notes in folder\n- date → calendar note for that date (use "today" for today\'s note)\n- fallback (no params) → list notes with optional filters',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    // Single note params
+                    id: {
+                        type: 'string',
+                        description: 'Note ID (BEST for space notes — get from search results)',
+                    },
+                    title: {
+                        type: 'string',
+                        description: 'Note title to search for',
+                    },
+                    filename: {
+                        type: 'string',
+                        description: 'Direct filename/path (for local notes only)',
+                    },
+                    date: {
+                        type: 'string',
+                        description: 'Date for calendar notes (YYYYMMDD, YYYY-MM-DD, today, tomorrow, yesterday)',
+                    },
+                    space: {
+                        type: 'string',
+                        description: 'Space name or ID scope',
+                    },
+                    includeContent: {
+                        type: 'boolean',
+                        description: 'Include note body content (default: false)',
+                    },
+                    startLine: {
+                        type: 'number',
+                        description: 'First line when includeContent=true (1-indexed)',
+                    },
+                    endLine: {
+                        type: 'number',
+                        description: 'Last line when includeContent=true (1-indexed)',
+                    },
+                    previewChars: {
+                        type: 'number',
+                        description: 'Preview length when includeContent=false (default: 280)',
+                    },
+                    // Resolve params
+                    resolve: {
+                        type: 'boolean',
+                        description: 'Enable resolve mode: find canonical note from a fuzzy reference',
+                    },
+                    resolveQuery: {
+                        type: 'string',
+                        description: 'Note reference to resolve (ID, title, filename, or date token)',
+                    },
+                    minScore: {
+                        type: 'number',
+                        description: 'Minimum score for auto-resolution (default: 0.88)',
+                    },
+                    ambiguityDelta: {
+                        type: 'number',
+                        description: 'If top scores are within this delta, treat as ambiguous (default: 0.06)',
+                    },
+                    // Periodic note params
+                    period: {
+                        type: 'string',
+                        enum: ['week', 'month', 'quarter', 'year'],
+                        description: 'Periodic note type. With count → recent sequence; without → single period',
+                    },
+                    count: {
+                        type: 'number',
+                        description: 'Number of recent periodic notes to return (triggers multi-note mode)',
+                    },
+                    fromDate: {
+                        type: 'string',
+                        description: 'Reference date for periodic notes (YYYY-MM-DD, default: today)',
+                    },
+                    includeMissing: {
+                        type: 'boolean',
+                        description: 'Include missing period slots in response (default: false)',
+                    },
+                    maxLookback: {
+                        type: 'number',
+                        description: 'Maximum period slots to inspect (default: 52, max: 260)',
+                    },
+                    week: {
+                        type: 'number',
+                        description: 'Week number 1-53 (for single periodic note with period=week)',
+                    },
+                    month: {
+                        type: 'number',
+                        description: 'Month number 1-12 (for single periodic note with period=month)',
+                    },
+                    quarter: {
+                        type: 'number',
+                        description: 'Quarter 1-4 (for single periodic note with period=quarter)',
+                    },
+                    year: {
+                        type: 'number',
+                        description: 'Year (e.g., 2025). Defaults to current year.',
+                    },
+                    // Date range params
+                    rangePeriod: {
+                        type: 'string',
+                        enum: ['today', 'yesterday', 'this-week', 'last-week', 'this-month', 'last-month', 'custom'],
+                        description: 'Predefined date range period or "custom" with startDate/endDate',
+                    },
+                    startDate: {
+                        type: 'string',
+                        description: 'Start date for custom range (YYYY-MM-DD)',
+                    },
+                    endDate: {
+                        type: 'string',
+                        description: 'End date for custom range (YYYY-MM-DD)',
+                    },
+                    maxDays: {
+                        type: 'number',
+                        description: 'Maximum days to scan for date range (default: 90, max: 366)',
+                    },
+                    // List/folder params
+                    folder: {
+                        type: 'string',
+                        description: 'Folder path filter (e.g., "20 - Areas" or "Notes/20 - Areas")',
+                    },
+                    types: {
+                        type: 'array',
+                        items: { type: 'string', enum: ['calendar', 'note', 'trash'] },
+                        description: 'Filter by note types',
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Filter by title/filename/folder substring (list mode) or resolve query',
+                    },
+                    // Pagination
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum results to return',
+                    },
+                    offset: {
+                        type: 'number',
+                        description: 'Pagination offset (default: 0)',
+                    },
+                    cursor: {
+                        type: 'string',
+                        description: 'Cursor token from previous page (preferred over offset)',
+                    },
+                },
+            },
+        },
+        {
+            name: 'noteplan_manage_note',
+            description: 'Manage notes: create, update, delete, move, restore, rename, or manage frontmatter properties.\n\nActions:\n- create: Create a project note (requires title)\n- update: Replace note content (requires filename, content, fullReplace + confirmationToken)\n- delete/move/restore/rename: Lifecycle ops (requires id or filename + dryRun/confirmationToken)\n- set_property/remove_property: Frontmatter (requires filename + key)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['create', 'update', 'delete', 'move', 'restore', 'rename', 'set_property', 'remove_property'],
+                        description: 'Action to perform',
+                    },
+                    id: {
+                        type: 'string',
+                        description: 'Note ID — used by delete, move, rename, restore (preferred for TeamSpace notes)',
+                    },
+                    filename: {
+                        type: 'string',
+                        description: 'Filename/path — used by update, delete, move, rename, restore, set_property, remove_property',
+                    },
+                    title: {
+                        type: 'string',
+                        description: 'Note title — required for create',
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'Note content — used by create (initial content) and update (replacement content)',
+                    },
+                    folder: {
+                        type: 'string',
+                        description: 'Folder path — used by create (smart matching built in)',
+                    },
+                    create_new_folder: {
+                        type: 'boolean',
+                        description: 'Bypass smart matching and create exact folder name — used by create',
+                    },
+                    space: {
+                        type: 'string',
+                        description: 'Space name or ID scope',
+                    },
+                    fullReplace: {
+                        type: 'boolean',
+                        description: 'Required safety confirmation for whole-note rewrite — used by update',
+                    },
+                    dryRun: {
+                        type: 'boolean',
+                        description: 'Preview impact and get confirmationToken — used by update, delete, move, rename, restore',
+                    },
+                    confirmationToken: {
+                        type: 'string',
+                        description: 'Token from dryRun for execution — used by update, delete, move, rename, restore',
+                    },
+                    allowEmptyContent: {
+                        type: 'boolean',
+                        description: 'Allow empty content — used by update',
+                    },
+                    destinationFolder: {
+                        type: 'string',
+                        description: 'Target folder — used by move, restore',
+                    },
+                    newFilename: {
+                        type: 'string',
+                        description: 'New filename for local notes — used by rename',
+                    },
+                    newTitle: {
+                        type: 'string',
+                        description: 'New title for TeamSpace notes — used by rename',
+                    },
+                    keepExtension: {
+                        type: 'boolean',
+                        description: 'Keep current extension on rename (default: true) — used by rename',
+                    },
+                    key: {
+                        type: 'string',
+                        description: 'Property key — used by set_property, remove_property',
+                    },
+                    value: {
+                        type: 'string',
+                        description: 'Property value — used by set_property',
+                    },
+                },
+                required: ['action'],
+            },
+        },
+        {
+            name: 'noteplan_edit_content',
+            description: 'Edit note content: insert, append, delete lines, edit a line, or replace a range of lines.\n\nActions:\n- insert: Insert at position (start/end/after-heading/in-section/at-line)\n- append: Append to end (shorthand for insert at end). Use date="today" to append to today\'s daily note (replaces noteplan_add_to_today).\n- delete_lines: Delete line range (requires startLine, endLine + dryRun/confirmationToken)\n- edit_line: Edit one line (requires line + content)\n- replace_lines: Replace line range (requires startLine, endLine, content + dryRun/confirmationToken)\n\nTarget note via id, filename, title, date, or query. Calendar notes (date param) are auto-created if they don\'t exist yet — no need to create them first. Always use tab characters for indentation.\n\nNotePlan syntax: Tasks use "- [ ] text" (open), "- [x]" (done), "- [-]" (cancelled), "- [>]" (scheduled). The task marker (*/- with or without checkbox) follows user settings — prefer noteplan_paragraphs(action=add) for auto-formatted tasks. Schedule tasks to dates with >YYYY-MM-DD. Link to notes with [[Note Name]]. Never add block IDs (^id) — only the NotePlan app creates these.\n\nUse scheduleDate to auto-append >YYYY-MM-DD scheduling to content.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['insert', 'append', 'delete_lines', 'edit_line', 'replace_lines'],
+                        description: 'Action to perform',
+                    },
+                    id: {
+                        type: 'string',
+                        description: 'Note ID (preferred for space notes)',
+                    },
+                    filename: {
+                        type: 'string',
+                        description: 'Filename/path of the note',
+                    },
+                    title: {
+                        type: 'string',
+                        description: 'Note title target',
+                    },
+                    date: {
+                        type: 'string',
+                        description: 'Calendar note date (auto-creates if missing)',
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Fuzzy note query',
+                    },
+                    space: {
+                        type: 'string',
+                        description: 'Space name or ID scope',
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'Content to insert/append/replace, or new line content for edit_line',
+                    },
+                    position: {
+                        type: 'string',
+                        enum: ['start', 'end', 'after-heading', 'at-line', 'in-section'],
+                        description: 'Where to insert: start (after frontmatter), end, after-heading (right after heading/marker line), in-section (at end of section, before next heading/marker), or at-line — used by insert',
+                    },
+                    heading: {
+                        type: 'string',
+                        description: 'Heading or section marker text (required for after-heading and in-section; matches both ## headings and **bold:** section markers) — used by insert',
+                    },
+                    line: {
+                        type: 'number',
+                        description: 'Line number (1-indexed) — used by insert (at-line) and edit_line',
+                    },
+                    startLine: {
+                        type: 'number',
+                        description: 'First line (1-indexed) — used by delete_lines, replace_lines',
+                    },
+                    endLine: {
+                        type: 'number',
+                        description: 'Last line (1-indexed) — used by delete_lines, replace_lines',
+                    },
+                    indentationStyle: {
+                        type: 'string',
+                        enum: ['tabs', 'preserve'],
+                        description: 'Indentation normalization (default: tabs) — used by insert, append, edit_line, replace_lines',
+                    },
+                    type: {
+                        type: 'string',
+                        enum: ['title', 'heading', 'task', 'checklist', 'bullet', 'quote', 'separator', 'empty', 'text'],
+                        description: 'Paragraph type for auto-formatting — used by insert',
+                    },
+                    taskStatus: {
+                        type: 'string',
+                        enum: ['open', 'done', 'cancelled', 'scheduled'],
+                        description: 'Task status (default: open) — used by insert with type=task/checklist',
+                    },
+                    headingLevel: {
+                        type: 'number',
+                        description: 'Heading level 1-6 — used by insert with type=heading/title',
+                    },
+                    priority: {
+                        type: 'number',
+                        description: 'Priority 1-3 — used by insert with type=task/checklist',
+                    },
+                    indentLevel: {
+                        type: 'number',
+                        description: 'Tab indent level — used by insert with type=task/checklist/bullet',
+                    },
+                    dryRun: {
+                        type: 'boolean',
+                        description: 'Preview impact and get confirmationToken — used by delete_lines, replace_lines',
+                    },
+                    confirmationToken: {
+                        type: 'string',
+                        description: 'Token from dryRun — used by delete_lines, replace_lines',
+                    },
+                    allowEmptyContent: {
+                        type: 'boolean',
+                        description: 'Allow empty content — used by edit_line, replace_lines',
+                    },
+                    scheduleDate: {
+                        type: 'string',
+                        description: 'Auto-append >YYYY-MM-DD scheduling date to content. Accepts: YYYY-MM-DD, YYYYMMDD, today, tomorrow, yesterday.',
+                    },
+                },
+                required: ['action'],
+            },
+        },
+        {
+            name: 'noteplan_paragraphs',
+            description: 'Paragraph and task operations on notes.\n\nParagraph actions:\n- get: Get note lines with metadata (requires filename). Returns line, lineIndex, content, type, etc.\n- search: Search for matching lines in a note (requires query + note ref via id/filename/title/date)\n\nTask actions:\n- search_global: Search tasks across all notes (requires query, supports "*" wildcard)\n- add: Add a task (requires target + content). Task marker format auto-matches user settings. Use scheduleDate to auto-append >YYYY-MM-DD scheduling to content, [[Note Name]] to link, #tag for tags, @person for mentions.\n- complete: Mark task done (requires filename + lineIndex or line)\n- update: Update task content/status (requires filename + lineIndex or line)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['get', 'search', 'search_global', 'add', 'complete', 'update'],
+                        description: 'Action to perform',
+                    },
+                    id: {
+                        type: 'string',
+                        description: 'Note ID — used by search',
+                    },
+                    filename: {
+                        type: 'string',
+                        description: 'Filename/path of the note',
+                    },
+                    title: {
+                        type: 'string',
+                        description: 'Note title — used by search',
+                    },
+                    date: {
+                        type: 'string',
+                        description: 'Calendar date — used by search',
+                    },
+                    space: {
+                        type: 'string',
+                        description: 'Space name or ID scope',
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Search text — required for search, search_global. Use "*" for wildcard in search_global.',
+                    },
+                    caseSensitive: {
+                        type: 'boolean',
+                        description: 'Case-sensitive match — used by search, search_global',
+                    },
+                    wholeWord: {
+                        type: 'boolean',
+                        description: 'Whole-word match — used by search, search_global',
+                    },
+                    startLine: {
+                        type: 'number',
+                        description: 'First line (1-indexed) — used by get',
+                    },
+                    endLine: {
+                        type: 'number',
+                        description: 'Last line (1-indexed) — used by get',
+                    },
+                    contextLines: {
+                        type: 'number',
+                        description: 'Context lines around matches — used by search',
+                    },
+                    paragraphMaxChars: {
+                        type: 'number',
+                        description: 'Max paragraph chars per match — used by search',
+                    },
+                    // Task-specific params
+                    status: {
+                        type: 'string',
+                        enum: ['open', 'done', 'cancelled', 'scheduled'],
+                        description: 'Filter by or set task status — used by search_global, update',
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'Task content — used by add, update (without marker prefix)',
+                    },
+                    target: {
+                        type: 'string',
+                        description: 'Target for add: date (today/tomorrow/YYYY-MM-DD) for daily notes or filename for project notes',
+                    },
+                    position: {
+                        type: 'string',
+                        enum: ['start', 'end', 'after-heading', 'in-section'],
+                        description: 'Where to add task (default: end) — used by add',
+                    },
+                    heading: {
+                        type: 'string',
+                        description: 'Heading or section marker text (matches both ## headings and **bold:** section markers) — used by add',
+                    },
+                    lineIndex: {
+                        type: 'number',
+                        description: 'Task line index (0-based) — used by complete, update',
+                    },
+                    line: {
+                        type: 'number',
+                        description: 'Task line number (1-based) — used by complete, update',
+                    },
+                    priority: {
+                        type: 'number',
+                        description: 'Priority 1-3 — used by add',
+                    },
+                    indentLevel: {
+                        type: 'number',
+                        description: 'Tab indent level — used by add',
+                    },
+                    allowEmptyContent: {
+                        type: 'boolean',
+                        description: 'Allow empty task content — used by update',
+                    },
+                    folder: {
+                        type: 'string',
+                        description: 'Folder filter — used by search_global',
+                    },
+                    noteQuery: {
+                        type: 'string',
+                        description: 'Filter candidate notes — used by search_global',
+                    },
+                    noteTypes: {
+                        type: 'array',
+                        items: { type: 'string', enum: ['calendar', 'note', 'trash'] },
+                        description: 'Note type filter — used by search_global',
+                    },
+                    preferCalendar: {
+                        type: 'boolean',
+                        description: 'Prioritize calendar notes — used by search_global',
+                    },
+                    periodicOnly: {
+                        type: 'boolean',
+                        description: 'Only periodic calendar notes — used by search_global',
+                    },
+                    maxNotes: {
+                        type: 'number',
+                        description: 'Max notes to scan — used by search_global',
+                    },
+                    scheduleDate: {
+                        type: 'string',
+                        description: 'Auto-append >YYYY-MM-DD scheduling date to content. Accepts: YYYY-MM-DD, YYYYMMDD, today, tomorrow, yesterday.',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Max results to return',
+                    },
+                    offset: {
+                        type: 'number',
+                        description: 'Pagination offset',
+                    },
+                    cursor: {
+                        type: 'string',
+                        description: 'Cursor from previous page',
+                    },
+                },
+                required: ['action'],
+            },
+        },
+        {
+            name: 'noteplan_folders',
+            description: 'Folder and space operations: list, find, resolve, create, move, rename, delete folders, or list spaces.\n\nActions:\n- list: List folders with optional filtering\n- find: Find folder matches for exploration\n- resolve: Resolve to one canonical folder path\n- create: Create a folder (local: path, TeamSpace: space + name)\n- move: Move a folder (requires dryRun/confirmationToken)\n- rename: Rename a folder (requires dryRun/confirmationToken)\n- delete: Delete folder to trash (requires dryRun/confirmationToken)\n- list_spaces: List spaces/workspaces with optional filtering',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['list', 'find', 'resolve', 'create', 'move', 'rename', 'delete', 'list_spaces'],
+                        description: 'Action to perform',
+                    },
+                    path: {
+                        type: 'string',
+                        description: 'Local folder path — used by create, delete',
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Search query — used by list, find, resolve',
+                    },
+                    space: {
+                        type: 'string',
+                        description: 'Space name or ID scope',
+                    },
+                    name: {
+                        type: 'string',
+                        description: 'Folder name — used by create (TeamSpace)',
+                    },
+                    parent: {
+                        type: 'string',
+                        description: 'Parent folder ref — used by create (TeamSpace)',
+                    },
+                    parentPath: {
+                        type: 'string',
+                        description: 'Parent folder path — used by list',
+                    },
+                    recursive: {
+                        type: 'boolean',
+                        description: 'Include descendants — used by list',
+                    },
+                    includeLocal: {
+                        type: 'boolean',
+                        description: 'Include local folders — used by list, find, resolve',
+                    },
+                    includeSpaces: {
+                        type: 'boolean',
+                        description: 'Include space folders — used by list, find, resolve',
+                    },
+                    maxDepth: {
+                        type: 'number',
+                        description: 'Max folder depth — used by list, find, resolve',
+                    },
+                    sourcePath: {
+                        type: 'string',
+                        description: 'Local source folder path — used by move, rename',
+                    },
+                    source: {
+                        type: 'string',
+                        description: 'TeamSpace source ref — used by move, rename, delete',
+                    },
+                    destinationFolder: {
+                        type: 'string',
+                        description: 'Local destination folder — used by move',
+                    },
+                    destination: {
+                        type: 'string',
+                        description: 'TeamSpace destination ref — used by move',
+                    },
+                    newName: {
+                        type: 'string',
+                        description: 'New folder name — used by rename',
+                    },
+                    minScore: {
+                        type: 'number',
+                        description: 'Min auto-resolve score — used by resolve',
+                    },
+                    ambiguityDelta: {
+                        type: 'number',
+                        description: 'Ambiguity delta — used by resolve',
+                    },
+                    dryRun: {
+                        type: 'boolean',
+                        description: 'Preview impact — used by move, rename, delete',
+                    },
+                    confirmationToken: {
+                        type: 'string',
+                        description: 'Token from dryRun — used by move, rename, delete',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Max results to return',
+                    },
+                    offset: {
+                        type: 'number',
+                        description: 'Pagination offset',
+                    },
+                    cursor: {
+                        type: 'string',
+                        description: 'Cursor from previous page',
+                    },
+                },
+                required: ['action'],
+            },
+        },
+        {
+            name: 'noteplan_filters',
+            description: 'Saved filter operations: list, get, get_tasks, list_parameters, save, rename.\n\nActions:\n- list: List saved filters\n- get: Get one filter with parsed params (requires name)\n- get_tasks: Execute a filter against tasks (requires name)\n- list_parameters: List supported filter parameter keys\n- save: Create or update a filter (requires name + items)\n- rename: Rename a filter (requires oldName + newName)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['list', 'get', 'get_tasks', 'list_parameters', 'save', 'rename'],
+                        description: 'Action to perform',
+                    },
+                    name: {
+                        type: 'string',
+                        description: 'Filter name — used by get, get_tasks, save',
+                    },
+                    oldName: {
+                        type: 'string',
+                        description: 'Current filter name — used by rename',
+                    },
+                    newName: {
+                        type: 'string',
+                        description: 'New filter name — used by rename',
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Filter names by substring — used by list',
+                    },
+                    overwrite: {
+                        type: 'boolean',
+                        description: 'Overwrite existing — used by save, rename',
+                    },
+                    items: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                param: { type: 'string', description: 'Filter parameter key' },
+                                value: {
+                                    oneOf: [
+                                        { type: 'string' },
+                                        { type: 'boolean' },
+                                        { type: 'number' },
+                                        { type: 'array', items: { type: 'string' } },
+                                    ],
+                                    description: 'Filter parameter value',
+                                },
+                                display: { type: 'boolean', description: 'UI display flag' },
+                            },
+                            required: ['param', 'value'],
+                        },
+                        description: 'Filter items — used by save',
+                    },
+                    maxNotes: {
+                        type: 'number',
+                        description: 'Max notes to scan — used by get_tasks',
+                    },
+                    space: {
+                        type: 'string',
+                        description: 'Space ID scope — used by get_tasks',
+                    },
+                    folder: {
+                        type: 'string',
+                        description: 'Folder scope — used by get_tasks',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Max results to return',
+                    },
+                    offset: {
+                        type: 'number',
+                        description: 'Pagination offset',
+                    },
+                    cursor: {
+                        type: 'string',
+                        description: 'Cursor from previous page',
+                    },
+                },
+                required: ['action'],
+            },
+        },
+        {
+            name: 'noteplan_eventkit',
+            description: 'macOS Calendar and Reminders operations.\n\nCalendar actions (source="calendar"):\n- get_events: Get events for a date/range\n- list_calendars: List all calendars\n- create_event: Create event (requires title + startDate)\n- update_event: Update event (requires eventId)\n- delete_event: Delete event (requires eventId + dryRun/confirmationToken)\n\nReminder actions (source="reminders"):\n- get: Get reminders (optional list/query filter)\n- list_lists: List reminder lists\n- create: Create reminder (requires title)\n- complete: Mark reminder done (requires reminderId)\n- update: Update reminder (requires reminderId)\n- delete: Delete reminder (requires reminderId + dryRun/confirmationToken)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    source: {
+                        type: 'string',
+                        enum: ['calendar', 'reminders'],
+                        description: 'EventKit source: "calendar" for Calendar.app, "reminders" for Reminders.app',
+                    },
+                    action: {
+                        type: 'string',
+                        enum: ['get_events', 'list_calendars', 'create_event', 'update_event', 'delete_event', 'get', 'list_lists', 'create', 'complete', 'update', 'delete'],
+                        description: 'Action to perform',
+                    },
+                    // Calendar params
+                    eventId: {
+                        type: 'string',
+                        description: 'Event ID — calendar: update_event, delete_event',
+                    },
+                    date: {
+                        type: 'string',
+                        description: 'Date (YYYY-MM-DD, "today", "tomorrow") — calendar: get_events',
+                    },
+                    days: {
+                        type: 'number',
+                        description: 'Days to fetch — calendar: get_events',
+                    },
+                    startDate: {
+                        type: 'string',
+                        description: 'Start date/time — calendar: create_event, update_event',
+                    },
+                    endDate: {
+                        type: 'string',
+                        description: 'End date/time — calendar: create_event, update_event',
+                    },
+                    calendar: {
+                        type: 'string',
+                        description: 'Calendar name — calendar: get_events, create_event',
+                    },
+                    location: {
+                        type: 'string',
+                        description: 'Event location — calendar: create_event, update_event',
+                    },
+                    allDay: {
+                        type: 'boolean',
+                        description: 'All-day event — calendar: create_event',
+                    },
+                    // Reminders params
+                    reminderId: {
+                        type: 'string',
+                        description: 'Reminder ID — reminders: complete, update, delete',
+                    },
+                    list: {
+                        type: 'string',
+                        description: 'Reminder list name — reminders: get, create',
+                    },
+                    dueDate: {
+                        type: 'string',
+                        description: 'Due date — reminders: create, update',
+                    },
+                    priority: {
+                        type: 'number',
+                        description: 'Priority: 0 (none), 1 (high), 5 (medium), 9 (low) — reminders: create, update',
+                    },
+                    includeCompleted: {
+                        type: 'boolean',
+                        description: 'Include completed — reminders: get',
+                    },
+                    // Shared params
+                    title: {
+                        type: 'string',
+                        description: 'Title — calendar: create_event, update_event; reminders: create, update',
+                    },
+                    notes: {
+                        type: 'string',
+                        description: 'Notes — calendar: create_event, update_event; reminders: create, update',
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Filter by substring — reminders: get, list_lists',
+                    },
+                    dryRun: {
+                        type: 'boolean',
+                        description: 'Preview impact — calendar: delete_event; reminders: delete',
+                    },
+                    confirmationToken: {
+                        type: 'string',
+                        description: 'Token from dryRun — calendar: delete_event; reminders: delete',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Max results to return',
+                    },
+                    offset: {
+                        type: 'number',
+                        description: 'Pagination offset',
+                    },
+                    cursor: {
+                        type: 'string',
+                        description: 'Cursor from previous page',
+                    },
+                },
+                required: ['source', 'action'],
+            },
+        },
+        {
+            name: 'noteplan_memory',
+            description: 'User preference memory operations.\n\nActions:\n- list: List/search stored memories\n- save: Save a new memory (requires content)\n- update: Update memory content/tags (requires id)\n- delete: Delete a memory (requires id)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['list', 'save', 'update', 'delete'],
+                        description: 'Action to perform',
+                    },
+                    id: {
+                        type: 'string',
+                        description: 'Memory ID — used by update, delete',
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'Memory content — used by save, update',
+                        minLength: 1,
+                        maxLength: 2000,
+                    },
+                    tags: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        maxItems: 10,
+                        description: 'Tags — used by save, update. Suggested: style, formatting, workflow, correction, naming, structure, preference',
+                    },
+                    tag: {
+                        type: 'string',
+                        description: 'Filter by tag — used by list',
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Search content — used by list',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Max results — used by list',
+                    },
+                    offset: {
+                        type: 'number',
+                        description: 'Pagination offset — used by list',
+                    },
+                },
+                required: ['action'],
+            },
+        },
+        {
+            name: 'noteplan_search',
+            description: 'Search across notes or list tags.\n\nActions:\n- search (default): Full-text or metadata search across notes. Use searchField, queryMode, propertyFilters, etc.\n- list_tags: List all tags/hashtags with optional filtering.\n\nSearch: discover notes by content/keywords/phrases and optional frontmatter property filters (e.g. {"category":"marketing"}). Use queryMode=smart/any/all for multi-word token matching, and query="*" for browse mode. Folder filters accept canonical paths from noteplan_folders (action: list/resolve), with or without "Notes/" prefix.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['search', 'list_tags'],
+                        description: 'Action to perform (default: search)',
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Search query (required for search). Supports OR patterns like "meeting|standup". For list_tags, filters tags by substring.',
+                    },
+                    space: {
+                        type: 'string',
+                        description: 'Space name or ID — used by search, list_tags',
+                    },
+                    searchField: {
+                        type: 'string',
+                        enum: ['content', 'title', 'filename', 'title_or_filename'],
+                        description: 'Search scope. Use "title" or "title_or_filename" for fast note discovery by version/name. Default: content',
+                    },
+                    queryMode: {
+                        type: 'string',
+                        enum: ['phrase', 'smart', 'any', 'all'],
+                        description: 'Multi-word behavior for content search: phrase (exact phrase), smart (token OR + relevance threshold), any (any token), all (all tokens). Default: smart',
+                    },
+                    minTokenMatches: {
+                        type: 'number',
+                        description: 'When queryMode is smart/any/all, minimum token matches required per note (auto by default)',
+                    },
+                    types: {
+                        type: 'array',
+                        items: { type: 'string', enum: ['calendar', 'note', 'trash'] },
+                        description: 'Filter by note types',
+                    },
+                    folders: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Filter by folders (canonical path, e.g. "20 - Areas"; "Notes/20 - Areas" is also accepted). If multiple folders are provided, the first is used for full-text scope.',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of results (default: 20, max: 200)',
+                    },
+                    fuzzy: {
+                        type: 'boolean',
+                        description: 'Enable fuzzy/typo-tolerant matching (default: false)',
+                    },
+                    caseSensitive: {
+                        type: 'boolean',
+                        description: 'Case-sensitive search (default: false)',
+                    },
+                    contextLines: {
+                        type: 'number',
+                        description: 'Lines of context around matches (0-5, default: 0)',
+                    },
+                    propertyFilters: {
+                        type: 'object',
+                        additionalProperties: { type: 'string' },
+                        description: 'Exact frontmatter property filters (all must match), e.g. {"category":"marketing"}',
+                    },
+                    propertyCaseSensitive: {
+                        type: 'boolean',
+                        description: 'Case-sensitive frontmatter property matching (default: false)',
+                    },
+                    modifiedAfter: {
+                        type: 'string',
+                        description: 'Filter notes modified after date (ISO date or "today", "yesterday", "this week", "this month")',
+                    },
+                    modifiedBefore: {
+                        type: 'string',
+                        description: 'Filter notes modified before date',
+                    },
+                    createdAfter: {
+                        type: 'string',
+                        description: 'Filter notes created after date',
+                    },
+                    createdBefore: {
+                        type: 'string',
+                        description: 'Filter notes created before date',
+                    },
+                },
+            },
+        },
+    ];
+    if (embeddingsToolsEnabled) {
+        toolDefinitions.push({
+            name: 'noteplan_embeddings',
+            description: 'Embeddings/vector search operations.\n\nActions:\n- status: Get embeddings config and index status\n- search: Semantic search over index (requires query)\n- sync: Build/refresh embeddings index\n- reset: Delete index rows (requires dryRun/confirmationToken)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['status', 'search', 'sync', 'reset'],
+                        description: 'Action to perform',
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Search query text — used by search',
+                    },
+                    space: {
+                        type: 'string',
+                        description: 'Space name or ID scope',
+                    },
+                    types: {
+                        type: 'array',
+                        items: { type: 'string', enum: ['calendar', 'note', 'trash'] },
+                        description: 'Note type filter — used by search, sync',
+                    },
+                    source: {
+                        type: 'string',
+                        enum: ['local', 'space'],
+                        description: 'Source filter — used by search',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Max results — used by search, sync',
+                    },
+                    offset: {
+                        type: 'number',
+                        description: 'Pagination offset — used by sync',
+                    },
+                    minScore: {
+                        type: 'number',
+                        description: 'Min cosine similarity — used by search',
+                    },
+                    includeText: {
+                        type: 'boolean',
+                        description: 'Include full chunk text — used by search',
+                    },
+                    previewChars: {
+                        type: 'number',
+                        description: 'Preview length — used by search',
+                    },
+                    maxChunks: {
+                        type: 'number',
+                        description: 'Max chunks to scan — used by search',
+                    },
+                    noteQuery: {
+                        type: 'string',
+                        description: 'Note filter substring — used by sync',
+                    },
+                    forceReembed: {
+                        type: 'boolean',
+                        description: 'Force recompute — used by sync',
+                    },
+                    pruneMissing: {
+                        type: 'boolean',
+                        description: 'Remove stale rows — used by sync',
+                    },
+                    batchSize: {
+                        type: 'number',
+                        description: 'API batch size — used by sync',
+                    },
+                    maxChunksPerNote: {
+                        type: 'number',
+                        description: 'Max chunks per note — used by sync',
+                    },
+                    dryRun: {
+                        type: 'boolean',
+                        description: 'Preview impact — used by reset',
+                    },
+                    confirmationToken: {
+                        type: 'string',
+                        description: 'Token from dryRun — used by reset',
+                    },
+                },
+                required: ['action'],
+            },
+        });
+    }
+    if (advancedFeaturesEnabled) {
+        toolDefinitions.push({
+            name: 'noteplan_ui',
+            description: 'NotePlan UI control via AppleScript.\n\nActions:\n- open_note: Open a note (title or filename)\n- open_today: Open today\'s note\n- search: Search in UI\n- run_plugin: Run a plugin command (requires pluginId + command)\n- open_view: Open a named view\n- toggle_sidebar: Toggle sidebar visibility\n- close_plugin_window: Close plugin window (by windowID/title, or omit both to close all)\n- list_plugin_windows: List open plugin windows',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['open_note', 'open_today', 'search', 'run_plugin', 'open_view', 'toggle_sidebar', 'close_plugin_window', 'list_plugin_windows'],
+                        description: 'Action to perform',
+                    },
+                    title: {
+                        type: 'string',
+                        description: 'Note title — used by open_note; window title — used by close_plugin_window',
+                    },
+                    filename: {
+                        type: 'string',
+                        description: 'Filename — used by open_note',
+                    },
+                    inNewWindow: {
+                        type: 'boolean',
+                        description: 'Open in new window — used by open_note',
+                    },
+                    inSplitView: {
+                        type: 'boolean',
+                        description: 'Open in split view — used by open_note',
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Search text — used by search',
+                    },
+                    pluginId: {
+                        type: 'string',
+                        description: 'Plugin ID — used by run_plugin',
+                    },
+                    command: {
+                        type: 'string',
+                        description: 'Command name — used by run_plugin',
+                    },
+                    arguments: {
+                        type: 'string',
+                        description: 'JSON arguments string — used by run_plugin',
+                    },
+                    name: {
+                        type: 'string',
+                        description: 'View name — used by open_view',
+                    },
+                    windowID: {
+                        type: 'string',
+                        description: 'Window ID — used by close_plugin_window',
+                    },
+                },
+                required: ['action'],
+            },
+        }, {
+            name: 'noteplan_plugins',
+            description: 'Plugin management: list, create, delete, install, read source/log, update HTML, screenshot.\n\nActions:\n- list: List installed plugins\n- list_available: List plugins from online repository\n- create: Create plugin with HTML view (requires pluginId, pluginName, commandName, html)\n- delete: Delete plugin (requires pluginId + confirmationToken)\n- install: Install from repository (requires pluginId)\n- log: Read plugin console log (requires pluginId)\n- source: Read plugin source (requires pluginId)\n- update_html: Apply find/replace patches (requires pluginId + patches)\n- screenshot: Capture plugin WebView screenshot (requires pluginId)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['list', 'list_available', 'create', 'delete', 'install', 'log', 'source', 'update_html', 'screenshot'],
+                        description: 'Action to perform',
+                    },
+                    pluginId: {
+                        type: 'string',
+                        description: 'Plugin ID — used by create, delete, install, log, source, update_html, screenshot',
+                    },
+                    pluginName: {
+                        type: 'string',
+                        description: 'Display name — used by create',
+                    },
+                    commandName: {
+                        type: 'string',
+                        description: 'Command name — used by create',
+                    },
+                    html: {
+                        type: 'string',
+                        description: 'HTML content — used by create',
+                    },
+                    icon: {
+                        type: 'string',
+                        description: 'Font Awesome icon name — used by create',
+                    },
+                    iconColor: {
+                        type: 'string',
+                        description: 'Tailwind color — used by create',
+                    },
+                    displayMode: {
+                        type: 'string',
+                        enum: ['main', 'split', 'window'],
+                        description: 'Display mode (default: main) — used by create',
+                    },
+                    autoLaunch: {
+                        type: 'boolean',
+                        description: 'Auto-reload and run — used by create, update_html',
+                    },
+                    patches: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                find: { type: 'string' },
+                                replace: { type: 'string' },
+                            },
+                            required: ['find', 'replace'],
+                        },
+                        description: 'Find/replace patches — used by update_html',
+                    },
+                    query: {
+                        type: 'string',
+                        description: 'Filter/search — used by list, list_available, source',
+                    },
+                    includeBeta: {
+                        type: 'boolean',
+                        description: 'Include beta plugins — used by list_available',
+                    },
+                    tail: {
+                        type: 'integer',
+                        description: 'Return last N lines — used by log',
+                    },
+                    clear: {
+                        type: 'boolean',
+                        description: 'Clear log after reading — used by log',
+                    },
+                    startLine: {
+                        type: 'integer',
+                        description: 'Start line (1-based) — used by source',
+                    },
+                    endLine: {
+                        type: 'integer',
+                        description: 'End line (1-based) — used by source',
+                    },
+                    contextLines: {
+                        type: 'integer',
+                        description: 'Context lines around matches — used by source',
+                    },
+                    confirmationToken: {
+                        type: 'string',
+                        description: 'Token for confirmation — used by delete',
+                    },
+                },
+                required: ['action'],
+            },
+        }, {
+            name: 'noteplan_themes',
+            description: 'Theme management: list, get, save, set active.\n\nActions:\n- list: List all themes and active theme names\n- get: Read a custom theme JSON (requires filename)\n- save: Create/update a custom theme (requires filename + theme)\n- set_active: Activate a theme (requires name)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['list', 'get', 'save', 'set_active'],
+                        description: 'Action to perform',
+                    },
+                    filename: {
+                        type: 'string',
+                        description: 'Theme filename — used by get, save',
+                    },
+                    name: {
+                        type: 'string',
+                        description: 'Theme name — used by set_active',
+                    },
+                    theme: {
+                        type: 'object',
+                        description: 'Theme object — used by save',
+                        properties: {
+                            name: { type: 'string' },
+                            style: { type: 'string', enum: ['Light', 'Dark'] },
+                            author: { type: 'object', properties: { name: { type: 'string' }, email: { type: 'string' } } },
+                            editor: { type: 'object' },
+                            styles: { type: 'object' },
+                        },
+                    },
+                    setActive: {
+                        type: 'boolean',
+                        description: 'Apply theme immediately — used by save (default: true)',
+                    },
+                    mode: {
+                        type: 'string',
+                        enum: ['light', 'dark', 'auto'],
+                        description: 'Mode to apply for — used by save, set_active',
+                    },
+                },
+                required: ['action'],
+            },
+        });
+    }
+    const annotatedToolDefinitions = toolDefinitions.map((tool) => ({
+        ...tool,
+        inputSchema: withDebugTimingsInputSchema(tool.inputSchema),
+        annotations: getToolAnnotations(tool.name),
+        outputSchema: getToolOutputSchema(tool.name),
+    }));
+    const toolDefinitionByName = new Map(annotatedToolDefinitions.map((tool) => [tool.name, tool]));
+    const registeredToolNames = annotatedToolDefinitions.map((tool) => tool.name);
+    const registeredToolNameSet = new Set(registeredToolNames);
+    const compactToolDefinitions = annotatedToolDefinitions.map((tool) => compactToolDefinition(tool));
+    // Register tool listing handler — all 12 tools returned directly (no pagination needed)
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools: compactToolDefinitions };
+    });
+    // Register resource listing handler
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        return {
+            resources: PLUGIN_API_RESOURCES.map((r) => ({
+                uri: `noteplan://plugin-api/${r.file}`,
+                name: r.name,
+                description: r.desc,
+                mimeType: r.file.endsWith('.md') ? 'text/markdown' : r.file.endsWith('.json') ? 'application/json' : 'text/javascript',
+            })),
+        };
+    });
+    // Register resource read handler
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        const uri = request.params.uri;
+        const prefix = 'noteplan://plugin-api/';
+        if (!uri.startsWith(prefix)) {
+            throw new Error(`Unknown resource URI: ${uri}`);
+        }
+        const filename = uri.slice(prefix.length);
+        const entry = PLUGIN_API_RESOURCES.find((r) => r.file === filename);
+        if (!entry) {
+            throw new Error(`Unknown resource: ${filename}. Available: ${PLUGIN_API_RESOURCES.map((r) => r.file).join(', ')}`);
+        }
+        const filePath = path.join(PLUGIN_API_DOCS_DIR, entry.file);
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`Resource file not found on disk: ${filePath}`);
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: entry.file.endsWith('.md') ? 'text/markdown' : entry.file.endsWith('.json') ? 'application/json' : 'text/javascript',
+                    text: content,
+                },
+            ],
+        };
+    });
+    // Register tool call handler
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const normalizedName = normalizeToolName(name);
+        const includeTiming = isDebugTimingsEnabled(args);
+        const startTime = Date.now();
+        try {
+            let result;
+            switch (normalizedName) {
+                // ── Primary consolidated tools ──
+                case 'noteplan_get_notes':
+                    result = dispatchGetNotes((args ?? {}));
+                    break;
+                case 'noteplan_search': {
+                    const searchAction = args?.action;
+                    if (searchAction === 'list_tags') {
+                        result = spaceTools.listTags(args);
+                    }
+                    else {
+                        result = await searchTools.searchNotes(args);
+                    }
+                    break;
+                }
+                case 'noteplan_manage_note': {
+                    const action = args?.action;
+                    const spaceWriteActions = new Set(['create', 'update', 'delete', 'move']);
+                    if (args?.space && spaceWriteActions.has(action) && !advancedFeaturesEnabled) {
+                        result = { success: false, error: upgradeMessage(`space write (${action})`), code: 'ERR_VERSION_GATE' };
+                        break;
+                    }
+                    switch (action) {
+                        case 'create':
+                            result = noteTools.createNote(args);
+                            break;
+                        case 'update':
+                            result = noteTools.updateNote(args);
+                            break;
+                        case 'delete':
+                            result = noteTools.deleteNote(args);
+                            break;
+                        case 'move':
+                            result = noteTools.moveNote(args);
+                            break;
+                        case 'restore':
+                            result = noteTools.restoreNote(args);
+                            break;
+                        case 'rename':
+                            result = noteTools.renameNoteFile(args);
+                            break;
+                        case 'set_property':
+                            result = noteTools.setProperty(args);
+                            break;
+                        case 'remove_property':
+                            result = noteTools.removeProperty(args);
+                            break;
+                        default: throw new Error(`Unknown action: ${action}`);
+                    }
+                    break;
+                }
+                case 'noteplan_edit_content': {
+                    const a = args;
+                    if (a.space && !advancedFeaturesEnabled) {
+                        const editAction = a?.action ?? 'edit';
+                        result = { success: false, error: upgradeMessage(`space write (${editAction})`), code: 'ERR_VERSION_GATE' };
+                        break;
+                    }
+                    if (a.scheduleDate && a.content) {
+                        a.content = appendScheduleDate(a.content, a.scheduleDate);
+                    }
+                    const action = a?.action;
+                    switch (action) {
+                        case 'insert':
+                            result = noteTools.insertContent(a);
+                            break;
+                        case 'append':
+                            result = noteTools.appendContent(a);
+                            break;
+                        case 'delete_lines':
+                            result = noteTools.deleteLines(a);
+                            break;
+                        case 'edit_line':
+                            result = noteTools.editLine(a);
+                            break;
+                        case 'replace_lines':
+                            result = noteTools.replaceLines(a);
+                            break;
+                        default: throw new Error(`Unknown action: ${action}`);
+                    }
+                    break;
+                }
+                case 'noteplan_paragraphs': {
+                    const a = args;
+                    const paragraphWriteActions = new Set(['add', 'complete', 'update']);
+                    if (a.space && paragraphWriteActions.has(a.action) && !advancedFeaturesEnabled) {
+                        result = { success: false, error: upgradeMessage(`space write (${a.action})`), code: 'ERR_VERSION_GATE' };
+                        break;
+                    }
+                    if (a.scheduleDate && a.content) {
+                        a.content = appendScheduleDate(a.content, a.scheduleDate);
+                    }
+                    const action = a?.action;
+                    switch (action) {
+                        case 'get':
+                            result = noteTools.getParagraphs(a);
+                            break;
+                        case 'search':
+                            result = noteTools.searchParagraphs(a);
+                            break;
+                        case 'search_global':
+                            result = taskTools.searchTasksGlobal(a);
+                            break;
+                        case 'add':
+                            result = taskTools.addTaskToNote(a);
+                            break;
+                        case 'complete':
+                            result = taskTools.completeTask(a);
+                            break;
+                        case 'update':
+                            result = taskTools.updateTask(a);
+                            break;
+                        default: throw new Error(`Unknown action: ${action}`);
+                    }
+                    break;
+                }
+                case 'noteplan_folders': {
+                    const action = args?.action;
+                    const folderWriteActions = new Set(['create', 'move', 'rename', 'delete']);
+                    if (args?.space && folderWriteActions.has(action) && !advancedFeaturesEnabled) {
+                        result = { success: false, error: upgradeMessage(`space folder (${action})`), code: 'ERR_VERSION_GATE' };
+                        break;
+                    }
+                    switch (action) {
+                        case 'list':
+                            result = spaceTools.listFolders(args);
+                            break;
+                        case 'find':
+                            result = spaceTools.findFolders(args);
+                            break;
+                        case 'resolve':
+                            result = spaceTools.resolveFolder(args);
+                            break;
+                        case 'create':
+                            result = spaceTools.createFolder(args);
+                            break;
+                        case 'move':
+                            result = spaceTools.moveFolder(args);
+                            break;
+                        case 'rename':
+                            result = spaceTools.renameFolder(args);
+                            break;
+                        case 'delete':
+                            result = spaceTools.deleteFolder(args);
+                            break;
+                        case 'list_spaces':
+                            result = spaceTools.listSpaces(args);
+                            break;
+                        default: throw new Error(`Unknown action: ${action}`);
+                    }
+                    break;
+                }
+                case 'noteplan_filters': {
+                    const action = args?.action;
+                    switch (action) {
+                        case 'list':
+                            result = filterTools.listFilters(args);
+                            break;
+                        case 'get':
+                            result = filterTools.getFilter(args);
+                            break;
+                        case 'get_tasks':
+                            result = filterTools.getFilterTasks(args);
+                            break;
+                        case 'list_parameters':
+                            result = filterTools.listFilterParameters();
+                            break;
+                        case 'save':
+                            result = filterTools.saveFilter(args);
+                            break;
+                        case 'rename':
+                            result = filterTools.renameFilter(args);
+                            break;
+                        default: throw new Error(`Unknown action: ${action}`);
+                    }
+                    break;
+                }
+                case 'noteplan_eventkit': {
+                    const a = args;
+                    const source = a?.source;
+                    const action = a?.action;
+                    if (source === 'reminders') {
+                        switch (action) {
+                            case 'get':
+                                result = reminderTools.getReminders(a);
+                                break;
+                            case 'list_lists':
+                                result = reminderTools.listReminderLists(a);
+                                break;
+                            case 'create':
+                                result = reminderTools.createReminder(a);
+                                break;
+                            case 'complete':
+                                result = reminderTools.completeReminder(a);
+                                break;
+                            case 'update':
+                                result = reminderTools.updateReminder(a);
+                                break;
+                            case 'delete':
+                                result = reminderTools.deleteReminder(a);
+                                break;
+                            default: throw new Error(`Unknown action: ${action}`);
+                        }
+                    }
+                    else {
+                        switch (action) {
+                            case 'get_events':
+                                result = eventTools.getEvents(a);
+                                break;
+                            case 'list_calendars':
+                                result = eventTools.listCalendars(a);
+                                break;
+                            case 'create_event':
+                                result = eventTools.createEvent(a);
+                                break;
+                            case 'update_event':
+                                result = eventTools.updateEvent(a);
+                                break;
+                            case 'delete_event':
+                                result = eventTools.deleteEvent(a);
+                                break;
+                            default: throw new Error(`Unknown action: ${action}`);
+                        }
+                    }
+                    break;
+                }
+                case 'noteplan_memory': {
+                    const action = args?.action;
+                    switch (action) {
+                        case 'list':
+                            result = memoryTools.listMemories(args);
+                            break;
+                        case 'save':
+                            result = memoryTools.saveMemory(args);
+                            break;
+                        case 'update':
+                            result = memoryTools.updateMemory(args);
+                            break;
+                        case 'delete':
+                            result = memoryTools.deleteMemory(args);
+                            break;
+                        default: throw new Error(`Unknown action: ${action}`);
+                    }
+                    break;
+                }
+                case 'noteplan_ui': {
+                    const action = args?.action;
+                    switch (action) {
+                        case 'open_note':
+                            result = uiTools.openNote(args);
+                            break;
+                        case 'open_today':
+                            result = uiTools.openToday(args);
+                            break;
+                        case 'search':
+                            result = uiTools.searchNotes(args);
+                            break;
+                        case 'run_plugin':
+                            result = uiTools.runPlugin(args);
+                            break;
+                        case 'open_view':
+                            result = uiTools.openView(args);
+                            break;
+                        case 'toggle_sidebar':
+                            result = uiTools.toggleSidebar(args);
+                            break;
+                        case 'close_plugin_window':
+                            result = uiTools.closePluginWindow(args);
+                            break;
+                        case 'list_plugin_windows':
+                            result = uiTools.listPluginWindows(args);
+                            break;
+                        default: throw new Error(`Unknown action: ${action}`);
+                    }
+                    break;
+                }
+                case 'noteplan_plugins': {
+                    const action = args?.action;
+                    switch (action) {
+                        case 'list':
+                            result = pluginTools.listPlugins(args);
+                            break;
+                        case 'list_available':
+                            result = pluginTools.listAvailablePlugins(args);
+                            break;
+                        case 'create':
+                            result = pluginTools.createPlugin(args);
+                            break;
+                        case 'delete':
+                            result = pluginTools.deletePlugin(args);
+                            break;
+                        case 'install':
+                            result = pluginTools.installPlugin(args);
+                            break;
+                        case 'log':
+                            result = pluginTools.getPluginLog(args);
+                            break;
+                        case 'source':
+                            result = pluginTools.getPluginSource(args);
+                            break;
+                        case 'update_html':
+                            result = pluginTools.updatePluginHtml(args);
+                            break;
+                        case 'screenshot':
+                            result = pluginTools.screenshotPlugin(args);
+                            break;
+                        default: throw new Error(`Unknown action: ${action}`);
+                    }
+                    break;
+                }
+                case 'noteplan_themes': {
+                    const action = args?.action;
+                    switch (action) {
+                        case 'list':
+                            result = themeTools.listThemes(args);
+                            break;
+                        case 'get':
+                            result = themeTools.getTheme(args);
+                            break;
+                        case 'save':
+                            result = themeTools.saveTheme(args);
+                            break;
+                        case 'set_active':
+                            result = themeTools.setTheme(args);
+                            break;
+                        default: throw new Error(`Unknown action: ${action}`);
+                    }
+                    break;
+                }
+                case 'noteplan_embeddings': {
+                    const action = args?.action;
+                    switch (action) {
+                        case 'status':
+                            result = embeddingsTools.embeddingsStatus(args);
+                            break;
+                        case 'search':
+                            result = await embeddingsTools.embeddingsSearch(args);
+                            break;
+                        case 'sync':
+                            result = await embeddingsTools.embeddingsSync(args);
+                            break;
+                        case 'reset':
+                            result = embeddingsTools.embeddingsReset(args);
+                            break;
+                        default: throw new Error(`Unknown action: ${action}`);
+                    }
+                    break;
+                }
+                default:
+                    throw new Error(`Unknown tool: ${name} (normalized: ${normalizedName})`);
+            }
+            const enrichedResult = enrichErrorResult(result, normalizedName, registeredToolNames);
+            const resultWithSuggestions = withSuggestedNextTools(enrichedResult, normalizedName, registeredToolNameSet);
+            const resultWithMemory = withMemoryHints(resultWithSuggestions, normalizedName);
+            const resultWithDuration = withDuration(resultWithMemory, Date.now() - startTime, includeTiming);
+            const hasOutputSchema = Boolean(toolDefinitionByName.get(normalizedName)?.outputSchema);
+            // If the result contains image data, return it as an MCP image content block
+            const typedResult = resultWithDuration;
+            if (typedResult._imageData && typedResult._imageMimeType) {
+                const imageData = typedResult._imageData;
+                const imageMimeType = typedResult._imageMimeType;
+                // Strip image data from the text response to avoid bloating it
+                const { _imageData: _, _imageMimeType: __, ...textResult } = typedResult;
+                return {
+                    content: [
+                        {
+                            type: 'image',
+                            data: imageData,
+                            mimeType: imageMimeType,
+                        },
+                        {
+                            type: 'text',
+                            text: JSON.stringify(textResult),
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(resultWithDuration),
+                    },
+                ],
+                ...(hasOutputSchema ? { structuredContent: resultWithDuration } : {}),
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            const meta = inferToolErrorMeta(normalizedName, errorMessage, registeredToolNames);
+            const errorResult = {
+                success: false,
+                error: errorMessage,
+                code: meta.code,
+                hint: meta.hint,
+                suggestedTool: meta.suggestedTool,
+                retryable: meta.retryable,
+            };
+            const errorWithDuration = withDuration(errorResult, Date.now() - startTime, includeTiming);
+            const hasOutputSchema = Boolean(toolDefinitionByName.get(normalizedName)?.outputSchema);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(errorWithDuration),
+                    },
+                ],
+                ...(hasOutputSchema ? { structuredContent: errorWithDuration } : {}),
+                isError: true,
+            };
+        }
+    });
+    return server;
+}
+// Start the server with stdio transport
+export async function startServer() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('NotePlan MCP server running on stdio');
+}
+//# sourceMappingURL=server.js.map