@noteplanco/noteplan-mcp 1.1.23 → 1.1.25

package/dist/noteplan/file-writer.test.js

@@ -2,50 +2,91 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
 vi.mock('fs');
+vi.mock('../transport/bridge-availability.js', () => ({
+    getBridgeClient: vi.fn(async () => null),
+    invalidateBridgeClient: vi.fn(),
+}));
 vi.mock('./file-reader.js', () => ({
     getNotePlanPath: vi.fn(() => '/np'),
     getNotesPath: vi.fn(() => '/np/Notes'),
     getCalendarPath: vi.fn(() => '/np/Calendar'),
     getFileExtension: vi.fn(() => '.md'),
     hasYearSubfolders: vi.fn(() => false),
-    buildCalendarNotePath: vi.fn((date) => `Calendar/${date}.md`),
+    buildCalendarNotePathAsync: vi.fn(async (date) => `Calendar/${date}.md`),
     getCalendarNote: vi.fn(() => null),
     isValidNoteExtension: vi.fn((filename) => {
         const ext = path.extname(filename).toLowerCase();
         return ext === '.md' || ext === '.txt';
     }),
 }));
-import { writeNoteFile, createProjectNote, createCalendarNote, ensureCalendarNote, appendToNote, prependToNote, updateNote, deleteNote, moveLocalNote, previewMoveLocalNote, restoreLocalNoteFromTrash, previewRestoreLocalNoteFromTrash, renameLocalNoteFile, previewRenameLocalNoteFile, createFolder, previewCreateFolder, deleteLocalFolder, previewDeleteLocalFolder, moveLocalFolder, previewMoveLocalFolder, renameLocalFolder, previewRenameLocalFolder, } from './file-writer.js';
+import { writeNoteFile, createProjectNote, createCalendarNote, createCalendarNoteIfNew, ensureCalendarNote, appendToNote, prependToNote, updateNote, deleteNote, moveLocalNote, previewMoveLocalNote, restoreLocalNoteFromTrash, previewRestoreLocalNoteFromTrash, renameLocalNoteFile, previewRenameLocalNoteFile, createFolder, previewCreateFolder, deleteLocalFolder, previewDeleteLocalFolder, moveLocalFolder, previewMoveLocalFolder, renameLocalFolder, previewRenameLocalFolder, } from './file-writer.js';
 import { getCalendarNote } from './file-reader.js';
 const mockFs = vi.mocked(fs);
