@noteplanco/noteplan-mcp 1.1.6 → 1.1.8

package/dist/tools/notes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"notes.d.ts","sourceRoot":"","sources":["../../src/tools/notes.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"notes.d.ts","sourceRoot":"","sources":["../../src/tools/notes.ts"],"names":[],"mappings":"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"}

package/dist/tools/notes.js

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import path from 'path';
 import * as store from '../noteplan/unified-store.js';
 import * as frontmatter from '../noteplan/frontmatter-parser.js';
+import { ensureTemplateFrontmatter } from './templates.js';
 import { issueConfirmationToken, validateAndConsumeConfirmationToken, } from '../utils/confirmation-tokens.js';
 import { parseParagraphLine, buildParagraphLine } from '../noteplan/markdown-parser.js';
 function toBoundedInt(value, defaultValue, min, max) {
@@ -34,6 +35,17 @@ function toOptionalBoolean(value) {
     }
     return undefined;
 }
+/**
+ * Coerce a value to boolean — handles MCP delivering boolean params as strings.
+ * Returns true for boolean true or string "true".
+ */
+function isTrueBool(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string')
+        return value.trim().toLowerCase() === 'true';
+    return false;
+}
 function confirmationFailureMessage(toolName, reason) {
     const refreshHint = `Call ${toolName} with dryRun=true to get a new confirmationToken.`;
     if (reason === 'missing') {
@@ -286,6 +298,8 @@ export const createNoteSchema = z.object({
     folder: z.string().optional().describe('Folder to create the note in. Supports smart matching (e.g., "projects" matches "10 - Projects")'),
     create_new_folder: z.boolean().optional().describe('Set to true to create a new folder instead of matching existing ones'),
     space: z.string().optional().describe('Space name or ID to create in (e.g., "My Team" or a UUID)'),
+    noteType: z.enum(['note', 'template']).optional().default('note').describe('Type of note to create. Use "template" to create in @Templates with proper frontmatter'),
+    templateTypes: z.array(z.enum(['empty-note', 'meeting-note', 'project-note', 'calendar-note'])).optional().describe('Template type tags — used when noteType="template"'),
 });
 export const updateNoteSchema = z.object({
     filename: z.string().describe('Filename/path of the note to update'),
@@ -358,6 +372,8 @@ export const moveNoteSchema = z.object({
 export const renameNoteFileSchema = z.object({
     id: z.string().optional().describe('Note ID (preferred for TeamSpace notes)'),
     filename: z.string().optional().describe('Filename/path of the note to rename'),
+    title: z.string().optional().describe('Note title to find and rename (fuzzy matched)'),
+    query: z.string().optional().describe('Fuzzy search query to find the note'),
     space: z.string().optional().describe('Space name or ID to search in'),
     newFilename: z
         .string()
@@ -381,11 +397,11 @@ export const renameNoteFileSchema = z.object({
         .optional()
         .describe('Confirmation token issued by dryRun for rename execution'),
 }).superRefine((input, ctx) => {
-    if (!input.id && !input.filename) {
+    if (!input.id && !input.filename && !input.title && !input.query) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: 'Provide one note reference: id or filename',
-            path: ['filename'],
+            message: 'Provide one note reference: id, filename, title, or query',
+            path: ['title'],
         });
     }
 });
@@ -670,13 +686,19 @@ export function resolveNote(params) {
 }
 export function createNote(params) {
     try {
-        const result = store.createNote(params.title, params.content, {
-            folder: params.folder,
+        const isTemplate = params.noteType === 'template';
+        const folder = isTemplate && !params.folder ? '@Templates' : params.folder;
+        const content = isTemplate
+            ? ensureTemplateFrontmatter(params.title, params.content, params.templateTypes)
+            : params.content;
+        const result = store.createNote(params.title, content, {
+            folder,
             space: params.space,
             createNewFolder: params.create_new_folder,
         });
         return {
             success: true,
+            tip: 'Use action "set_property" to add frontmatter fields (e.g. type, tags) or "remove_property" to delete them.',
             note: {
                 title: result.note.title,
                 filename: result.note.filename,
@@ -722,7 +744,7 @@ export function updateNote(params) {
                 error: 'Empty content is blocked for noteplan_update_note. Use allowEmptyContent=true to override intentionally.',
             };
         }
-        if (params.dryRun === true) {
+        if (isTrueBool(params.dryRun)) {
             const token = issueConfirmationToken({
                 tool: 'noteplan_update_note',
                 target: params.filename,
@@ -788,7 +810,7 @@ export function deleteNote(params) {
                 error: 'Note not found',
             };
         }
-        if (params.dryRun === true) {
+        if (isTrueBool(params.dryRun)) {
             const token = issueConfirmationToken({
                 tool: 'noteplan_delete_note',
                 target: target.identifier,
@@ -852,7 +874,7 @@ export function moveNote(params) {
         }
         const preview = store.previewMoveNote(target.identifier, params.destinationFolder);
         const confirmationTarget = `${preview.fromFilename}=>${preview.toFilename}::${preview.destinationParentId ?? preview.destinationFolder}`;
-        if (params.dryRun === true) {
+        if (isTrueBool(params.dryRun)) {
             const token = issueConfirmationToken({
                 tool: 'noteplan_move_note',
                 target: confirmationTarget,
@@ -926,7 +948,7 @@ export function restoreNote(params) {
         }
         const preview = store.previewRestoreNote(target.identifier, params.destinationFolder);
         const confirmationTarget = `${preview.fromIdentifier}=>${preview.toIdentifier}`;
-        if (params.dryRun === true) {
+        if (isTrueBool(params.dryRun)) {
             const token = issueConfirmationToken({
                 tool: 'noteplan_restore_note',
                 target: confirmationTarget,
@@ -990,12 +1012,16 @@ export function restoreNote(params) {
 }
 export function renameNoteFile(params) {
     try {
-        // Resolve the note to determine if it's local or space
-        const target = resolveNoteTarget(params.id, params.filename, params.space);
-        if (!target.note) {
-            return { success: false, error: 'Note not found' };
+        // Resolve the note — supports id, filename, title, or query
+        const resolved = resolveWritableNoteReference(params);
+        if (!resolved.note) {
+            return {
+                success: false,
+                error: resolved.error || 'Note not found',
+                candidates: resolved.candidates,
+            };
         }
-        const note = target.note;
+        const note = resolved.note;
         // Space note: rename title
         if (note.source === 'space') {
             if (!params.newTitle) {
@@ -1006,7 +1032,7 @@ export function renameNoteFile(params) {
             }
             const writeId = note.id || note.filename;
             const confirmationTarget = `${note.title}=>${params.newTitle}`;
-            if (params.dryRun === true) {
+            if (isTrueBool(params.dryRun)) {
                 const token = issueConfirmationToken({
                     tool: 'noteplan_rename_note_file',
                     target: confirmationTarget,
@@ -1059,16 +1085,18 @@ export function renameNoteFile(params) {
             };
         }
         // Local note: rename file
-        if (!params.newFilename) {
+        // Accept newTitle as an alias for newFilename — "rename the note" typically means changing the title
+        const effectiveNewFilename = params.newFilename || params.newTitle;
+        if (!effectiveNewFilename) {
             return {
                 success: false,
-                error: 'newFilename is required for local notes (use newTitle for TeamSpace notes)',
+                error: 'newFilename or newTitle is required for local notes',
             };
         }
         const keepExtension = params.keepExtension ?? true;
-        const preview = store.previewRenameNoteFile(note.filename, params.newFilename, keepExtension);
+        const preview = store.previewRenameNoteFile(note.filename, effectiveNewFilename, keepExtension);
         const confirmationTarget = `${preview.fromFilename}=>${preview.toFilename}`;
-        if (params.dryRun === true) {
+        if (isTrueBool(params.dryRun)) {
             const token = issueConfirmationToken({
                 tool: 'noteplan_rename_note_file',
                 target: confirmationTarget,
@@ -1103,7 +1131,26 @@ export function renameNoteFile(params) {
                 error: confirmationFailureMessage('noteplan_rename_note_file', confirmation.reason),
             };
         }
-        const renamed = store.renameNoteFile(note.filename, params.newFilename, keepExtension);
+        const renamed = store.renameNoteFile(note.filename, effectiveNewFilename, keepExtension);
+        // Also update the # Title heading in the note content if it matches the old title
+        const newTitle = params.newTitle || params.newFilename;
+        if (newTitle && renamed.note.content) {
+            const lines = renamed.note.content.split('\n');
+            const titleLineIndex = lines.findIndex((l) => /^#\s+/.test(l));
+            if (titleLineIndex !== -1) {
+                const oldHeadingTitle = lines[titleLineIndex].replace(/^#\s+/, '');
+                // Update heading if it matches the old note title (or old filename without extension)
+                const oldTitle = note.title || '';
+                const oldFilenameBase = note.filename.replace(/^.*\//, '').replace(/\.\w+$/, '');
+                if (oldHeadingTitle === oldTitle || oldHeadingTitle === oldFilenameBase) {
+                    lines[titleLineIndex] = `# ${newTitle}`;
+                    const writeTarget = getWritableIdentifier(renamed.note);
+                    store.updateNote(writeTarget.identifier, lines.join('\n'), {
+                        source: writeTarget.source,
+                    });
+                }
+            }
+        }
         return {
             success: true,
             message: `Note renamed to ${renamed.toFilename}`,
@@ -1319,6 +1366,7 @@ export function searchParagraphs(params) {
     const nextCursor = hasMore ? String(offset + page.length) : null;
     const result = {
         success: true,
+        tip: 'To search across ALL notes at once, use action "search_global" instead. It supports query "*" to match all tasks.',
         query,
         count: page.length,
         totalCount: allMatches.length,
@@ -1427,6 +1475,7 @@ export const appendContentSchema = z.object({
     query: z.string().optional().describe('Resolvable note query (fuzzy note lookup before append)'),
     space: z.string().optional().describe('Space name or ID scope for title/date/query resolution'),
     content: z.string().describe('Content to append'),
+    heading: z.string().optional().describe('Heading or section marker text — when provided, appends at end of that section instead of end of note'),
     indentationStyle: z
         .enum(['tabs', 'preserve'])
         .optional()
@@ -1555,6 +1604,41 @@ export function insertContent(params) {
         const note = resolved.note;
         const indentationStyle = normalizeIndentationStyle(params.indentationStyle);
         let contentToInsert = params.content;
+        // Auto-correct position when line number is provided but position is wrong
+        // Catches LLMs sending { position: "start", line: 5 } instead of { position: "at-line", line: 5 }
+        if (params.line !== undefined && params.position !== 'at-line') {
+            params.position = 'at-line';
+        }
+        // Auto-detect raw task/checklist markdown when type is not explicitly set
+        // Catches LLMs sending "- [ ] Buy groceries", "* [x] Done", "* Buy groceries", "+ Item" without proper type
+        if (!params.type && /^[\t ]*[*+\-]\s+/.test(contentToInsert)) {
+            // Determine type from the marker character
+            const markerMatch = contentToInsert.match(/^[\t ]*([*+\-])\s+/);
+            const markerChar = markerMatch?.[1];
+            if (markerChar === '+') {
+                params.type = 'checklist';
+            }
+            else if (markerChar === '*') {
+                params.type = 'task';
+            }
+            else if (markerChar === '-' && /^[\t ]*-\s+\[[ x\->]\]\s+/.test(contentToInsert)) {
+                // Dash with checkbox is clearly a task (plain "- text" could be a bullet, so only match with checkbox)
+                params.type = 'task';
+            }
+            // Detect status from the checkbox marker if present
+            if (params.type) {
+                const statusMatch = contentToInsert.match(/\[(.)\]/);
+                if (statusMatch) {
+                    const marker = statusMatch[1];
+                    if (marker === 'x')
+                        params.taskStatus = 'done';
+                    else if (marker === '-')
+                        params.taskStatus = 'cancelled';
+                    else if (marker === '>')
+                        params.taskStatus = 'scheduled';
+                }
+            }
+        }
         if (params.type) {
             contentToInsert = contentToInsert
                 .split('\n')
@@ -1578,6 +1662,7 @@ export function insertContent(params) {
         });
         return {
             success: true,
+            tip: 'Use noteplan_paragraphs(action: "get") to inspect line numbers and content before making further edits.',
             message: `Content inserted at ${params.position}`,
             note: {
                 id: note.id,
@@ -1610,6 +1695,7 @@ export function appendContent(params) {
         const normalized = normalizeContentIndentation(params.content, indentationStyle);
         const newContent = frontmatter.insertContentAtPosition(note.content, normalized.content, {
             position: 'end',
+            heading: params.heading,
         });
         const writeTarget = getWritableIdentifier(note);
         store.updateNote(writeTarget.identifier, newContent, {
@@ -1642,8 +1728,18 @@ export function deleteLines(params) {
         }
         const note = resolved.note;
         const allLines = note.content.split('\n');
-        const boundedStartLine = toBoundedInt(params.startLine, 1, 1, Math.max(1, allLines.length));
-        const boundedEndLine = toBoundedInt(params.endLine, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, allLines.length));
+        // Line numbers are absolute (1-indexed), matching get_notes/getParagraphs
+        const totalLineCount = allLines.length;
+        const fmLineCount = frontmatter.getFrontmatterLineCount(note.content);
+        const minLine = fmLineCount > 0 ? fmLineCount + 1 : 1;
+        const boundedStartLine = toBoundedInt(params.startLine, minLine, minLine, Math.max(minLine, totalLineCount));
+        const boundedEndLine = toBoundedInt(params.endLine, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, totalLineCount));
+        if (boundedStartLine <= fmLineCount) {
+            return {
+                success: false,
+                error: `Lines 1-${fmLineCount} are frontmatter and cannot be deleted. Content starts at line ${fmLineCount + 1}.`,
+            };
+        }
         const lineCountToDelete = boundedEndLine - boundedStartLine + 1;
         const previewStartIndex = boundedStartLine - 1;
         const previewEndIndexExclusive = boundedEndLine;
@@ -1660,7 +1756,7 @@ export function deleteLines(params) {
             ? buildAttachmentWarningMessage(removedAttachmentReferences.length)
             : undefined;
         const confirmTarget = `${note.filename}:${boundedStartLine}-${boundedEndLine}`;
-        if (params.dryRun === true) {
+        if (isTrueBool(params.dryRun)) {
             const token = issueConfirmationToken({
                 tool: 'noteplan_delete_lines',
                 target: confirmTarget,
@@ -1690,7 +1786,10 @@ export function deleteLines(params) {
                 error: confirmationFailureMessage('noteplan_delete_lines', confirmation.reason),
             };
         }
-        const newContent = frontmatter.deleteLines(note.content, boundedStartLine, boundedEndLine);
+        // Splice out lines using absolute indices (no frontmatter offset needed)
+        const splicedLines = [...allLines];
+        splicedLines.splice(boundedStartLine - 1, lineCountToDelete);
+        const newContent = splicedLines.join('\n');
         const writeIdentifier = note.source === 'space' ? (note.id || note.filename) : note.filename;
         store.updateNote(writeIdentifier, newContent, { source: note.source });
         return {
@@ -1724,13 +1823,21 @@ export function editLine(params) {
         const note = resolved.note;
         const lines = note.content.split('\n');
         const originalLineCount = lines.length;
-        const lineIndex = params.line - 1; // Convert to 0-indexed
+        // Line numbers are absolute (1-indexed), matching get_notes/getParagraphs
+        const fmLineCount = frontmatter.getFrontmatterLineCount(note.content);
+        const lineIndex = Number(params.line) - 1; // Convert to 0-indexed
         if (lineIndex < 0 || lineIndex >= lines.length) {
             return {
                 success: false,
                 error: `Line ${params.line} does not exist (note has ${lines.length} lines)`,
             };
         }
+        if (fmLineCount > 0 && lineIndex < fmLineCount) {
+            return {
+                success: false,
+                error: `Line ${params.line} is inside frontmatter (lines 1-${fmLineCount}). Content starts at line ${fmLineCount + 1}.`,
+            };
+        }
         const originalLine = lines[lineIndex];
         const indentationStyle = normalizeIndentationStyle(params.indentationStyle);
         const normalized = normalizeContentIndentation(params.content, indentationStyle);
@@ -1781,13 +1888,31 @@ export function replaceLines(params) {
         const note = resolved.note;
         const allLines = note.content.split('\n');
         const originalLineCount = allLines.length;
-        const boundedStartLine = toBoundedInt(params.startLine, 1, 1, Math.max(1, originalLineCount));
+        // Line numbers are absolute (1-indexed), matching get_notes/getParagraphs
+        const fmLineCount = frontmatter.getFrontmatterLineCount(note.content);
+        const minLine = fmLineCount > 0 ? fmLineCount + 1 : 1;
+        const boundedStartLine = toBoundedInt(params.startLine, minLine, minLine, Math.max(minLine, originalLineCount));
         const boundedEndLine = toBoundedInt(params.endLine, boundedStartLine, boundedStartLine, Math.max(boundedStartLine, originalLineCount));
-        const startIndex = boundedStartLine - 1;
-        const lineCountToReplace = boundedEndLine - boundedStartLine + 1;
+        if (boundedStartLine <= fmLineCount) {
+            return {
+                success: false,
+                error: `Lines 1-${fmLineCount} are frontmatter and cannot be replaced directly. Content starts at line ${fmLineCount + 1}.`,
+            };
+        }
+        let startIndex = boundedStartLine - 1;
+        let lineCountToReplace = boundedEndLine - boundedStartLine + 1;
         const replacedText = allLines.slice(startIndex, boundedEndLine).join('\n');
         const indentationStyle = normalizeIndentationStyle(params.indentationStyle);
         const normalized = normalizeContentIndentation(params.content, indentationStyle);
+        // If replacement content includes frontmatter and the note already has
+        // frontmatter, extend the splice to replace the old frontmatter too.
+        // The agent's frontmatter is the intended update.
+        const replacementHasFm = fmLineCount > 0
+            && frontmatter.parseNoteContent(normalized.content).hasFrontmatter;
+        if (replacementHasFm) {
+            lineCountToReplace += startIndex; // extend to also cover frontmatter lines
+            startIndex = 0;
+        }
         if (params.allowEmptyContent !== true && normalized.content.trim().length === 0) {
             return {
                 success: false,
@@ -1806,7 +1931,7 @@ export function replaceLines(params) {
             warnings.push(`Line numbers shifted by ${lineDelta > 0 ? '+' : ''}${lineDelta} after this replacement. Re-read line numbers before the next mutation.`);
         }
         const target = `${note.filename}:${boundedStartLine}-${boundedEndLine}:${replacementLines.length}:${normalized.content.length}`;
-        if (params.dryRun === true) {
+        if (isTrueBool(params.dryRun)) {
             const token = issueConfirmationToken({
                 tool: 'noteplan_replace_lines',
                 target,
@@ -1865,4 +1990,216 @@ export function replaceLines(params) {
         };
     }
 }
+// ---------------------------------------------------------------------------
+// searchParagraphsGlobal — search ALL lines (including frontmatter) across notes
+// ---------------------------------------------------------------------------
+function normalizeType(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const lower = value.trim().toLowerCase();
+    if (lower === 'calendar' || lower === 'note' || lower === 'trash')
+        return lower;
+    return undefined;
+}
+function normalizeTypeList(values) {
+    if (!Array.isArray(values))
+        return undefined;
+    const unique = new Set();
+    for (const entry of values) {
+        const normalized = normalizeType(entry);
+        if (normalized)
+            unique.add(normalized);
+    }
+    return unique.size > 0 ? Array.from(unique) : undefined;
+}
+function isPeriodicCalendarNote(note) {
+    if (note.type !== 'calendar' || !note.date)
+        return false;
+    return note.date.includes('-');
+}
+export const searchParagraphsGlobalSchema = z.object({
+    query: z.string().describe('Text to find across all notes (searches ALL lines including frontmatter)'),
+    caseSensitive: z.boolean().optional().default(false).describe('Case-sensitive match (default: false)'),
+    wholeWord: z.boolean().optional().default(false).describe('Require whole-word matches (default: false)'),
+    status: z
+        .enum(['open', 'done', 'cancelled', 'scheduled'])
+        .optional()
+        .describe('Filter results to only lines with this task status'),
+    contextLines: z.number().min(0).max(5).optional().default(1).describe('Context lines before/after each match'),
+    paragraphMaxChars: z
+        .number()
+        .min(50)
+        .max(5000)
+        .optional()
+        .default(600)
+        .describe('Maximum paragraph text chars per match'),
+    folder: z.string().optional().describe('Restrict to a specific folder path'),
+    space: z.string().optional().describe('Restrict to a specific space name or ID'),
+    noteQuery: z.string().optional().describe('Filter notes by title/filename/folder substring'),
+    noteTypes: z
+        .array(z.enum(['calendar', 'note', 'trash']))
+        .optional()
+        .describe('Restrict scanned notes by type'),
+    preferCalendar: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Prioritize calendar notes before maxNotes truncation'),
+    periodicOnly: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('When true, only scan periodic calendar notes (weekly/monthly/quarterly/yearly)'),
+    maxNotes: z.number().min(1).max(2000).optional().default(500).describe('Maximum notes to scan'),
+    limit: z.number().min(1).max(300).optional().default(30).describe('Maximum matches to return'),
+    offset: z.number().min(0).optional().default(0).describe('Pagination offset'),
+    cursor: z.string().optional().describe('Cursor token from previous page (preferred over offset)'),
+});
+export function searchParagraphsGlobal(params) {
+    const query = typeof params?.query === 'string' ? params.query.trim() : '';
+    if (!query) {
+        return {
+            success: false,
+            error: 'query is required',
+        };
+    }
+    const caseSensitive = params.caseSensitive ?? false;
+    const wholeWord = params.wholeWord ?? false;
+    const contextLines = toBoundedInt(params.contextLines, 1, 0, 5);
+    const paragraphMaxChars = toBoundedInt(params.paragraphMaxChars, 600, 50, 5000);
+    const normalizedQuery = caseSensitive ? query : query.toLowerCase();
+    const wildcardQuery = query === '*';
+    const matcher = wholeWord
+        ? new RegExp(`\\b${escapeRegExp(query)}\\b`, caseSensitive ? '' : 'i')
+        : null;
+    const maxNotes = toBoundedInt(params.maxNotes, 500, 1, 2000);
+    const noteQuery = typeof params.noteQuery === 'string' ? params.noteQuery.trim().toLowerCase() : '';
+    const noteTypes = normalizeTypeList(params.noteTypes);
+    const preferCalendar = params.preferCalendar === true;
+    const periodicOnly = params.periodicOnly === true;
+    const allNotes = store.listNotes({
+        folder: params.folder,
+        space: params.space,
+    });
+    let filteredNotes = noteQuery
+        ? allNotes.filter((note) => {
+            const haystack = `${note.title} ${note.filename} ${note.folder || ''}`.toLowerCase();
+            return haystack.includes(noteQuery);
+        })
+        : allNotes;
+    if (noteTypes && noteTypes.length > 0) {
+        filteredNotes = filteredNotes.filter((note) => noteTypes.includes(note.type));
+    }
+    if (periodicOnly) {
+        filteredNotes = filteredNotes.filter((note) => isPeriodicCalendarNote(note));
+    }
+    if (preferCalendar) {
+        filteredNotes = [...filteredNotes].sort((a, b) => {
+            const aCalendar = a.type === 'calendar' ? 1 : 0;
+            const bCalendar = b.type === 'calendar' ? 1 : 0;
+            if (aCalendar !== bCalendar)
+                return bCalendar - aCalendar;
+            const aModified = a.modifiedAt?.getTime() ?? 0;
+            const bModified = b.modifiedAt?.getTime() ?? 0;
+            return bModified - aModified;
+        });
+    }
+    const scannedNotes = filteredNotes.slice(0, maxNotes);
+    const truncatedByMaxNotes = filteredNotes.length > scannedNotes.length;
+    const allMatches = [];
+    for (const note of scannedNotes) {
+        const allLines = note.content.split('\n');
+        for (let lineIndex = 0; lineIndex < allLines.length; lineIndex++) {
+            const lineContent = allLines[lineIndex];
+            const haystack = caseSensitive ? lineContent : lineContent.toLowerCase();
+            const isMatch = wildcardQuery
+                ? true
+                : matcher
+                    ? matcher.test(lineContent)
+                    : haystack.includes(normalizedQuery);
+            if (!isMatch)
+                continue;
+            const paragraphBounds = findParagraphBounds(allLines, lineIndex);
+            const paragraphRaw = allLines
+                .slice(paragraphBounds.startIndex, paragraphBounds.endIndex + 1)
+                .join('\n');
+            const paragraphTruncated = paragraphRaw.length > paragraphMaxChars;
+            const paragraph = paragraphTruncated
+                ? `${paragraphRaw.slice(0, Math.max(0, paragraphMaxChars - 3))}...`
+                : paragraphRaw;
+            const contextStart = Math.max(0, lineIndex - contextLines);
+            const contextEnd = Math.min(allLines.length - 1, lineIndex + contextLines);
+            const meta = parseParagraphLine(lineContent, lineIndex, lineIndex === 0);
+            // Apply status filter (backward compat with searchTasksGlobal)
+            if (params.status && meta.taskStatus !== params.status)
+                continue;
+            allMatches.push({
+                note: {
+                    id: note.id,
+                    title: note.title,
+                    filename: note.filename,
+                    type: note.type,
+                    source: note.source,
+                    folder: note.folder,
+                    spaceId: note.spaceId,
+                    date: note.date,
+                },
+                lineIndex,
+                line: lineIndex + 1,
+                content: lineContent,
+                // Backward-compat alias: `status` mirrors `taskStatus` for old consumers
+                ...(meta.taskStatus !== undefined && { status: meta.taskStatus }),
+                type: meta.type,
+                indentLevel: meta.indentLevel,
+                ...(meta.headingLevel !== undefined && { headingLevel: meta.headingLevel }),
+                ...(meta.taskStatus !== undefined && { taskStatus: meta.taskStatus }),
+                ...(meta.priority !== undefined && { priority: meta.priority }),
+                ...(meta.marker !== undefined && { marker: meta.marker }),
+                ...(meta.hasCheckbox !== undefined && { hasCheckbox: meta.hasCheckbox }),
+                tags: meta.tags,
+                mentions: meta.mentions,
+                ...(meta.scheduledDate !== undefined && { scheduledDate: meta.scheduledDate }),
+                paragraphStartLine: paragraphBounds.startIndex + 1,
+                paragraphEndLine: paragraphBounds.endIndex + 1,
+                paragraph,
+                paragraphTruncated,
+                contextBefore: allLines.slice(contextStart, lineIndex),
+                contextAfter: allLines.slice(lineIndex + 1, contextEnd + 1),
+            });
+        }
+    }
+    const offset = toBoundedInt(params.cursor ?? params.offset, 0, 0, Number.MAX_SAFE_INTEGER);
+    const limit = toBoundedInt(params.limit, 30, 1, 300);
+    const page = allMatches.slice(offset, offset + limit);
+    const hasMore = offset + page.length < allMatches.length;
+    const nextCursor = hasMore ? String(offset + page.length) : null;
+    const result = {
+        success: true,
+        query,
+        count: page.length,
+        totalCount: allMatches.length,
+        offset,
+        limit,
+        hasMore,
+        nextCursor,
+        scannedNoteCount: scannedNotes.length,
+        totalNotes: filteredNotes.length,
+        truncatedByMaxNotes,
+        maxNotes,
+        noteTypes,
+        preferCalendar,
+        periodicOnly,
+        matches: page,
+    };
+    if (hasMore) {
+        result.performanceHints = ['Continue with nextCursor to fetch the next global paragraph match page.'];
+    }
+    if (truncatedByMaxNotes) {
+        result.performanceHints = [
+            ...(result.performanceHints ?? []),
+            'Increase maxNotes or narrow folder/space/noteQuery to reduce truncation.',
+        ];
+    }
+    return result;
+}
 //# sourceMappingURL=notes.js.map