mcp-memory-bucket 0.10.13 → 0.10.15

package/dist/src/attachments/repository.js

@@ -61,8 +61,9 @@ export class AttachmentRepository {
         // (remote/write-order.ts).
         const entry = buildAttachmentEntry(dir, filename, data);
         await writeRemoteThenLocal(() => this.pushAttachmentToRemoteIfNeeded(kind, doc.folder, path.join(dir, entry.filename), data, guessMimeType(entry.filename)), () => {
-            fs.mkdirSync(dir, { recursive: true });
-            fs.writeFileSync(resolveWithinBase(dir, undefined, entry.filename), data);
+            const safePath = resolveWithinBase(dir, undefined, entry.filename);
+            fs.mkdirSync(path.dirname(safePath), { recursive: true }); // creates nested subdirs too, e.g. attachments/references/
+            fs.writeFileSync(safePath, data);
         });
         const existing = doc.attachments ?? [];
         await this.saveAttachmentsList(kind, folder, docIdOrName, [...existing, entry]);
@@ -87,6 +88,7 @@ export class AttachmentRepository {
         };
         const safePath = resolveWithinBase(dir, undefined, filename);
         await writeRemoteThenLocal(() => this.pushAttachmentToRemoteIfNeeded(kind, doc.folder, safePath, data, guessMimeType(filename)), () => {
+            fs.mkdirSync(path.dirname(safePath), { recursive: true }); // harmless if already present; guards a nested dir removed out-of-band
             fs.rmSync(safePath, { force: true });
             fs.writeFileSync(safePath, data);
         });
@@ -106,6 +108,14 @@ export class AttachmentRepository {
         // disk locally.
         await this.trashAttachmentOnRemoteIfNeeded(kind, doc.folder, safePath);
         fs.rmSync(safePath, { force: true });
+        // Clean up now-empty intermediate subdirectories (e.g. attachments/references/ after its last
+        // file is removed) — walks upward from the removed file's own parent dir, stopping at `dir`
+        // (attachments/ itself, which the check below already handles).
+        let cleanupDir = path.dirname(safePath);
+        while (cleanupDir !== dir && fs.existsSync(cleanupDir) && fs.readdirSync(cleanupDir).length === 0) {
+            fs.rmdirSync(cleanupDir);
+            cleanupDir = path.dirname(cleanupDir);
+        }
         const next = (doc.attachments ?? []).filter((a) => a.filename !== filename);
         await this.saveAttachmentsList(kind, folder, docIdOrName, next);
         if (listAttachmentFiles(dir).length === 0) {

package/dist/src/attachments/storage.js

@@ -71,17 +71,20 @@ export function guessMimeType(filename) {
         return MIME_BY_EXT[ext];
     return BINARY_EXTENSIONS.has(ext) ? 'application/octet-stream' : 'text/plain';
 }
+/** `filename` may include a relative subpath (e.g. "references/foo.md") to nest it inside `dir`. */
 export function uniqueFilename(dir, filename) {
     // Validate that the filename doesn't escape the directory
     resolveWithinBase(dir, undefined, filename);
     if (!fs.existsSync(path.join(dir, filename)))
         return filename;
+    const dirPart = path.dirname(filename); // '.' for a bare filename, or e.g. "references"
     const ext = path.extname(filename);
     const base = path.basename(filename, ext);
+    const candidate = (n) => (dirPart === '.' ? `${base}-${n}${ext}` : path.join(dirPart, `${base}-${n}${ext}`));
     let n = 2;
-    while (fs.existsSync(path.join(dir, `${base}-${n}${ext}`)))
+    while (fs.existsSync(path.join(dir, candidate(n))))
         n++;
-    return `${base}-${n}${ext}`;
+    return candidate(n);
 }
 /**
  * Resolves the collision-avoided final filename and builds the resulting AttachmentEntry metadata
@@ -108,15 +111,27 @@ export function buildAttachmentEntry(dir, filename, data) {
 /** `dir` is the attachments directory itself, as returned by attachmentsDirFor. */
 export function writeAttachmentFile(dir, filename, data) {
     const entry = buildAttachmentEntry(dir, filename, data);
-    fs.mkdirSync(dir, { recursive: true });
     const safePath = resolveWithinBase(dir, undefined, entry.filename);
+    fs.mkdirSync(path.dirname(safePath), { recursive: true }); // creates nested subdirs too, e.g. attachments/references/
     fs.writeFileSync(safePath, data);
     return entry;
 }
+/** Recurses into subdirectories — an attachment's `filename` may be a nested relative path (e.g. "references/foo.md"). Returns paths relative to `dir`. */
 export function listAttachmentFiles(dir) {
     if (!fs.existsSync(dir))
         return [];
-    return fs.readdirSync(dir).filter((name) => fs.statSync(path.join(dir, name)).isFile());
+    const out = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            for (const nested of listAttachmentFiles(full))
+                out.push(path.join(entry.name, nested));
+        }
+        else if (entry.isFile()) {
+            out.push(entry.name);
+        }
+    }
+    return out;
 }
 /**
  * Reconciles a memory doc's attachments wrapper directory after an EXTERNAL rename (the file was

package/dist/src/attachments/tools.js

@@ -15,7 +15,7 @@ export function registerAttachmentTools(mcp, attachRepo) {
         kind: kindSchema,
         ...folderSchema,
         doc: z.string().describe('memory doc filename or skill name'),
-        filename: z.string(),
+        filename: z.string().describe('filename to store it under — may include a relative subpath (e.g. "references/foo.md") to nest it inside attachments/'),
         file_path: z.string().describe('local filesystem path to the file to attach'),
     }, async ({ kind, folder, doc, filename, file_path }) => {
         try {
@@ -41,7 +41,7 @@ export function registerAttachmentTools(mcp, attachRepo) {
             return { content: [{ type: 'text', text: err.message }], isError: true };
         }
     });
-    mcp.tool('attachment_update', "Replaces an attachment's content in place.", { kind: kindSchema, ...folderSchema, doc: z.string(), filename: z.string(), file_path: z.string() }, async ({ kind, folder, doc, filename, file_path }) => {
+    mcp.tool('attachment_update', "Replaces an attachment's content in place.", { kind: kindSchema, ...folderSchema, doc: z.string(), filename: z.string().describe('may include a relative subpath (e.g. "references/foo.md")'), file_path: z.string() }, async ({ kind, folder, doc, filename, file_path }) => {
         try {
             assertFileSizeOk(file_path);
             const data = fs.readFileSync(file_path);

package/dist/src/remote/remote-sync.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { upsertFile, removeFile, walkMarkdownFiles, walkAttachmentFiles } from '../store/sync.js';
+import { upsertFile, removeFile, walkMarkdownFiles, walkAttachmentFiles, walkSkillSiblingFiles } from '../store/sync.js';
 import { getLastChanged, getChangedSince, readFile, FolderfooAuthError } from './folderfoo-client.js';
 import { isUnderAttachmentsDir } from '../attachments/storage.js';
 // Fixed for every remote source in v1 - no per-source tuning knob, per the
@@ -79,6 +79,13 @@ async function reconcileDeletions(db, spec, folder, credentialsBaseDir) {
     if (!fs.existsSync(folder.mirrorDir))
         return;
     for (const mirrorFilePath of walkMarkdownFiles(folder.mirrorDir)) {
+        // For skills, this loop must only ever act on SKILL.md itself — a sibling .md file (e.g.
+        // references/foo.md) is handled by the dedicated sibling-diff loop below instead, which compares
+        // it against the remote listing under its own real name (no remoteFilename translation, unlike
+        // SKILL.md's fixed "SKILL" remote name). Without this guard, a sibling .md would look
+        // deleted-remotely here (it was never pushed under "SKILL") and get wrongly deleted.
+        if (spec.table === 'skills' && path.basename(mirrorFilePath) !== 'SKILL.md')
+            continue;
         const relPath = path.relative(folder.mirrorDir, mirrorFilePath);
         // remoteFiles' entries are keyed by folderfoo's own filename grammar, which may differ from
         // the local mirror's filename (see spec.remoteFilename's doc comment — skills push under the
@@ -112,6 +119,24 @@ async function reconcileDeletions(db, spec, folder, credentialsBaseDir) {
         if (!remoteRelPaths.has(relPath))
             fs.unlinkSync(mirrorFilePath);
     }
+    // Prunes a stale SKILL SIBLING file (references/foo.md, scripts/bar.mjs, etc. — anything under a
+    // skill's own directory besides SKILL.md itself and attachments/) once it's gone from folderfoo's
+    // listing. Reuses the SAME remoteRelPaths already fetched above — no extra network call. Siblings
+    // are never indexed as their own doc row (see walkSkillSiblingFiles's doc comment), so like
+    // attachments there's no removeFile/DB row to clean up, just the mirror file itself. Pushed under
+    // its own literal filename (see pushSkillSiblingFileIfNeeded) with no remoteFilename translation,
+    // so a plain relative-path membership check is enough, same as the attachment loop above.
+    if (spec.table === 'skills') {
+        const skillRows = db.prepare(`SELECT source_path FROM skills WHERE folder = ?`).all(folder.name);
+        for (const { source_path: sourcePath } of skillRows) {
+            const skillDir = path.dirname(sourcePath);
+            for (const siblingPath of walkSkillSiblingFiles(skillDir)) {
+                const relPath = path.relative(folder.mirrorDir, siblingPath);
+                if (!remoteRelPaths.has(relPath))
+                    fs.unlinkSync(siblingPath);
+            }
+        }
+    }
     if (spec.table === 'memory_docs') {
         reconcileOrphanedAttachmentWrappers(folder.mirrorDir);
         reconcileMisindexedAttachmentRows(db, folder.mirrorDir);

package/dist/src/server.js

@@ -1,3 +1,4 @@
+import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import express from 'express';
@@ -6,7 +7,7 @@ import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/
 import { loadConfig } from './config.js';
 import { openCache } from './store/db.js';
 import { initialScan, watchSources, skillSyncSpec, memorySyncSpec } from './store/sync.js';
-import { SkillRepository } from './skills/repository.js';
+import { SkillRepository, findSkillDirAncestor } from './skills/repository.js';
 import { MemoryRepository } from './memory/repository.js';
 import { registerSkillTools } from './skills/tools.js';
 import { registerMemoryTools } from './memory/tools.js';
@@ -68,12 +69,41 @@ if (config.folderfooHost) {
 const skillFolders = [{ name: 'builtin', path: builtinSkillsDir }, ...config.skillFolders];
 const skillSpec = skillSyncSpec(skillFolders);
 const memorySpec = memorySyncSpec(config.memoryFolders);
+// Built before watchSources below so onUnmatchedFileChange's closure can reference skillRepo —
+// SkillRepository's own constructor doesn't need the watcher itself (that's attached separately via
+// setWatcher once it exists).
+const skillRepo = new SkillRepository(db, skillFolders, config.remoteSkillFolders, config.baseDir, identity);
+const memoryRepo = new MemoryRepository(db, config.memoryFolders, config.remoteMemoryFolders, config.baseDir, identity);
+// Reacts to a direct filesystem write under an existing skill's directory (any file that isn't
+// SKILL.md itself, outside attachments/) that bypassed every MCP tool — e.g. an agent using a
+// generic file-write tool to drop references/foo.md straight into a skill's directory. Pushes/
+// re-pushes it to the skill's remote folder if that folder is remote-backed (no-op for a local
+// folder — pushSkillSiblingFileIfNeeded/trashSkillSiblingFileIfNeeded already guard on that), and
+// trashes it remotely on unlink. Kept out of the generic sync.ts layer since "parent dir contains
+// SKILL.md" is a skill-specific convention.
+skillSpec.onUnmatchedFileChange = (filePath, changeType) => {
+    if (path.basename(filePath) === '.last-synced')
+        return; // remote poller's own watermark sidecar file, not skill content
+    const folder = skillFolders.find((f) => filePath.startsWith(f.path + path.sep));
+    if (!folder)
+        return;
+    const skillDir = findSkillDirAncestor(filePath, folder.path);
+    if (!skillDir)
+        return; // not actually under any skill's own directory (e.g. a stray file at the folder root)
+    if (changeType === 'unlink') {
+        skillRepo.trashSkillSiblingFileIfNeeded(folder.name, filePath).catch((err) => console.error(`[memory-bucket] failed to trash sibling ${filePath}:`, err));
+    }
+    else {
+        fs.promises
+            .readFile(filePath)
+            .then((data) => skillRepo.pushSkillSiblingFileIfNeeded(folder.name, filePath, data))
+            .catch((err) => console.error(`[memory-bucket] failed to push sibling ${filePath}:`, err));
+    }
+};
 initialScan(db, skillSpec);
 initialScan(db, memorySpec);
 const skillWatcher = watchSources(db, skillSpec);
 const memoryWatcher = watchSources(db, memorySpec);
-const skillRepo = new SkillRepository(db, skillFolders, config.remoteSkillFolders, config.baseDir, identity);
-const memoryRepo = new MemoryRepository(db, config.memoryFolders, config.remoteMemoryFolders, config.baseDir, identity);
 skillRepo.setWatcher(skillWatcher);
 memoryRepo.setWatcher(memoryWatcher);
 const attachmentRepo = new AttachmentRepository(memoryRepo, skillRepo, db);

package/dist/src/shared/bucket-folder-tool.js

@@ -73,7 +73,7 @@ export function registerBucketFolderTools(mcp, config, skillRepo, memoryRepo, db
     mcp.tool('bucket_connect_remote_folder', "Connects one of the user's own folderfoo folders (see bucket_list_remote_folders for `folderPath` values) as a new skill or memory source — syncs like a folder added via bucket_create_folder, so skill_create/memory_create can target it via `folder` and edits push back to folderfoo automatically. Idempotent: if this exact folderPath is already connected under this kind, returns that existing folder instead of creating a duplicate. Same login requirement as bucket_list_remote_folders.", {
         kind: KIND,
         folderPath: z.string().describe("a `path` value from bucket_list_remote_folders ('' for the folderfoo root)"),
-        name: z.string().optional().describe("name for the folder; defaults to a sanitized version of folderPath's last segment"),
+        name: z.string().optional().describe("name for the folder; defaults to a sanitized version of folderPath's last segment. Auto-suffixed with the connecting username if it collides with a folder connected under a different folderfoo login."),
     }, async ({ kind, folderPath, name }) => {
         if (config.folderfooMode === 'off' || !config.folderfooHost) {
             return {
@@ -99,13 +99,19 @@ export function registerBucketFolderTools(mcp, config, skillRepo, memoryRepo, db
         if (!folderName) {
             return { content: [{ type: 'text', text: 'could not derive a valid folder name — provide one explicitly' }], isError: true };
         }
-        const mirrorDir = mirrorDirFor(config.baseDir, current.mode, current.username, folderName);
-        const remote = { name: folderName, server, tenantId: TENANT_ID, folderPath, mirrorDir, mode: current.mode, username: current.username };
         try {
+            // Resolved FIRST (before deriving mirrorDir) — auto-suffixes the requested name when it
+            // collides with a folder connected under a DIFFERENT folderfoo login (e.g. two different users
+            // each naturally wanting "bbbmemz"), still rejecting a collision against the CALLER's own
+            // identity. Mirrors the web route's POST /api/remote-folders logic (routes.ts) — see
+            // repo.resolveAvailableName's doc comment.
+            const resolvedName = repo.resolveAvailableName(folderName, current.username);
+            const mirrorDir = mirrorDirFor(config.baseDir, current.mode, current.username, resolvedName);
+            const remote = { name: resolvedName, server, tenantId: TENANT_ID, folderPath, mirrorDir, mode: current.mode, username: current.username };
             repo.registerRemoteFolder(remote);
-            saveRemoteFolder(config, kind, { name: folderName, server, tenantId: TENANT_ID, folderPath, mode: current.mode, username: current.username });
+            saveRemoteFolder(config, kind, { name: resolvedName, server, tenantId: TENANT_ID, folderPath, mode: current.mode, username: current.username });
             await pollOne(db, specFor(kind), remote, config.baseDir);
-            return { content: [{ type: 'text', text: JSON.stringify({ name: folderName, server, tenantId: TENANT_ID, folderPath, kind }, null, 2) }] };
+            return { content: [{ type: 'text', text: JSON.stringify({ name: resolvedName, server, tenantId: TENANT_ID, folderPath, kind }, null, 2) }] };
         }
         catch (err) {
             return { content: [{ type: 'text', text: err.message }], isError: true };

package/dist/src/skills/repository.js

@@ -4,11 +4,12 @@ import matter from 'gray-matter';
 import { writeMarkdownFile, formatMarkdownFile } from '../store/markdown-file.js';
 import { assertValidSkillName } from '../store/skill-name.js';
 import { resolveWithinBase } from '../store/safe-path.js';
-import { upsertFile, removeFile, scanSingleFolder, unregisterFolder, skillSyncSpec } from '../store/sync.js';
+import { upsertFile, removeFile, scanSingleFolder, unregisterFolder, skillSyncSpec, walkSkillSiblingFiles } from '../store/sync.js';
 import { SearchQueryError, sanitizeFtsQuery } from '../store/search.js';
 import { applyBodyEdits } from '../shared/body-edits.js';
 import { rebaseFolderPath } from '../config.js';
 import { readFile as readRemoteFile, writeFile as writeRemoteFile, writeBinaryFile as writeRemoteBinaryFile, trashFile as trashRemoteFile, trashFolder as trashRemoteFolder, renameFolder as renameRemoteFolder, joinRemoteFolderPath, assertRemoteFolderExists } from '../remote/folderfoo-client.js';
+import { guessMimeType } from '../attachments/storage.js';
 import { isFolderVisible } from '../remote/identity.js';
 import { writeRemoteThenLocal } from '../remote/write-order.js';
 function rowToDoc(row) {
@@ -119,6 +120,35 @@ export class SkillRepository {
         const dirRelPath = joinRemoteFolderPath(remote.folderPath, path.relative(remote.mirrorDir, path.dirname(attachmentFilePath)));
         await trashRemoteFile(remote.server, this.credentialsBaseDir, remote.tenantId, dirRelPath, path.basename(attachmentFilePath), remote.owner);
     }
+    /**
+     * Pushes one arbitrary file (by its LOCAL absolute path) that lives alongside SKILL.md in a
+     * skill's own directory — the sibling-file counterpart to pushToRemoteIfNeeded (SKILL.md only,
+     * fixed remote name 'SKILL') and pushAttachmentIfNeeded (attachments/ only). Pushed under its own
+     * real filename, since folderfoo has no reason to rename it. No-op for a local folder.
+     */
+    async pushSkillSiblingFileIfNeeded(folderName, filePath, content) {
+        const remote = this.remoteFor(folderName);
+        if (!remote || !this.credentialsBaseDir)
+            return;
+        await assertRemoteFolderExists(remote.server, this.credentialsBaseDir, remote.tenantId, remote.folderPath, folderName, remote.owner);
+        const dirRelPath = joinRemoteFolderPath(remote.folderPath, path.relative(remote.mirrorDir, path.dirname(filePath)));
+        const name = path.basename(filePath);
+        if (typeof content === 'string') {
+            await writeRemoteFile(remote.server, this.credentialsBaseDir, remote.tenantId, dirRelPath, name, content, remote.owner);
+        }
+        else {
+            await writeRemoteBinaryFile(remote.server, this.credentialsBaseDir, remote.tenantId, dirRelPath, name, content, guessMimeType(name), remote.owner);
+        }
+    }
+    /** Trashes one sibling file's remote copy on folderfoo — the sibling-file counterpart to trashAttachmentIfNeeded. No-op for a local folder. */
+    async trashSkillSiblingFileIfNeeded(folderName, filePath) {
+        const remote = this.remoteFor(folderName);
+        if (!remote || !this.credentialsBaseDir)
+            return;
+        await assertRemoteFolderExists(remote.server, this.credentialsBaseDir, remote.tenantId, remote.folderPath, folderName, remote.owner);
+        const dirRelPath = joinRemoteFolderPath(remote.folderPath, path.relative(remote.mirrorDir, path.dirname(filePath)));
+        await trashRemoteFile(remote.server, this.credentialsBaseDir, remote.tenantId, dirRelPath, path.basename(filePath), remote.owner);
+    }
     /** Attaches the live chokidar watcher so addFolder/removeFolder can mutate it without a restart. */
     setWatcher(watcher) {
         this.watcher = watcher;
@@ -451,6 +481,13 @@ export class SkillRepository {
             fs.writeFileSync(filePath, fileContents, 'utf-8');
         });
         upsertFile(this.db, this.syncSpec, filePath);
+        // Pushes any sibling files (references/, scripts/, etc.) an agent already populated the skill
+        // dir with before calling create() — e.g. a portable agentskills.io skill assembled on disk
+        // first. No-op when the dir was empty besides SKILL.md, and a no-op push for a local folder.
+        for (const siblingPath of walkSkillSiblingFiles(skillDir)) {
+            const data = fs.readFileSync(siblingPath);
+            await this.pushSkillSiblingFileIfNeeded(targetFolder.name, siblingPath, data);
+        }
         return { ...fm, body, paused: false };
     }
     /**
@@ -681,3 +718,23 @@ function stripSourcePath(fm) {
     const { source_path: _sp, folder: _folder, ...rest } = fm;
     return rest;
 }
+/**
+ * Walks upward from `filePath` looking for the nearest ancestor directory that contains a
+ * SKILL.md — i.e. "is this file a sibling somewhere under some skill's own directory." A sibling
+ * can be arbitrarily deep (e.g. references/sub/foo.md), so this must walk multiple levels up, not
+ * just check the immediate parent. Stops at `folderRoot` (the configured skill folder's own root)
+ * so a stray file sitting directly at the folder root — not under any skill's directory at all —
+ * correctly returns null instead of walking past the folder entirely.
+ */
+export function findSkillDirAncestor(filePath, folderRoot) {
+    let dir = path.dirname(filePath);
+    const root = path.resolve(folderRoot);
+    while (dir.startsWith(root)) {
+        if (fs.existsSync(path.join(dir, 'SKILL.md')))
+            return dir;
+        if (dir === root)
+            break;
+        dir = path.dirname(dir);
+    }
+    return null;
+}