+// Production code uses fs.promises; tests assert against fs.*Sync. The proxy
+// forwards every promise call to its sync counterpart, with existsSync gating
+// stat/readFile/access so ENOENT surfaces consistently.
 beforeEach(() => {
     vi.resetAllMocks();
-    // Default: directories exist, files do not
     mockFs.existsSync.mockReturnValue(false);
+    const enoent = () => Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+    mockFs.promises = {
+        writeFile: vi.fn(async (p, content, opts) => {
+            const normalized = typeof opts === 'string' ? { encoding: opts } : opts;
+            return mockFs.writeFileSync(p, content, normalized);
+        }),
+        mkdir: vi.fn(async (p, opts) => mockFs.mkdirSync(p, opts)),
+        rename: vi.fn(async (a, b) => mockFs.renameSync(a, b)),
+        copyFile: vi.fn(async (a, b) => mockFs.copyFileSync(a, b)),
+        unlink: vi.fn(async (p) => mockFs.unlinkSync(p)),
+        rm: vi.fn(async (p) => {
+            if (mockFs.rmSync)
+                mockFs.rmSync(p, { recursive: true });
+            else
+                mockFs.unlinkSync(p);
+        }),
+        readFile: vi.fn(async (p, enc) => {
+            if (!mockFs.existsSync(p))
+                throw enoent();
+            return mockFs.readFileSync(p, enc);
+        }),
+        readdir: vi.fn(async (p, opts) => mockFs.readdirSync(p, opts)),
+        stat: vi.fn(async (p) => {
+            if (!mockFs.existsSync(p))
+                throw enoent();
+            const explicit = mockFs.statSync(p);
+            if (explicit !== undefined && explicit !== null)
+                return explicit;
+            return { isDirectory: () => false, isFile: () => true };
+        }),
+        access: vi.fn(async (p) => {
+            if (!mockFs.existsSync(p))
+                throw enoent();
+        }),
+    };
 });
 // ---------------------------------------------------------------------------
 // writeNoteFile
 // ---------------------------------------------------------------------------
 describe('writeNoteFile', () => {
-    it('normalizes CRLF to LF', () => {
+    it('normalizes CRLF to LF', async () => {
         mockFs.existsSync.mockReturnValue(true); // dir exists, file exists
-        writeNoteFile('Notes/test.md', 'line1\r\nline2\r\n');
+        await writeNoteFile('Notes/test.md', 'line1\r\nline2\r\n');
         expect(mockFs.writeFileSync).toHaveBeenCalledWith('/np/Notes/test.md', 'line1\nline2\n', { encoding: 'utf-8' });
     });
-    it('creates parent directories when they do not exist', () => {
+    it('creates parent directories when they do not exist', async () => {
         // First call: dir check -> false, second call: file check -> false
         mockFs.existsSync.mockReturnValue(false);
-        writeNoteFile('Notes/sub/test.md', 'content');
+        await writeNoteFile('Notes/sub/test.md', 'content');
         expect(mockFs.mkdirSync).toHaveBeenCalledWith('/np/Notes/sub', { recursive: true });
     });
-    it('does in-place write for existing files (no wx flag)', () => {
+    it('does in-place write for existing files (no wx flag)', async () => {
         // dir exists, file exists
         mockFs.existsSync.mockReturnValue(true);
-        writeNoteFile('Notes/existing.md', 'updated');
+        await writeNoteFile('Notes/existing.md', 'updated');
         expect(mockFs.writeFileSync).toHaveBeenCalledTimes(1);
         expect(mockFs.writeFileSync).toHaveBeenCalledWith('/np/Notes/existing.md', 'updated', { encoding: 'utf-8' });
     });
-    it('uses wx flag for new files', () => {
+    it('uses wx flag for new files', async () => {
         // dir exists (first call), file does not exist (second call)
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
@@ -53,10 +94,10 @@ describe('writeNoteFile', () => {
                 return true; // dir
             return false; // file
         });
-        writeNoteFile('Notes/new.md', 'hello');
+        await writeNoteFile('Notes/new.md', 'hello');
         expect(mockFs.writeFileSync).toHaveBeenCalledWith('/np/Notes/new.md', 'hello', { encoding: 'utf-8', flag: 'wx' });
     });
-    it('falls back to plain write on EPERM from wx', () => {
+    it('falls back to plain write on EPERM from wx', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             if (String(p) === '/np/Notes')
                 return true;
@@ -66,11 +107,11 @@ describe('writeNoteFile', () => {
         mockFs.writeFileSync.mockImplementationOnce(() => {
             throw eperm;
         });
-        writeNoteFile('Notes/new.md', 'data');
+        await writeNoteFile('Notes/new.md', 'data');
         expect(mockFs.writeFileSync).toHaveBeenCalledTimes(2);
         expect(mockFs.writeFileSync).toHaveBeenLastCalledWith('/np/Notes/new.md', 'data', { encoding: 'utf-8' });
     });
-    it('falls back to plain write on EEXIST from wx', () => {
+    it('falls back to plain write on EEXIST from wx', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             if (String(p) === '/np/Notes')
                 return true;
@@ -80,10 +121,10 @@ describe('writeNoteFile', () => {
         mockFs.writeFileSync.mockImplementationOnce(() => {
             throw eexist;
         });
-        writeNoteFile('Notes/new.md', 'data');
+        await writeNoteFile('Notes/new.md', 'data');
         expect(mockFs.writeFileSync).toHaveBeenCalledTimes(2);
     });
-    it('re-throws non-EPERM/EEXIST errors', () => {
+    it('re-throws non-EPERM/EEXIST errors', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             if (String(p) === '/np/Notes')
                 return true;
@@ -93,96 +134,191 @@ describe('writeNoteFile', () => {
         mockFs.writeFileSync.mockImplementationOnce(() => {
             throw eacces;
         });
-        expect(() => writeNoteFile('Notes/new.md', 'data')).toThrow('EACCES');
+        await expect(writeNoteFile('Notes/new.md', 'data')).rejects.toThrow('EACCES');
     });
-    it('rejects paths outside NotePlan root', () => {
-        expect(() => writeNoteFile('/outside/path.md', 'x')).toThrow();
+    it('rejects paths outside NotePlan root', async () => {
+        await expect(writeNoteFile('/outside/path.md', 'x')).rejects.toThrow();
     });
 });
 // ---------------------------------------------------------------------------
 // createProjectNote
 // ---------------------------------------------------------------------------
 describe('createProjectNote', () => {
-    it('creates note with sanitized filename and returns relative path', () => {
+    it('creates note with sanitized filename and returns relative path', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        const result = createProjectNote('My Note');
+        const result = await createProjectNote('My Note');
         expect(result).toBe(path.join('Notes', 'My Note.md'));
         expect(mockFs.writeFileSync).toHaveBeenCalled();
     });
-    it('uses default content when content is empty', () => {
+    it('uses default content when content is empty', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        createProjectNote('Title');
+        await createProjectNote('Title');
         // The writeFileSync should be called with "# Title\n\n" (after CRLF normalization, still same)
         const calls = mockFs.writeFileSync.mock.calls;
         const contentArg = calls[0]?.[1];
         expect(contentArg).toBe('# Title\n\n');
     });
-    it('uses provided content when given', () => {
+    it('uses provided content when given', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        createProjectNote('Title', 'custom body');
+        await createProjectNote('Title', 'custom body');
         const calls = mockFs.writeFileSync.mock.calls;
         expect(calls[0]?.[1]).toBe('custom body');
     });
-    it('creates note in specified folder', () => {
+    it('creates note in specified folder', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        const result = createProjectNote('Note', '', 'Work');
+        const result = await createProjectNote('Note', '', 'Work');
         expect(result).toBe(path.join('Notes', 'Work', 'Note.md'));
     });
-    it('strips Notes/ prefix from folder to avoid double-nesting', () => {
+    it('strips Notes/ prefix from folder to avoid double-nesting', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        const result = createProjectNote('Note', '', 'Notes/Work');
+        const result = await createProjectNote('Note', '', 'Notes/Work');
         expect(result).toBe(path.join('Notes', 'Work', 'Note.md'));
     });
-    it('throws if note already exists with same extension', () => {
+    it('treats a bare "Notes" folder as the vault root (no Notes/Notes nesting)', async () => {
+        // Regression: when the folder resolver short-circuits on the
+        // reserved top-level name "Notes" and passes the literal through,
+        // we used to produce `Notes/Notes/<title>` because the prefix
+        // strip required a trailing slash. The regex now also matches
+        // end-of-string.
+        mockFs.existsSync.mockReturnValue(false);
+        const result = await createProjectNote('Note', '', 'Notes');
+        expect(result).toBe(path.join('Notes', 'Note.md'));
+    });
+    it('throws if note already exists with same extension', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             return String(p) === '/np/Notes/Dup.md';
         });
-        expect(() => createProjectNote('Dup')).toThrow('Note already exists');
+        await expect(createProjectNote('Dup')).rejects.toThrow('Note already exists');
     });
-    it('throws if note exists with alternate extension (.txt)', () => {
+    it('throws if note exists with alternate extension (.txt)', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             return String(p) === '/np/Notes/Dup.txt';
         });
-        expect(() => createProjectNote('Dup')).toThrow('Note already exists');
+        await expect(createProjectNote('Dup')).rejects.toThrow('Note already exists');
     });
-    it('sanitizes special characters in title', () => {
+    it('sanitizes special characters in title', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        const result = createProjectNote('Hello/World?');
+        const result = await createProjectNote('Hello/World?');
         expect(result).toBe(path.join('Notes', 'Hello-World-.md'));
     });
-    it('sanitizes all illegal filename chars', () => {
+    it('sanitizes all illegal filename chars', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        const result = createProjectNote('a\\b?c%d*e:f|g"h<i>j');
+        const result = await createProjectNote('a\\b?c%d*e:f|g"h<i>j');
         // Each illegal char replaced with -
         expect(result).toBe(path.join('Notes', 'a-b-c-d-e-f-g-h-i-j.md'));
     });
+    // Regression: the explicit `filename` parameter used to be silently dropped
+    // by the schema, so callers had to do create + rename in two steps. These
+    // tests pin the new behavior — title and filename are independent inputs.
+    describe('explicit filename parameter', () => {
+        it('uses the explicit filename instead of deriving from title', async () => {
+            mockFs.existsSync.mockReturnValue(false);
+            const result = await createProjectNote('Human Readable Title', '', undefined, '_context.md');
+            expect(result).toBe(path.join('Notes', '_context.md'));
+        });
+        it('appends the configured default extension when filename has none', async () => {
+            mockFs.existsSync.mockReturnValue(false);
+            const result = await createProjectNote('Title', '', undefined, '_context');
+            expect(result).toBe(path.join('Notes', '_context.md'));
+        });
+        it('keeps an explicit .txt extension', async () => {
+            mockFs.existsSync.mockReturnValue(false);
+            const result = await createProjectNote('Title', '', undefined, '_context.txt');
+            expect(result).toBe(path.join('Notes', '_context.txt'));
+        });
+        it('combines explicit filename with the folder argument', async () => {
+            mockFs.existsSync.mockReturnValue(false);
+            const result = await createProjectNote('Title', '', 'Work', 'shortname');
+            expect(result).toBe(path.join('Notes', 'Work', 'shortname.md'));
+        });
+        it('preserves the title-derived heading even when filename overrides the on-disk name', async () => {
+            mockFs.existsSync.mockReturnValue(false);
+            await createProjectNote('Human Title', '', undefined, '_short.md');
+            const calls = mockFs.writeFileSync.mock.calls;
+            // Default content path: "# {title}\n\n"
+            expect(calls[0]?.[1]).toBe('# Human Title\n\n');
+        });
+        it('rejects a filename containing a path separator', async () => {
+            await expect(createProjectNote('Title', '', undefined, 'Work/_context.md')).rejects.toThrow(/path separator/);
+        });
+        it('rejects path traversal via ".."', async () => {
+            // The regex catches `/`/`\\` first, but a bare ".." with no separator
+            // would also be split-checked. Verify both rejections.
+            await expect(createProjectNote('Title', '', undefined, '../escape.md')).rejects.toThrow();
+        });
+        it('rejects an empty filename', async () => {
+            await expect(createProjectNote('Title', '', undefined, '   ')).rejects.toThrow(/empty/);
+        });
+        it('replaces illegal filename chars (matching title-derived behavior)', async () => {
+            // `*` is illegal in filenames; sanitizeFilename replaces it with `-`,
+            // matching the behavior we apply to title-derived filenames.
+            mockFs.existsSync.mockReturnValue(false);
+            const result = await createProjectNote('Title', '', undefined, '*.md');
+            expect(result).toBe(path.join('Notes', '-.md'));
+        });
+        it('detects collision against the same extension', async () => {
+            mockFs.existsSync.mockImplementation((p) => String(p) === '/np/Notes/_dup.md');
+            await expect(createProjectNote('Title', '', undefined, '_dup.md')).rejects.toThrow(/already exists/);
+        });
+        it('detects collision against the alternate extension', async () => {
+            // _dup.md requested but _dup.txt already on disk → still a collision.
+            mockFs.existsSync.mockImplementation((p) => String(p) === '/np/Notes/_dup.txt');
+            await expect(createProjectNote('Title', '', undefined, '_dup.md')).rejects.toThrow(/already exists/);
+        });
+    });
 });
 // ---------------------------------------------------------------------------
 // createCalendarNote
 // ---------------------------------------------------------------------------
 describe('createCalendarNote', () => {
-    it('creates calendar note and returns path', () => {
+    it('creates calendar note and returns path', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        const result = createCalendarNote('20240115', '# Jan 15');
+        const result = await createCalendarNote('20240115', '# Jan 15');
         expect(result).toBe('Calendar/20240115.md');
     });
 });
 // ---------------------------------------------------------------------------
+// createCalendarNoteIfNew — collision-aware variant used by the
+// noteplan_manage_note(action: create) calendar path.
+// ---------------------------------------------------------------------------
+describe('createCalendarNoteIfNew', () => {
+    it('creates a new calendar note when no file exists at either extension', async () => {
+        mockFs.existsSync.mockReturnValue(false);
+        const result = await createCalendarNoteIfNew('2026-W16', '## Goals');
+        expect(result).toBe('Calendar/2026-W16.md');
+        expect(mockFs.writeFileSync).toHaveBeenCalled();
+    });
+    it('writes the provided content (empty string allowed)', async () => {
+        mockFs.existsSync.mockReturnValue(false);
+        await createCalendarNoteIfNew('2026-Q2', '');
+        const calls = mockFs.writeFileSync.mock.calls;
+        expect(calls[0]?.[1]).toBe('');
+    });
+    it('rejects when a calendar note already exists at the same extension', async () => {
+        mockFs.existsSync.mockImplementation((p) => String(p) === '/np/Calendar/2026-W16.md');
+        await expect(createCalendarNoteIfNew('2026-W16', '')).rejects.toThrow(/already exists/);
+    });
+    it('rejects when a calendar note exists at the alternate extension', async () => {
+        mockFs.existsSync.mockImplementation((p) => String(p) === '/np/Calendar/2026-W16.txt');
+        await expect(createCalendarNoteIfNew('2026-W16', '')).rejects.toThrow(/already exists/);
+    });
+});
+// ---------------------------------------------------------------------------
 // ensureCalendarNote
 // ---------------------------------------------------------------------------
 describe('ensureCalendarNote', () => {
-    it('returns existing note path when found', () => {
-        vi.mocked(getCalendarNote).mockReturnValueOnce({
+    it('returns existing note path when found', async () => {
+        vi.mocked(getCalendarNote).mockResolvedValueOnce({
             filename: 'Calendar/20240115.md',
         });
-        const result = ensureCalendarNote('20240115');
+        const result = await ensureCalendarNote('20240115');
         expect(result).toBe('Calendar/20240115.md');
         expect(mockFs.writeFileSync).not.toHaveBeenCalled();
     });
-    it('creates new note when none exists', () => {
-        vi.mocked(getCalendarNote).mockReturnValueOnce(null);
+    it('creates new note when none exists', async () => {
+        vi.mocked(getCalendarNote).mockResolvedValueOnce(null);
         mockFs.existsSync.mockReturnValue(false);
-        const result = ensureCalendarNote('20240115');
+        const result = await ensureCalendarNote('20240115');
         expect(result).toBe('Calendar/20240115.md');
         expect(mockFs.writeFileSync).toHaveBeenCalled();
     });
@@ -191,70 +327,70 @@ describe('ensureCalendarNote', () => {
 // appendToNote
 // ---------------------------------------------------------------------------
 describe('appendToNote', () => {
-    it('appends content to existing note', () => {
+    it('appends content to existing note', async () => {
         mockFs.existsSync.mockReturnValue(true);
         mockFs.readFileSync.mockReturnValue('existing\n');
-        appendToNote('Notes/test.md', 'appended');
+        await appendToNote('Notes/test.md', 'appended');
         const written = mockFs.writeFileSync.mock.calls[0]?.[1];
         expect(written).toBe('existing\nappended');
     });
-    it('adds newline before content if note does not end with one', () => {
+    it('adds newline before content if note does not end with one', async () => {
         mockFs.existsSync.mockReturnValue(true);
         mockFs.readFileSync.mockReturnValue('existing');
-        appendToNote('Notes/test.md', 'appended');
+        await appendToNote('Notes/test.md', 'appended');
         const written = mockFs.writeFileSync.mock.calls[0]?.[1];
         expect(written).toBe('existing\nappended');
     });
-    it('throws if note does not exist', () => {
+    it('throws if note does not exist', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        expect(() => appendToNote('Notes/nope.md', 'x')).toThrow('Note not found');
+        await expect(appendToNote('Notes/nope.md', 'x')).rejects.toThrow('Note not found');
     });
 });
 // ---------------------------------------------------------------------------
 // prependToNote
 // ---------------------------------------------------------------------------
 describe('prependToNote', () => {
-    it('inserts after frontmatter', () => {
+    it('inserts after frontmatter', async () => {
         mockFs.existsSync.mockReturnValue(true);
         mockFs.readFileSync.mockReturnValue('---\ntitle: X\n---\nbody');
-        prependToNote('Notes/test.md', 'PREPENDED');
+        await prependToNote('Notes/test.md', 'PREPENDED');
         const written = mockFs.writeFileSync.mock.calls[0]?.[1];
         // lines: ['---', 'title: X', '---', 'body']
         // insertIndex = 3, so content goes at index 3
         expect(written).toBe('---\ntitle: X\n---\nPREPENDED\nbody');
     });
-    it('inserts at top if no frontmatter', () => {
+    it('inserts at top if no frontmatter', async () => {
         mockFs.existsSync.mockReturnValue(true);
         mockFs.readFileSync.mockReturnValue('# Title\nBody');
-        prependToNote('Notes/test.md', 'PREPENDED');
+        await prependToNote('Notes/test.md', 'PREPENDED');
         const written = mockFs.writeFileSync.mock.calls[0]?.[1];
         expect(written).toBe('PREPENDED\n# Title\nBody');
     });
-    it('throws if note does not exist', () => {
+    it('throws if note does not exist', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        expect(() => prependToNote('Notes/nope.md', 'x')).toThrow('Note not found');
+        await expect(prependToNote('Notes/nope.md', 'x')).rejects.toThrow('Note not found');
     });
 });
 // ---------------------------------------------------------------------------
 // updateNote
 // ---------------------------------------------------------------------------
 describe('updateNote', () => {
-    it('replaces entire note content', () => {
+    it('replaces entire note content', async () => {
         mockFs.existsSync.mockReturnValue(true);
-        updateNote('Notes/test.md', 'new content');
+        await updateNote('Notes/test.md', 'new content');
         const written = mockFs.writeFileSync.mock.calls[0]?.[1];
         expect(written).toBe('new content');
     });
-    it('throws if note does not exist', () => {
+    it('throws if note does not exist', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        expect(() => updateNote('Notes/nope.md', 'x')).toThrow('Note not found');
+        await expect(updateNote('Notes/nope.md', 'x')).rejects.toThrow('Note not found');
     });
 });
 // ---------------------------------------------------------------------------
 // deleteNote
 // ---------------------------------------------------------------------------
 describe('deleteNote', () => {
-    it('moves file to @Trash folder', () => {
+    it('moves file to @Trash folder', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/test.md')
@@ -263,21 +399,21 @@ describe('deleteNote', () => {
                 return true;
             return false; // trash target does not exist yet
         });
-        const result = deleteNote('Notes/test.md');
+        const result = await deleteNote('Notes/test.md');
         expect(result).toBe(path.join('Notes', '@Trash', 'test.md'));
         expect(mockFs.renameSync).toHaveBeenCalledWith('/np/Notes/test.md', '/np/Notes/@Trash/test.md');
     });
-    it('creates @Trash if it does not exist', () => {
+    it('creates @Trash if it does not exist', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/test.md')
                 return true;
             return false;
         });
-        deleteNote('Notes/test.md');
+        await deleteNote('Notes/test.md');
         expect(mockFs.mkdirSync).toHaveBeenCalledWith('/np/Notes/@Trash', { recursive: true });
     });
-    it('handles duplicate names in trash (appends -1, -2, etc.)', () => {
+    it('handles duplicate names in trash (appends -1, -2, etc.)', async () => {
         let callCount = 0;
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
@@ -293,14 +429,14 @@ describe('deleteNote', () => {
                 return false; // free
             return false;
         });
-        const result = deleteNote('Notes/test.md');
+        const result = await deleteNote('Notes/test.md');
         expect(result).toBe(path.join('Notes', '@Trash', 'test-2.md'));
     });
-    it('throws if file does not exist', () => {
+    it('throws if file does not exist', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        expect(() => deleteNote('Notes/nope.md')).toThrow('Note not found');
+        await expect(deleteNote('Notes/nope.md')).rejects.toThrow('Note not found');
     });
-    it('uses EPERM fallback for moveFile (copy + delete)', () => {
+    it('uses EPERM fallback for moveFile (copy + delete)', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/test.md')
@@ -313,11 +449,11 @@ describe('deleteNote', () => {
         mockFs.renameSync.mockImplementationOnce(() => {
             throw eperm;
         });
-        deleteNote('Notes/test.md');
+        await deleteNote('Notes/test.md');
         expect(mockFs.copyFileSync).toHaveBeenCalledWith('/np/Notes/test.md', '/np/Notes/@Trash/test.md');
         expect(mockFs.unlinkSync).toHaveBeenCalledWith('/np/Notes/test.md');
     });
-    it('uses EXDEV fallback for moveFile (copy + delete)', () => {
+    it('uses EXDEV fallback for moveFile (copy + delete)', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/test.md')
@@ -330,10 +466,92 @@ describe('deleteNote', () => {
         mockFs.renameSync.mockImplementationOnce(() => {
             throw exdev;
         });
-        deleteNote('Notes/test.md');
+        await deleteNote('Notes/test.md');
         expect(mockFs.copyFileSync).toHaveBeenCalled();
         expect(mockFs.unlinkSync).toHaveBeenCalled();
     });
+    it('also trashes the sibling _attachments folder', async () => {
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s === '/np/Notes/Photo.md')
+                return true;
+            if (s === '/np/Notes/Photo_attachments')
+                return true;
+            if (s === '/np/Notes/@Trash')
+                return true;
+            return false;
+        });
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        await deleteNote('Notes/Photo.md');
+        const renameCalls = mockFs.renameSync.mock.calls.map((c) => [String(c[0]), String(c[1])]);
+        expect(renameCalls).toContainEqual(['/np/Notes/Photo.md', '/np/Notes/@Trash/Photo.md']);
+        expect(renameCalls).toContainEqual([
+            '/np/Notes/Photo_attachments',
+            '/np/Notes/@Trash/Photo_attachments',
+        ]);
+    });
+    it('matches the disambiguated trash basename when the note collides', async () => {
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s === '/np/Notes/Dup.md')
+                return true;
+            if (s === '/np/Notes/Dup_attachments')
+                return true;
+            if (s === '/np/Notes/@Trash')
+                return true;
+            if (s === '/np/Notes/@Trash/Dup.md')
+                return true; // collision → suffix to Dup-1
+            return false;
+        });
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        const result = await deleteNote('Notes/Dup.md');
+        expect(result).toBe(path.join('Notes', '@Trash', 'Dup-1.md'));
+        const renameCalls = mockFs.renameSync.mock.calls.map((c) => [String(c[0]), String(c[1])]);
+        // The attachments folder follows the disambiguated note name so a
+        // restore would still find them sitting next to the .md file.
+        expect(renameCalls).toContainEqual([
+            '/np/Notes/Dup_attachments',
+            '/np/Notes/@Trash/Dup-1_attachments',
+        ]);
+    });
+    // When trash collision suffixes the basename (Dup → Dup-1), the in-content
+    // attachment links still point at the original Dup_attachments/. Without
+    // rewriting them, restoring would produce broken images.
+    it('rewrites in-content attachment links when the trash basename gets a suffix', async () => {
+        let onDiskContent = '# Dup\n\n![pic](Dup_attachments/photo.png)\n[file](Dup_attachments/notes.pdf)\n';
+        let trashed = false;
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s === '/np/Notes/Dup.md')
+                return !trashed;
+            if (s === '/np/Notes/@Trash/Dup-1.md')
+                return trashed;
+            if (s === '/np/Notes/@Trash')
+                return true;
+            if (s === '/np/Notes/@Trash/Dup.md')
+                return true; // forces -1 suffix
+            return false;
+        });
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        mockFs.renameSync.mockImplementation((from, to) => {
+            if (String(from) === '/np/Notes/Dup.md' && String(to) === '/np/Notes/@Trash/Dup-1.md') {
+                trashed = true;
+            }
+        });
+        mockFs.readFileSync.mockImplementation((p) => {
+            if (String(p) === '/np/Notes/@Trash/Dup-1.md')
+                return onDiskContent;
+            throw new Error('unexpected read: ' + p);
+        });
+        mockFs.writeFileSync.mockImplementation((p, content) => {
+            if (String(p) === '/np/Notes/@Trash/Dup-1.md')
+                onDiskContent = content;
+        });
+        await deleteNote('Notes/Dup.md');
+        expect(onDiskContent).toContain('Dup-1_attachments/photo.png');
+        expect(onDiskContent).toContain('Dup-1_attachments/notes.pdf');
+        expect(onDiskContent).not.toContain('Dup_attachments/');
+    });
 });
 // ---------------------------------------------------------------------------
 // previewMoveLocalNote
@@ -348,28 +566,28 @@ describe('previewMoveLocalNote', () => {
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
     }
-    it('returns preview with fromFilename, toFilename, destinationFolder', () => {
+    it('returns preview with fromFilename, toFilename, destinationFolder', async () => {
         setupMovePreview();
-        const result = previewMoveLocalNote('Notes/test.md', 'Notes/Work');
+        const result = await previewMoveLocalNote('Notes/test.md', 'Notes/Work');
         expect(result.fromFilename).toBe(path.join('Notes', 'test.md'));
         expect(result.toFilename).toBe(path.join('Notes', 'Work', 'test.md'));
         expect(result.destinationFolder).toBe('Notes/Work');
     });
-    it('validates source exists', () => {
+    it('validates source exists', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        expect(() => previewMoveLocalNote('Notes/nope.md', 'Notes/Work')).toThrow('Note not found');
+        await expect(previewMoveLocalNote('Notes/nope.md', 'Notes/Work')).rejects.toThrow('Note not found');
     });
-    it('rejects directories', () => {
+    it('rejects directories', async () => {
         mockFs.existsSync.mockReturnValue(true);
         mockFs.statSync.mockReturnValue({ isDirectory: () => true, isFile: () => false });
-        expect(() => previewMoveLocalNote('Notes/folder', 'Notes/Work')).toThrow('Not a note file');
+        await expect(previewMoveLocalNote('Notes/folder', 'Notes/Work')).rejects.toThrow('Not a note file');
     });
-    it('rejects if source is outside Notes folder', () => {
+    it('rejects if source is outside Notes folder', async () => {
         mockFs.existsSync.mockReturnValue(true);
         mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
-        expect(() => previewMoveLocalNote('Calendar/20240101.md', 'Notes/Work')).toThrow('must be inside Notes');
+        await expect(previewMoveLocalNote('Calendar/20240101.md', 'Notes/Work')).rejects.toThrow('must be inside Notes');
     });
-    it('rejects if already at destination', () => {
+    it('rejects if already at destination', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/Work/test.md')
@@ -377,9 +595,9 @@ describe('previewMoveLocalNote', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
-        expect(() => previewMoveLocalNote('Notes/Work/test.md', 'Notes/Work')).toThrow('already in the destination');
+        await expect(previewMoveLocalNote('Notes/Work/test.md', 'Notes/Work')).rejects.toThrow('already in the destination');
     });
-    it('rejects if conflict at destination', () => {
+    it('rejects if conflict at destination', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/test.md')
@@ -389,25 +607,25 @@ describe('previewMoveLocalNote', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
-        expect(() => previewMoveLocalNote('Notes/test.md', 'Notes/Work')).toThrow('already exists at destination');
+        await expect(previewMoveLocalNote('Notes/test.md', 'Notes/Work')).rejects.toThrow('already exists at destination');
     });
-    it('handles folder input without Notes/ prefix', () => {
+    it('handles folder input without Notes/ prefix', async () => {
         setupMovePreview();
-        const result = previewMoveLocalNote('Notes/test.md', 'Work');
+        const result = await previewMoveLocalNote('Notes/test.md', 'Work');
         expect(result.destinationFolder).toBe('Notes/Work');
     });
-    it('handles folder input with trailing slash', () => {
+    it('handles folder input with trailing slash', async () => {
         setupMovePreview();
-        const result = previewMoveLocalNote('Notes/test.md', 'Work/');
+        const result = await previewMoveLocalNote('Notes/test.md', 'Work/');
         expect(result.destinationFolder).toBe('Notes/Work');
     });
-    it('rejects when destinationFolder looks like a different filename', () => {
+    it('rejects when destinationFolder looks like a different filename', async () => {
         setupMovePreview();
-        expect(() => previewMoveLocalNote('Notes/test.md', 'Work/other.md')).toThrow('must be a folder path, not a filename');
+        await expect(previewMoveLocalNote('Notes/test.md', 'Work/other.md')).rejects.toThrow('must be a folder path, not a filename');
     });
-    it('strips same filename from destination path', () => {
+    it('strips same filename from destination path', async () => {
         setupMovePreview();
-        const result = previewMoveLocalNote('Notes/test.md', 'Work/test.md');
+        const result = await previewMoveLocalNote('Notes/test.md', 'Work/test.md');
         expect(result.destinationFolder).toBe('Notes/Work');
     });
 });
@@ -415,7 +633,7 @@ describe('previewMoveLocalNote', () => {
 // moveLocalNote
 // ---------------------------------------------------------------------------
 describe('moveLocalNote', () => {
-    it('moves note between folders', () => {
+    it('moves note between folders', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/test.md')
@@ -425,12 +643,12 @@ describe('moveLocalNote', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
-        const result = moveLocalNote('Notes/test.md', 'Work');
+        const result = await moveLocalNote('Notes/test.md', 'Work');
         expect(result).toBe(path.join('Notes', 'Work', 'test.md'));
         expect(mockFs.mkdirSync).toHaveBeenCalledWith('/np/Notes/Work', { recursive: true });
         expect(mockFs.renameSync).toHaveBeenCalled();
     });
-    it('creates destination folder if needed', () => {
+    it('creates destination folder if needed', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/test.md')
@@ -438,15 +656,51 @@ describe('moveLocalNote', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
-        moveLocalNote('Notes/test.md', 'NewFolder');
+        await moveLocalNote('Notes/test.md', 'NewFolder');
         expect(mockFs.mkdirSync).toHaveBeenCalled();
     });
+    // Regression: previously the move only relocated the .md file, leaving
+    // the sibling _attachments folder behind and silently breaking every
+    // embedded image/file reference in the moved note.
+    it('also moves the sibling _attachments folder when present', async () => {
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            // Note + its attachments folder both exist; destination is empty.
+            if (s === '/np/Notes/Photo.md')
+                return true;
+            if (s === '/np/Notes/Photo_attachments')
+                return true;
+            return false;
+        });
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        await moveLocalNote('Notes/Photo.md', 'Albums');
+        const renameCalls = mockFs.renameSync.mock.calls.map((c) => [String(c[0]), String(c[1])]);
+        expect(renameCalls).toContainEqual(['/np/Notes/Photo.md', '/np/Notes/Albums/Photo.md']);
+        expect(renameCalls).toContainEqual([
+            '/np/Notes/Photo_attachments',
+            '/np/Notes/Albums/Photo_attachments',
+        ]);
+    });
+    it('skips the attachments move when the folder is absent', async () => {
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s === '/np/Notes/Plain.md')
+                return true;
+            return false; // no Plain_attachments
+        });
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        await moveLocalNote('Notes/Plain.md', 'Work');
+        const renameCalls = mockFs.renameSync.mock.calls.map((c) => [String(c[0]), String(c[1])]);
+        // Only the file itself was moved, no attachments folder rename.
+        expect(renameCalls).toHaveLength(1);
+        expect(renameCalls[0]).toEqual(['/np/Notes/Plain.md', '/np/Notes/Work/Plain.md']);
+    });
 });
 // ---------------------------------------------------------------------------
 // previewRestoreLocalNoteFromTrash
 // ---------------------------------------------------------------------------
 describe('previewRestoreLocalNoteFromTrash', () => {
-    it('returns preview for restoring from trash', () => {
+    it('returns preview for restoring from trash', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/@Trash/test.md')
@@ -454,20 +708,20 @@ describe('previewRestoreLocalNoteFromTrash', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
-        const result = previewRestoreLocalNoteFromTrash('Notes/@Trash/test.md', 'Notes');
+        const result = await previewRestoreLocalNoteFromTrash('Notes/@Trash/test.md', 'Notes');
         expect(result.fromFilename).toBe(path.join('Notes', '@Trash', 'test.md'));
         expect(result.toFilename).toBe(path.join('Notes', 'test.md'));
     });
-    it('throws if source not found', () => {
+    it('throws if source not found', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        expect(() => previewRestoreLocalNoteFromTrash('Notes/@Trash/nope.md', 'Notes')).toThrow('Note not found');
+        await expect(previewRestoreLocalNoteFromTrash('Notes/@Trash/nope.md', 'Notes')).rejects.toThrow('Note not found');
     });
-    it('throws if source is not inside @Trash', () => {
+    it('throws if source is not inside @Trash', async () => {
         mockFs.existsSync.mockReturnValue(true);
         mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
-        expect(() => previewRestoreLocalNoteFromTrash('Notes/test.md', 'Notes')).toThrow('must be inside @Trash');
+        await expect(previewRestoreLocalNoteFromTrash('Notes/test.md', 'Notes')).rejects.toThrow('must be inside @Trash');
     });
-    it('throws if conflict at destination', () => {
+    it('throws if conflict at destination', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/@Trash/test.md')
@@ -477,14 +731,14 @@ describe('previewRestoreLocalNoteFromTrash', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
-        expect(() => previewRestoreLocalNoteFromTrash('Notes/@Trash/test.md', 'Notes')).toThrow('already exists at destination');
+        await expect(previewRestoreLocalNoteFromTrash('Notes/@Trash/test.md', 'Notes')).rejects.toThrow('already exists at destination');
     });
 });
 // ---------------------------------------------------------------------------
 // restoreLocalNoteFromTrash
 // ---------------------------------------------------------------------------
 describe('restoreLocalNoteFromTrash', () => {
-    it('restores note from trash to destination', () => {
+    it('restores note from trash to destination', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/@Trash/test.md')
@@ -494,10 +748,30 @@ describe('restoreLocalNoteFromTrash', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
-        const result = restoreLocalNoteFromTrash('Notes/@Trash/test.md', 'Notes');
+        const result = await restoreLocalNoteFromTrash('Notes/@Trash/test.md', 'Notes');
         expect(result).toBe(path.join('Notes', 'test.md'));
         expect(mockFs.renameSync).toHaveBeenCalled();
     });
+    it('also restores the sibling _attachments folder when present', async () => {
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s === '/np/Notes/@Trash/Photo.md')
+                return true;
+            if (s === '/np/Notes/@Trash/Photo_attachments')
+                return true;
+            if (s === '/np/Notes')
+                return true;
+            return false;
+        });
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        await restoreLocalNoteFromTrash('Notes/@Trash/Photo.md', 'Notes');
+        const renameCalls = mockFs.renameSync.mock.calls.map((c) => [String(c[0]), String(c[1])]);
+        expect(renameCalls).toContainEqual(['/np/Notes/@Trash/Photo.md', '/np/Notes/Photo.md']);
+        expect(renameCalls).toContainEqual([
+            '/np/Notes/@Trash/Photo_attachments',
+            '/np/Notes/Photo_attachments',
+        ]);
+    });
 });
 // ---------------------------------------------------------------------------
 // previewRenameLocalNoteFile
@@ -512,28 +786,28 @@ describe('previewRenameLocalNoteFile', () => {
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
     }
-    it('returns preview with fromFilename and toFilename', () => {
+    it('returns preview with fromFilename and toFilename', async () => {
         setupRenamePreview();
-        const result = previewRenameLocalNoteFile('Notes/old.md', 'new');
+        const result = await previewRenameLocalNoteFile('Notes/old.md', 'new');
         expect(result.fromFilename).toBe(path.join('Notes', 'old.md'));
         expect(result.toFilename).toBe(path.join('Notes', 'new.md'));
     });
-    it('keepExtension=true preserves original extension', () => {
+    it('keepExtension=true preserves original extension', async () => {
         setupRenamePreview();
-        const result = previewRenameLocalNoteFile('Notes/old.md', 'new.txt', true);
+        const result = await previewRenameLocalNoteFile('Notes/old.md', 'new.txt', true);
         // keepExtension=true means keep .md
         expect(result.toFilename).toBe(path.join('Notes', 'new.md'));
     });
-    it('keepExtension=false uses provided extension', () => {
+    it('keepExtension=false uses provided extension', async () => {
         setupRenamePreview();
-        const result = previewRenameLocalNoteFile('Notes/old.md', 'new.txt', false);
+        const result = await previewRenameLocalNoteFile('Notes/old.md', 'new.txt', false);
         expect(result.toFilename).toBe(path.join('Notes', 'new.txt'));
     });
-    it('throws if new name matches current name', () => {
+    it('throws if new name matches current name', async () => {
         setupRenamePreview();
-        expect(() => previewRenameLocalNoteFile('Notes/old.md', 'old')).toThrow('matches current filename');
+        await expect(previewRenameLocalNoteFile('Notes/old.md', 'old')).rejects.toThrow('matches current filename');
     });
-    it('throws if new name already exists', () => {
+    it('throws if new name already exists', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/old.md')
@@ -543,23 +817,23 @@ describe('previewRenameLocalNoteFile', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
-        expect(() => previewRenameLocalNoteFile('Notes/old.md', 'taken')).toThrow('already exists with filename');
+        await expect(previewRenameLocalNoteFile('Notes/old.md', 'taken')).rejects.toThrow('already exists with filename');
     });
-    it('throws if source not found', () => {
+    it('throws if source not found', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        expect(() => previewRenameLocalNoteFile('Notes/nope.md', 'new')).toThrow('Note not found');
+        await expect(previewRenameLocalNoteFile('Notes/nope.md', 'new')).rejects.toThrow('Note not found');
     });
-    it('throws if source is a directory', () => {
+    it('throws if source is a directory', async () => {
         mockFs.existsSync.mockReturnValue(true);
         mockFs.statSync.mockReturnValue({ isDirectory: () => true, isFile: () => false });
-        expect(() => previewRenameLocalNoteFile('Notes/folder', 'new')).toThrow('Not a note file');
+        await expect(previewRenameLocalNoteFile('Notes/folder', 'new')).rejects.toThrow('Not a note file');
     });
-    it('sanitizes special characters in rename', () => {
+    it('sanitizes special characters in rename', async () => {
         setupRenamePreview();
-        const result = previewRenameLocalNoteFile('Notes/old.md', 'he?lo');
+        const result = await previewRenameLocalNoteFile('Notes/old.md', 'he?lo');
         expect(result.toFilename).toBe(path.join('Notes', 'he-lo.md'));
     });
-    it('rejects rename that changes folder', () => {
+    it('rejects rename that changes folder', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/old.md')
@@ -567,14 +841,14 @@ describe('previewRenameLocalNoteFile', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
-        expect(() => previewRenameLocalNoteFile('Notes/old.md', 'OtherFolder/new')).toThrow('must stay in the same folder');
+        await expect(previewRenameLocalNoteFile('Notes/old.md', 'OtherFolder/new')).rejects.toThrow('must stay in the same folder');
     });
 });
 // ---------------------------------------------------------------------------
 // renameLocalNoteFile
 // ---------------------------------------------------------------------------
 describe('renameLocalNoteFile', () => {
-    it('renames file within same folder', () => {
+    it('renames file within same folder', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/old.md')
@@ -582,49 +856,119 @@ describe('renameLocalNoteFile', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
-        const result = renameLocalNoteFile('Notes/old.md', 'new');
+        const result = await renameLocalNoteFile('Notes/old.md', 'new');
         expect(result).toBe(path.join('Notes', 'new.md'));
         expect(mockFs.renameSync).toHaveBeenCalledWith('/np/Notes/old.md', '/np/Notes/new.md');
     });
+    it('also renames the sibling _attachments folder', async () => {
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s === '/np/Notes/old.md')
+                return true;
+            if (s === '/np/Notes/old_attachments')
+                return true;
+            // Renamed-note read-back sees no content (file's been moved) — the
+            // link-rewriter just no-ops. Exercised by the next test.
+            return false;
+        });
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        await renameLocalNoteFile('Notes/old.md', 'fresh');
+        const renameCalls = mockFs.renameSync.mock.calls.map((c) => [String(c[0]), String(c[1])]);
+        expect(renameCalls).toContainEqual(['/np/Notes/old.md', '/np/Notes/fresh.md']);
+        expect(renameCalls).toContainEqual([
+            '/np/Notes/old_attachments',
+            '/np/Notes/fresh_attachments',
+        ]);
+    });
+    it('rewrites attachment-folder references in the renamed note content', async () => {
+        let onDiskContent = '# Old\n\nSee ![pic](old_attachments/photo.png) and [doc](old_attachments/notes.pdf).\n';
+        let renamed = false;
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s === '/np/Notes/old.md')
+                return !renamed; // present until rename
+            if (s === '/np/Notes/fresh.md')
+                return renamed; // appears post-rename
+            if (s === '/np/Notes/old_attachments')
+                return !renamed;
+            if (s === '/np/Notes/fresh_attachments')
+                return renamed;
+            return false;
+        });
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        mockFs.renameSync.mockImplementation((from, to) => {
+            if (String(from) === '/np/Notes/old.md' && String(to) === '/np/Notes/fresh.md') {
+                renamed = true;
+            }
+        });
+        mockFs.readFileSync.mockImplementation((p) => {
+            if (String(p) === '/np/Notes/fresh.md')
+                return onDiskContent;
+            throw new Error('unexpected read: ' + p);
+        });
+        mockFs.writeFileSync.mockImplementation((p, content) => {
+            if (String(p) === '/np/Notes/fresh.md')
+                onDiskContent = content;
+        });
+        await renameLocalNoteFile('Notes/old.md', 'fresh');
+        expect(onDiskContent).toContain('fresh_attachments/photo.png');
+        expect(onDiskContent).toContain('fresh_attachments/notes.pdf');
+        expect(onDiskContent).not.toContain('old_attachments/');
+    });
+    it('skips link rewrite when the basename did not change (extension-only rename)', async () => {
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s === '/np/Notes/Same.md')
+                return true;
+            return false;
+        });
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        await renameLocalNoteFile('Notes/Same.md', 'Same.txt', false);
+        // No content read/write should happen when basename is unchanged —
+        // attachment folder name is identical, so rewriteAttachmentLinks short-
+        // circuits before touching the file.
+        expect(mockFs.readFileSync).not.toHaveBeenCalled();
+        expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+    });
 });
 // ---------------------------------------------------------------------------
 // previewCreateFolder
 // ---------------------------------------------------------------------------
 describe('previewCreateFolder', () => {
-    it('returns normalized folder path', () => {
+    it('returns normalized folder path', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        const result = previewCreateFolder('MyFolder');
+        const result = await previewCreateFolder('MyFolder');
         expect(result).toBe('MyFolder');
     });
-    it('strips Notes/ prefix', () => {
+    it('strips Notes/ prefix', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        const result = previewCreateFolder('Notes/MyFolder');
+        const result = await previewCreateFolder('Notes/MyFolder');
         expect(result).toBe('MyFolder');
     });
-    it('throws if folder already exists', () => {
+    it('throws if folder already exists', async () => {
         mockFs.existsSync.mockReturnValue(true);
-        expect(() => previewCreateFolder('ExistingFolder')).toThrow('Folder already exists');
+        await expect(previewCreateFolder('ExistingFolder')).rejects.toThrow('Folder already exists');
     });
-    it('throws on empty folder path', () => {
-        expect(() => previewCreateFolder('  ')).toThrow();
+    it('throws on empty folder path', async () => {
+        await expect(previewCreateFolder('  ')).rejects.toThrow();
     });
-    it('throws on invalid segments (..)', () => {
-        expect(() => previewCreateFolder('a/../b')).toThrow('invalid');
+    it('throws on invalid segments (..)', async () => {
+        await expect(previewCreateFolder('a/../b')).rejects.toThrow('invalid');
     });
 });
 // ---------------------------------------------------------------------------
 // createFolder
 // ---------------------------------------------------------------------------
 describe('createFolder', () => {
-    it('creates folder under Notes and returns normalized path', () => {
+    it('creates folder under Notes and returns normalized path', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        const result = createFolder('Projects');
+        const result = await createFolder('Projects');
         expect(result).toBe('Projects');
         expect(mockFs.mkdirSync).toHaveBeenCalledWith('/np/Notes/Projects', { recursive: true });
     });
-    it('creates nested folder', () => {
+    it('creates nested folder', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        const result = createFolder('Projects/Work');
+        const result = await createFolder('Projects/Work');
         expect(result).toBe('Projects/Work');
     });
 });
@@ -632,35 +976,35 @@ describe('createFolder', () => {
 // previewDeleteLocalFolder
 // ---------------------------------------------------------------------------
 describe('previewDeleteLocalFolder', () => {
-    it('returns normalized folder path', () => {
+    it('returns normalized folder path', async () => {
         mockFs.existsSync.mockReturnValue(true);
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        const result = previewDeleteLocalFolder('MyFolder');
+        const result = await previewDeleteLocalFolder('MyFolder');
         expect(result).toBe('MyFolder');
     });
-    it('throws if folder does not exist', () => {
+    it('throws if folder does not exist', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        expect(() => previewDeleteLocalFolder('Nope')).toThrow('Folder not found');
+        await expect(previewDeleteLocalFolder('Nope')).rejects.toThrow('Folder not found');
     });
-    it('throws if target is not a directory', () => {
+    it('throws if target is not a directory', async () => {
         mockFs.existsSync.mockReturnValue(true);
         mockFs.statSync.mockReturnValue({ isDirectory: () => false });
-        expect(() => previewDeleteLocalFolder('file.md')).toThrow('Not a folder');
+        await expect(previewDeleteLocalFolder('file.md')).rejects.toThrow('Not a folder');
     });
-    it('cannot delete @Trash folder', () => {
+    it('cannot delete @Trash folder', async () => {
         mockFs.existsSync.mockReturnValue(true);
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        expect(() => previewDeleteLocalFolder('@Trash')).toThrow('Cannot delete the @Trash folder');
+        await expect(previewDeleteLocalFolder('@Trash')).rejects.toThrow('Cannot delete the @Trash folder');
     });
-    it('throws on empty path', () => {
-        expect(() => previewDeleteLocalFolder('  ')).toThrow();
+    it('throws on empty path', async () => {
+        await expect(previewDeleteLocalFolder('  ')).rejects.toThrow();
     });
 });
 // ---------------------------------------------------------------------------
 // deleteLocalFolder
 // ---------------------------------------------------------------------------
 describe('deleteLocalFolder', () => {
-    it('moves folder to @Trash', () => {
+    it('moves folder to @Trash', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/Old')
@@ -672,11 +1016,11 @@ describe('deleteLocalFolder', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        const result = deleteLocalFolder('Old');
+        const result = await deleteLocalFolder('Old');
         expect(result).toBe(path.join('Notes', '@Trash', 'Old'));
         expect(mockFs.renameSync).toHaveBeenCalled();
     });
-    it('handles duplicate folder names in trash', () => {
+    it('handles duplicate folder names in trash', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/Old')
@@ -690,10 +1034,10 @@ describe('deleteLocalFolder', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        const result = deleteLocalFolder('Old');
+        const result = await deleteLocalFolder('Old');
         expect(result).toBe(path.join('Notes', '@Trash', 'Old-1'));
     });
-    it('creates @Trash if it does not exist', () => {
+    it('creates @Trash if it does not exist', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/Old')
@@ -703,7 +1047,7 @@ describe('deleteLocalFolder', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        deleteLocalFolder('Old');
+        await deleteLocalFolder('Old');
         expect(mockFs.mkdirSync).toHaveBeenCalledWith('/np/Notes/@Trash', { recursive: true });
     });
 });
@@ -722,18 +1066,18 @@ describe('previewMoveLocalFolder', () => {
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
     }
-    it('returns preview with fromFolder and toFolder', () => {
+    it('returns preview with fromFolder and toFolder', async () => {
         setupFolderMove();
-        const result = previewMoveLocalFolder('Source', 'Dest');
+        const result = await previewMoveLocalFolder('Source', 'Dest');
         expect(result.fromFolder).toBe('Source');
         expect(result.toFolder).toBe('Dest/Source');
     });
-    it('cannot move folder into itself', () => {
+    it('cannot move folder into itself', async () => {
         mockFs.existsSync.mockReturnValue(true);
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        expect(() => previewMoveLocalFolder('Source', 'Source')).toThrow('Cannot move a folder into itself');
+        await expect(previewMoveLocalFolder('Source', 'Source')).rejects.toThrow('Cannot move a folder into itself');
     });
-    it('cannot move folder into its descendants', () => {
+    it('cannot move folder into its descendants', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/Source')
@@ -743,13 +1087,13 @@ describe('previewMoveLocalFolder', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        expect(() => previewMoveLocalFolder('Source', 'Source/Child')).toThrow('Cannot move a folder into itself');
+        await expect(previewMoveLocalFolder('Source', 'Source/Child')).rejects.toThrow('Cannot move a folder into itself');
     });
-    it('throws if source folder not found', () => {
+    it('throws if source folder not found', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        expect(() => previewMoveLocalFolder('Nope', 'Dest')).toThrow('Source folder not found');
+        await expect(previewMoveLocalFolder('Nope', 'Dest')).rejects.toThrow('Source folder not found');
     });
-    it('throws if destination folder not found', () => {
+    it('throws if destination folder not found', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/Source')
@@ -757,9 +1101,9 @@ describe('previewMoveLocalFolder', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        expect(() => previewMoveLocalFolder('Source', 'NoDest')).toThrow('Destination folder not found');
+        await expect(previewMoveLocalFolder('Source', 'NoDest')).rejects.toThrow('Destination folder not found');
     });
-    it('throws if folder already at destination', () => {
+    it('throws if folder already at destination', async () => {
         // Source is already inside Dest, meaning the target path resolves to the same place
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
@@ -770,9 +1114,9 @@ describe('previewMoveLocalFolder', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        expect(() => previewMoveLocalFolder('Dest/Source', 'Dest')).toThrow('already in the destination');
+        await expect(previewMoveLocalFolder('Dest/Source', 'Dest')).rejects.toThrow('already in the destination');
     });
-    it('throws if conflict at destination', () => {
+    it('throws if conflict at destination', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/Source')
@@ -784,9 +1128,9 @@ describe('previewMoveLocalFolder', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        expect(() => previewMoveLocalFolder('Source', 'Dest')).toThrow('already exists at destination');
+        await expect(previewMoveLocalFolder('Source', 'Dest')).rejects.toThrow('already exists at destination');
     });
-    it('allows moving to Notes root', () => {
+    it('allows moving to Notes root', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/Sub/Source')
@@ -796,7 +1140,7 @@ describe('previewMoveLocalFolder', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        const result = previewMoveLocalFolder('Sub/Source', 'Notes');
+        const result = await previewMoveLocalFolder('Sub/Source', 'Notes');
         expect(result.toFolder).toBe('Source');
         expect(result.destinationFolder).toBe('Notes');
     });
@@ -805,7 +1149,7 @@ describe('previewMoveLocalFolder', () => {
 // moveLocalFolder
 // ---------------------------------------------------------------------------
 describe('moveLocalFolder', () => {
-    it('moves folder to destination', () => {
+    it('moves folder to destination', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/Source')
@@ -815,7 +1159,7 @@ describe('moveLocalFolder', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        const result = moveLocalFolder('Source', 'Dest');
+        const result = await moveLocalFolder('Source', 'Dest');
         expect(result.fromFolder).toBe('Source');
         expect(result.toFolder).toBe('Dest/Source');
         expect(mockFs.renameSync).toHaveBeenCalledWith('/np/Notes/Source', '/np/Notes/Dest/Source');
@@ -834,22 +1178,22 @@ describe('previewRenameLocalFolder', () => {
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
     }
-    it('returns preview with fromFolder and toFolder', () => {
+    it('returns preview with fromFolder and toFolder', async () => {
         setupFolderRename();
-        const result = previewRenameLocalFolder('Old', 'New');
+        const result = await previewRenameLocalFolder('Old', 'New');
         expect(result.fromFolder).toBe('Old');
         expect(result.toFolder).toBe('New');
     });
-    it('sanitizes new folder name', () => {
+    it('sanitizes new folder name', async () => {
         setupFolderRename();
-        const result = previewRenameLocalFolder('Old', 'He?lo');
+        const result = await previewRenameLocalFolder('Old', 'He?lo');
         expect(result.toFolder).toBe('He-lo');
     });
-    it('throws if new name matches current name', () => {
+    it('throws if new name matches current name', async () => {
         setupFolderRename();
-        expect(() => previewRenameLocalFolder('Old', 'Old')).toThrow('matches current name');
+        await expect(previewRenameLocalFolder('Old', 'Old')).rejects.toThrow('matches current name');
     });
-    it('throws if new name already exists', () => {
+    it('throws if new name already exists', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/Old')
@@ -859,17 +1203,17 @@ describe('previewRenameLocalFolder', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        expect(() => previewRenameLocalFolder('Old', 'Taken')).toThrow('already exists');
+        await expect(previewRenameLocalFolder('Old', 'Taken')).rejects.toThrow('already exists');
     });
-    it('throws if source not found', () => {
+    it('throws if source not found', async () => {
         mockFs.existsSync.mockReturnValue(false);
-        expect(() => previewRenameLocalFolder('Nope', 'New')).toThrow('Source folder not found');
+        await expect(previewRenameLocalFolder('Nope', 'New')).rejects.toThrow('Source folder not found');
     });
-    it('throws on empty new name', () => {
+    it('throws on empty new name', async () => {
         setupFolderRename();
-        expect(() => previewRenameLocalFolder('Old', '  ')).toThrow('required');
+        await expect(previewRenameLocalFolder('Old', '  ')).rejects.toThrow('required');
     });
-    it('must stay in same parent folder', () => {
+    it('must stay in same parent folder', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/Old')
@@ -877,14 +1221,14 @@ describe('previewRenameLocalFolder', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        expect(() => previewRenameLocalFolder('Old', 'Other/New')).toThrow('must stay in the same parent folder');
+        await expect(previewRenameLocalFolder('Old', 'Other/New')).rejects.toThrow('must stay in the same parent folder');
     });
 });
 // ---------------------------------------------------------------------------
 // renameLocalFolder
 // ---------------------------------------------------------------------------
 describe('renameLocalFolder', () => {
-    it('renames folder and returns preview', () => {
+    it('renames folder and returns preview', async () => {
         mockFs.existsSync.mockImplementation((p) => {
             const s = String(p);
             if (s === '/np/Notes/Old')
@@ -892,10 +1236,179 @@ describe('renameLocalFolder', () => {
             return false;
         });
         mockFs.statSync.mockReturnValue({ isDirectory: () => true });
-        const result = renameLocalFolder('Old', 'New');
+        const result = await renameLocalFolder('Old', 'New');
         expect(result.fromFolder).toBe('Old');
         expect(result.toFolder).toBe('New');
         expect(mockFs.renameSync).toHaveBeenCalledWith('/np/Notes/Old', '/np/Notes/New');
     });
 });
+// ---------------------------------------------------------------------------
+// Folder access rules — wiring into write paths
+// ---------------------------------------------------------------------------
+import { __resetFolderAccessConfigForTests } from '../utils/folder-access.js';
+describe('folder-access wiring', () => {
+    beforeEach(() => {
+        delete process.env.NOTEPLAN_ALLOWED_FOLDERS;
+        delete process.env.NOTEPLAN_DENIED_FOLDERS;
+        __resetFolderAccessConfigForTests();
+    });
+    it('createProjectNote rejects when target folder is denied', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        await expect(createProjectNote('Diary', '', 'Personal')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+        expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+    });
+    it('createProjectNote allows targets in undenied folders', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        mockFs.existsSync.mockReturnValue(false);
+        const result = await createProjectNote('Plan', '', 'Work');
+        expect(result).toBe(path.join('Notes', 'Work', 'Plan.md'));
+    });
+    it('createCalendarNoteIfNew rejects when Calendar/ is denied', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Calendar';
+        __resetFolderAccessConfigForTests();
+        await expect(createCalendarNoteIfNew('20260507', '')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+    });
+    it('updateNote rejects when the note sits in a denied folder', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        await expect(updateNote('Notes/Personal/Diary.md', 'new content')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+        expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+    });
+    it('deleteNote rejects when the note sits in a denied folder', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        mockFs.existsSync.mockReturnValue(true);
+        await expect(deleteNote('Notes/Personal/Diary.md')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+        expect(mockFs.renameSync).not.toHaveBeenCalled();
+    });
+    it('moveLocalNote rejects when EITHER source or destination is denied', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s === '/np/Notes/Plan.md')
+                return true;
+            if (s === '/np/Notes/Personal/Diary.md')
+                return true;
+            return false;
+        });
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        // Moving INTO a denied folder is rejected.
+        await expect(moveLocalNote('Notes/Plan.md', 'Personal')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+        // Moving OUT of a denied folder is also rejected (would otherwise be
+        // an exfiltration path).
+        await expect(moveLocalNote('Notes/Personal/Diary.md', 'Work')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+    });
+    it('renameLocalNoteFile rejects when the source folder is denied', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        mockFs.existsSync.mockImplementation((p) => {
+            return String(p) === '/np/Notes/Personal/Diary.md';
+        });
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        await expect(renameLocalNoteFile('Notes/Personal/Diary.md', 'Renamed')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+    });
+    it('restoreLocalNoteFromTrash rejects when destination is denied', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        mockFs.existsSync.mockImplementation((p) => {
+            return String(p) === '/np/Notes/@Trash/Diary.md';
+        });
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        await expect(restoreLocalNoteFromTrash('Notes/@Trash/Diary.md', 'Personal')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+    });
+    it('appendToNote rejects when target is in a denied folder', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        await expect(appendToNote('Notes/Personal/Diary.md', 'new line')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+        expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+    });
+    it('prependToNote rejects when target is in a denied folder', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        await expect(prependToNote('Notes/Personal/Diary.md', 'preface')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+        expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+    });
+    it('ensureCalendarNote rejects when Calendar/ is denied (closes the addToToday gap)', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Calendar';
+        __resetFolderAccessConfigForTests();
+        // No existing calendar note → falls through to the create branch
+        // where the assert fires. Without the guard the .md would land on
+        // disk before the downstream writer's own filter could reject.
+        vi.mocked(getCalendarNote).mockResolvedValueOnce(null);
+        await expect(ensureCalendarNote('20260507')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+        expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+    });
+    // Dry-run leak guard: the preview functions used to skip the access check
+    // entirely, so an agent could call them to learn whether a path resolves
+    // (path-existence side channel). The asserts now live inside the preview
+    // functions themselves — both dry-run and execute pass through the same
+    // gate.
+    it('previewMoveLocalNote rejects when destination is denied', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        mockFs.existsSync.mockImplementation((p) => String(p) === '/np/Notes/Plan.md');
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        await expect(previewMoveLocalNote('Notes/Plan.md', 'Personal')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+    });
+    it('previewRestoreLocalNoteFromTrash rejects when destination is denied', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        mockFs.existsSync.mockImplementation((p) => String(p) === '/np/Notes/@Trash/Diary.md');
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        await expect(previewRestoreLocalNoteFromTrash('Notes/@Trash/Diary.md', 'Personal')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+    });
+    it('previewRenameLocalNoteFile rejects when source folder is denied', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        mockFs.existsSync.mockImplementation((p) => String(p) === '/np/Notes/Personal/Diary.md');
+        mockFs.statSync.mockReturnValue({ isDirectory: () => false, isFile: () => true });
+        await expect(previewRenameLocalNoteFile('Notes/Personal/Diary.md', 'Renamed')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+    });
+    // Folder-level operations were initially un-gated, so an agent could
+    // create / delete / rename / move a denied folder outright (or move a
+    // benign folder INTO a denied subtree) and bypass the rule for every
+    // file inside. The asserts now live at the preview layer so dry-run
+    // and execute share the same gate.
+    it('previewCreateFolder rejects when target sits inside a denied subtree', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        mockFs.existsSync.mockReturnValue(false);
+        await expect(previewCreateFolder('Personal/Sub')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+    });
+    it('previewDeleteLocalFolder rejects when target is denied', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.statSync.mockReturnValue({ isDirectory: () => true });
+        await expect(previewDeleteLocalFolder('Personal')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+        expect(mockFs.renameSync).not.toHaveBeenCalled();
+    });
+    it('previewMoveLocalFolder rejects when EITHER source or destination is denied', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s === '/np/Notes/Personal')
+                return true;
+            if (s === '/np/Notes/Work')
+                return true;
+            return false;
+        });
+        mockFs.statSync.mockReturnValue({ isDirectory: () => true });
+        // Moving a denied folder out is rejected (would expose its contents).
+        await expect(previewMoveLocalFolder('Personal', 'Work')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+        // Moving anything INTO a denied subtree is rejected (smuggling).
+        await expect(previewMoveLocalFolder('Work', 'Personal')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+    });
+    it('previewRenameLocalFolder rejects when source folder is denied', async () => {
+        process.env.NOTEPLAN_DENIED_FOLDERS = 'Notes/Personal';
+        __resetFolderAccessConfigForTests();
+        mockFs.existsSync.mockImplementation((p) => String(p) === '/np/Notes/Personal');
+        mockFs.statSync.mockReturnValue({ isDirectory: () => true });
+        await expect(previewRenameLocalFolder('Personal', 'Renamed')).rejects.toThrow(/NOTEPLAN_DENIED_FOLDERS/);
+    });
+});
 //# sourceMappingURL=file-writer.test.js.map