package/dist/src/store/sync.js

@@ -19,7 +19,15 @@ export function skillSyncSpec(sources) {
         matchesFile: (filePath) => path.basename(filePath) === 'SKILL.md',
         columns: skillColumns,
         getId: (fm) => fm.name,
-        remoteFilename: { toRemote: () => 'SKILL', toLocal: () => 'SKILL.md' },
+        remoteFilename: {
+            toRemote: () => 'SKILL',
+            // SKILL.md itself pushes/pulls under the fixed opaque remote name "SKILL" (translated to/from
+            // "SKILL.md" locally) — but a sibling file (references/foo.md, scripts/bar.mjs) pushes under
+            // its own real name (see SkillRepository.pushSkillSiblingFileIfNeeded) and must pull back down
+            // under that SAME real name, not get coerced into "SKILL.md". Only translate the one name this
+            // spec actually owns; anything else passes through unchanged.
+            toLocal: (remoteName) => (remoteName === 'SKILL' ? 'SKILL.md' : remoteName),
+        },
         toRow: (fm, _sourcePath, mtimeMs) => ({
             id: fm.name,
             description: fm.description,
@@ -269,12 +277,37 @@ export function* walkAttachmentFiles(dir) {
         }
     }
 }
+/**
+ * Yields every file under `skillDir` (a single skill's own directory, i.e. dirname(SKILL.md's
+ * source_path)) EXCEPT SKILL.md itself and anything under attachments/ — the "sibling files" a
+ * portable agentskills.io skill keeps alongside SKILL.md (references/, scripts/, assets/, etc).
+ * Used by push (walk-and-push on create()) and by remote-sync.ts's reconcileDeletions to prune
+ * stale siblings. A sibling is never indexed as its own doc row — see skillSyncSpec's matchesFile,
+ * which only ever matches SKILL.md itself.
+ */
+export function* walkSkillSiblingFiles(skillDir) {
+    if (!fs.existsSync(skillDir))
+        return;
+    for (const entry of fs.readdirSync(skillDir, { withFileTypes: true })) {
+        const full = path.join(skillDir, entry.name);
+        if (entry.isDirectory()) {
+            if (isUnderAttachmentsDir(entry.name))
+                continue;
+            yield* walkSkillSiblingFiles(full);
+        }
+        else if (entry.isFile() && entry.name !== 'SKILL.md') {
+            yield full;
+        }
+    }
+}
 export function watchSources(db, spec) {
     const watcher = chokidar.watch(spec.sources.map((f) => f.path), { ignoreInitial: true, persistent: true, depth: 10, ignored: (filePath) => isUnderAttachmentsDir(filePath) });
     watcher
         .on('add', (filePath) => {
-        if (!spec.matchesFile(filePath))
+        if (!spec.matchesFile(filePath)) {
+            spec.onUnmatchedFileChange?.(filePath, 'add');
             return;
+        }
         try {
             upsertFile(db, spec, filePath);
         }
@@ -283,8 +316,10 @@ export function watchSources(db, spec) {
         }
     })
         .on('change', (filePath) => {
-        if (!spec.matchesFile(filePath))
+        if (!spec.matchesFile(filePath)) {
+            spec.onUnmatchedFileChange?.(filePath, 'change');
             return;
+        }
         try {
             upsertFile(db, spec, filePath);
         }
@@ -293,8 +328,10 @@ export function watchSources(db, spec) {
         }
     })
         .on('unlink', (filePath) => {
-        if (!spec.matchesFile(filePath))
+        if (!spec.matchesFile(filePath)) {
+            spec.onUnmatchedFileChange?.(filePath, 'unlink');
             return;
+        }
         removeFile(db, spec.table, filePath);
     });
     return watcher;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-memory-bucket",
-  "version": "0.10.13",
+  "version": "0.10.15",
   "type": "module",
   "description": "MCP server exposing skill_* (reusable coding patterns) and memory_* (point-in-time working context) tools over a markdown+frontmatter source, cached into SQLite at runtime.",
   "repository": {