mcp-memory-bucket 0.7.4 → 0.8.0

package/dist/client/index.html

@@ -26,8 +26,14 @@
     :root[data-theme='light'] { color-scheme: light; }
     :root[data-theme='dark'] { color-scheme: dark; }
     body { font-family: system-ui, sans-serif; margin: 0; background: var(--bg); color: var(--fg); }
+    folderfoo-profile-circle {
+      position: fixed;
+      top: 16px;
+      right: 16px;
+      z-index: 2147483000;
+    }
   </style>
-  <script type="module" crossorigin src="/assets/index-Cr5jNKWL.js"></script>
+  <script type="module" crossorigin src="/assets/index-BfU_uQyK.js"></script>
 </head>
 <body>
   <mem-bucket-app></mem-bucket-app>

package/dist/src/attachments/repository.js

@@ -9,34 +9,34 @@ export class AttachmentRepository {
         this.memoryRepo = memoryRepo;
         this.skillRepo = skillRepo;
     }
-    getDoc(kind, docIdOrName) {
-        const doc = kind === 'memory' ? this.memoryRepo.get(docIdOrName) : this.skillRepo.get(docIdOrName);
+    async getDoc(kind, docIdOrName) {
+        const doc = kind === 'memory' ? await this.memoryRepo.get(docIdOrName) : await this.skillRepo.get(docIdOrName);
         if (!doc)
             throw new Error(`${kind} doc "${docIdOrName}" not found`);
         return doc;
     }
-    saveAttachmentsList(kind, docIdOrName, attachments) {
+    async saveAttachmentsList(kind, docIdOrName, attachments) {
         if (kind === 'memory') {
-            this.memoryRepo.update(docIdOrName, { attachments });
+            await this.memoryRepo.update(docIdOrName, { attachments });
         }
         else {
-            this.skillRepo.update(docIdOrName, { attachments });
+            await this.skillRepo.update(docIdOrName, { attachments });
         }
     }
-    add(kind, docIdOrName, filename, data) {
-        const doc = this.getDoc(kind, docIdOrName);
+    async add(kind, docIdOrName, filename, data) {
+        const doc = await this.getDoc(kind, docIdOrName);
         const dir = attachmentsDirFor(doc.source_path, kind);
         const entry = writeAttachmentFile(dir, filename, data);
         const existing = doc.attachments ?? [];
-        this.saveAttachmentsList(kind, docIdOrName, [...existing, entry]);
+        await this.saveAttachmentsList(kind, docIdOrName, [...existing, entry]);
         return entry;
     }
-    get(kind, docIdOrName, filename) {
-        const doc = this.getDoc(kind, docIdOrName);
+    async get(kind, docIdOrName, filename) {
+        const doc = await this.getDoc(kind, docIdOrName);
         return (doc.attachments ?? []).find((a) => a.filename === filename);
     }
-    update(kind, docIdOrName, filename, data) {
-        const doc = this.getDoc(kind, docIdOrName);
+    async update(kind, docIdOrName, filename, data) {
+        const doc = await this.getDoc(kind, docIdOrName);
         const dir = attachmentsDirFor(doc.source_path, kind);
         const existingEntry = (doc.attachments ?? []).find((a) => a.filename === filename);
         if (!existingEntry)
@@ -46,16 +46,16 @@ export class AttachmentRepository {
         const written = writeAttachmentFile(dir, filename, data);
         // Full replace: preserve position, overwrite metadata for this filename entry.
         const next = (doc.attachments ?? []).map((a) => (a.filename === filename ? written : a));
-        this.saveAttachmentsList(kind, docIdOrName, next);
+        await this.saveAttachmentsList(kind, docIdOrName, next);
         return written;
     }
-    remove(kind, docIdOrName, filename) {
-        const doc = this.getDoc(kind, docIdOrName);
+    async remove(kind, docIdOrName, filename) {
+        const doc = await this.getDoc(kind, docIdOrName);
         const dir = attachmentsDirFor(doc.source_path, kind);
         const safePath = resolveWithinBase(dir, undefined, filename);
         fs.rmSync(safePath, { force: true });
         const next = (doc.attachments ?? []).filter((a) => a.filename !== filename);
-        this.saveAttachmentsList(kind, docIdOrName, next);
+        await this.saveAttachmentsList(kind, docIdOrName, next);
         if (listAttachmentFiles(dir).length === 0) {
             fs.rmSync(dir, { recursive: true, force: true });
             if (kind === 'memory') {
@@ -68,16 +68,16 @@ export class AttachmentRepository {
             }
         }
     }
-    list(kind, docIdOrName) {
-        return this.getDoc(kind, docIdOrName).attachments ?? [];
+    async list(kind, docIdOrName) {
+        return (await this.getDoc(kind, docIdOrName)).attachments ?? [];
     }
     /** Absolute filesystem path for an attachment's file, for callers (e.g. MCP tools) that need to Read it. */
-    absolutePathFor(kind, docIdOrName, filename) {
-        const doc = this.getDoc(kind, docIdOrName);
+    async absolutePathFor(kind, docIdOrName, filename) {
+        const doc = await this.getDoc(kind, docIdOrName);
         return path.join(attachmentsDirFor(doc.source_path, kind), filename);
     }
-    reconcile(kind, docIdOrName) {
-        const doc = this.getDoc(kind, docIdOrName);
+    async reconcile(kind, docIdOrName) {
+        const doc = await this.getDoc(kind, docIdOrName);
         const dir = attachmentsDirFor(doc.source_path, kind);
         const declared = new Set((doc.attachments ?? []).map((a) => a.filename));
         const onDisk = new Set(listAttachmentFiles(dir));

package/dist/src/attachments/tools.js

@@ -19,8 +19,8 @@ export function registerAttachmentTools(mcp, attachRepo) {
         try {
             assertFileSizeOk(file_path);
             const data = fs.readFileSync(file_path);
-            const entry = attachRepo.add(kind, doc, filename, data);
-            const absolute_path = attachRepo.absolutePathFor(kind, doc, entry.filename);
+            const entry = await attachRepo.add(kind, doc, filename, data);
+            const absolute_path = await attachRepo.absolutePathFor(kind, doc, entry.filename);
             return { content: [{ type: 'text', text: JSON.stringify({ ...entry, absolute_path }, null, 2) }] };
         }
         catch (err) {
@@ -29,10 +29,10 @@ export function registerAttachmentTools(mcp, attachRepo) {
     });
     mcp.tool('attachment_get', 'Returns the on-disk path (not content) of an attachment, plus its metadata. Use Read on the returned absolute_path for the content.', { kind: kindSchema, doc: z.string(), filename: z.string() }, async ({ kind, doc, filename }) => {
         try {
-            const entry = attachRepo.get(kind, doc, filename);
+            const entry = await attachRepo.get(kind, doc, filename);
             if (!entry)
                 throw new Error(`attachment "${filename}" not found`);
-            const absolute_path = attachRepo.absolutePathFor(kind, doc, entry.filename);
+            const absolute_path = await attachRepo.absolutePathFor(kind, doc, entry.filename);
             return { content: [{ type: 'text', text: JSON.stringify({ ...entry, absolute_path }, null, 2) }] };
         }
         catch (err) {
@@ -43,8 +43,8 @@ export function registerAttachmentTools(mcp, attachRepo) {
         try {
             assertFileSizeOk(file_path);
             const data = fs.readFileSync(file_path);
-            const entry = attachRepo.update(kind, doc, filename, data);
-            const absolute_path = attachRepo.absolutePathFor(kind, doc, entry.filename);
+            const entry = await attachRepo.update(kind, doc, filename, data);
+            const absolute_path = await attachRepo.absolutePathFor(kind, doc, entry.filename);
             return { content: [{ type: 'text', text: JSON.stringify({ ...entry, absolute_path }, null, 2) }] };
         }
         catch (err) {
@@ -53,7 +53,7 @@ export function registerAttachmentTools(mcp, attachRepo) {
     });
     mcp.tool('attachment_remove', 'Deletes an attachment from a memory doc or skill.', { kind: kindSchema, doc: z.string(), filename: z.string() }, async ({ kind, doc, filename }) => {
         try {
-            attachRepo.remove(kind, doc, filename);
+            await attachRepo.remove(kind, doc, filename);
             return { content: [{ type: 'text', text: `removed "${filename}"` }] };
         }
         catch (err) {
@@ -62,11 +62,11 @@ export function registerAttachmentTools(mcp, attachRepo) {
     });
     mcp.tool('attachment_list', 'Lists all attachments on a memory doc or skill, each with its absolute on-disk path.', { kind: kindSchema, doc: z.string() }, async ({ kind, doc }) => {
         try {
-            const entries = attachRepo.list(kind, doc);
-            const withPaths = entries.map((entry) => ({
+            const entries = await attachRepo.list(kind, doc);
+            const withPaths = await Promise.all(entries.map(async (entry) => ({
                 ...entry,
-                absolute_path: attachRepo.absolutePathFor(kind, doc, entry.filename),
-            }));
+                absolute_path: await attachRepo.absolutePathFor(kind, doc, entry.filename),
+            })));
             return { content: [{ type: 'text', text: JSON.stringify(withPaths, null, 2) }] };
         }
         catch (err) {
@@ -75,7 +75,7 @@ export function registerAttachmentTools(mcp, attachRepo) {
     });
     mcp.tool('attachment_reconcile', "Compares a doc's declared attachments against what is actually on disk; reports orphans (declared but missing) and unlisted files (present but not declared). Report-only, does not repair.", { kind: kindSchema, doc: z.string() }, async ({ kind, doc }) => {
         try {
-            const result = attachRepo.reconcile(kind, doc);
+            const result = await attachRepo.reconcile(kind, doc);
             return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
         }
         catch (err) {

package/dist/src/config.js

@@ -1,9 +1,36 @@
 import fs from 'node:fs';
 import path from 'node:path';
+const FOLDERFOO_DEV_HOST = 'http://localhost:3000';
+const FOLDERFOO_CLOUD_HOST = 'https://files.cuul.cc';
+function isRemoteEntry(entry) {
+    return typeof entry === 'object' && 'remote' in entry;
+}
+/** Local mirror directory a remote source's content is synced into - see the RemoteFolder doc comment above. */
+export function mirrorDirFor(baseDir, name) {
+    return path.join(baseDir, '.memory-bucket-remote-cache', sanitizeFolderName(name));
+}
 function memoryDirFlag(argv) {
     const idx = argv.indexOf('--memory-dir');
     return idx !== -1 ? argv[idx + 1] : undefined;
 }
+function folderfooModeFlag(argv) {
+    const idx = argv.indexOf('--folderfoo-mode');
+    return idx !== -1 ? argv[idx + 1] : undefined;
+}
+function resolveFolderfooMode(argv) {
+    const raw = (folderfooModeFlag(argv) ?? process.env.FOLDERFOO_MODE ?? 'off').toLowerCase();
+    if (raw === 'dev' || raw === 'cloud' || raw === 'off')
+        return raw;
+    console.error(`[memory-bucket] unrecognized --folderfoo-mode/FOLDERFOO_MODE "${raw}" — expected off|dev|cloud, defaulting to "off"`);
+    return 'off';
+}
+function folderfooHostFor(mode) {
+    if (mode === 'dev')
+        return FOLDERFOO_DEV_HOST;
+    if (mode === 'cloud')
+        return FOLDERFOO_CLOUD_HOST;
+    return null;
+}
 function readConfigFile(configPath) {
     if (!fs.existsSync(configPath))
         return {};
@@ -12,16 +39,32 @@ function readConfigFile(configPath) {
 function nameFromPath(p) {
     return path.basename(p);
 }
+/**
+ * Resolves every configured source entry to a NamedFolder - for a remote
+ * entry, NamedFolder.path is the local MIRROR directory (see mirrorDirFor),
+ * not folderfoo itself, so every existing downstream consumer of
+ * NamedFolder (chokidar, sync.ts's upsertFile/folderForFile) keeps working
+ * completely unchanged. remoteFolders carries the folderfoo-specific
+ * coordinates a remote entry also needs, threaded separately into the
+ * poller rather than into NamedFolder/TableSyncSpec.
+ */
 function resolveFolders(entries, baseDir) {
+    const remoteFolders = [];
     const folders = entries.map((entry) => {
         if (typeof entry === 'string') {
             return { name: nameFromPath(entry), path: path.resolve(baseDir, entry) };
         }
+        if (isRemoteEntry(entry)) {
+            const mirrorDir = mirrorDirFor(baseDir, entry.name);
+            remoteFolders.push({ name: entry.name, ...entry.remote, mirrorDir });
+            return { name: entry.name, path: mirrorDir };
+        }
         return { name: entry.name, path: path.resolve(baseDir, entry.path) };
     });
     // de-dupe by resolved path (e.g. default + explicit config both pointing at ./skills)
     const seen = new Set();
-    return folders.filter((f) => (seen.has(f.path) ? false : (seen.add(f.path), true)));
+    const deduped = folders.filter((f) => (seen.has(f.path) ? false : (seen.add(f.path), true)));
+    return { folders: deduped, remoteFolders };
 }
 export function loadConfig(cwd = process.cwd(), argv = process.argv) {
     const explicitDir = memoryDirFlag(argv) ?? process.env.MEMORY_BUCKET_DIR;
@@ -37,14 +80,19 @@ export function loadConfig(cwd = process.cwd(), argv = process.argv) {
     // rather than silently registering a directory that was never created.
     const defaultSkillSources = overrides.skill_sources ?? (fs.existsSync(path.resolve(baseDir, './skills')) ? ['./skills'] : []);
     const defaultMemorySources = overrides.memory_sources ?? (fs.existsSync(path.resolve(baseDir, './docs')) ? ['./docs'] : []);
-    const skillFolders = resolveFolders(defaultSkillSources, baseDir);
-    const memoryFolders = resolveFolders(defaultMemorySources, baseDir);
+    const { folders: skillFolders, remoteFolders: remoteSkillFolders } = resolveFolders(defaultSkillSources, baseDir);
+    const { folders: memoryFolders, remoteFolders: remoteMemoryFolders } = resolveFolders(defaultMemorySources, baseDir);
+    const folderfooMode = resolveFolderfooMode(argv);
     return {
         skillFolders,
         memoryFolders,
+        remoteSkillFolders,
+        remoteMemoryFolders,
         cacheDbPath: path.join(baseDir, '.memory-bucket-cache.sqlite'),
         configPath,
         baseDir,
+        folderfooMode,
+        folderfooHost: folderfooHostFor(folderfooMode),
     };
 }
 /**
@@ -68,6 +116,25 @@ export function saveFolder(config, kind, folder) {
     };
     fs.writeFileSync(config.configPath, JSON.stringify(next, null, 2) + '\n');
 }
+/**
+ * Appends a new REMOTE (folderfoo) source entry — same append-only behavior as saveFolder above,
+ * but writes the `{name, remote: {...}}` shape instead of `{name, path}`. The JWT itself is never
+ * written here — that's credentials.ts's job, kept in a separate untracked file (see its own doc
+ * comment for why: this config file is a plain JSON file that might reasonably get committed/shared).
+ */
+export function saveRemoteFolder(config, kind, entry) {
+    const current = readConfigFile(config.configPath);
+    const key = kind === 'skill' ? 'skill_sources' : 'memory_sources';
+    const existing = current[key] ?? [];
+    const next = {
+        ...current,
+        [key]: [
+            ...existing,
+            { name: entry.name, remote: { server: entry.server, tenantId: entry.tenantId, folderPath: entry.folderPath } },
+        ],
+    };
+    fs.writeFileSync(config.configPath, JSON.stringify(next, null, 2) + '\n');
+}
 /** Lowercase-hyphenate a folder-derived name, same shape as skill names. */
 export function sanitizeFolderName(raw) {
     return raw

package/dist/src/memory/repository.js

@@ -1,13 +1,16 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
+import matter from 'gray-matter';
 import { writeMarkdownFile } from '../store/markdown-file.js';
 import { slugify } from '../store/slug.js';
 import { resolveWithinBase } from '../store/safe-path.js';
 import { upsertFile, removeFile, scanSingleFolder, unregisterFolder, memorySyncSpec } from '../store/sync.js';
 import { SearchQueryError, sanitizeFtsQuery } from '../store/search.js';
+import { applyBodyEdits } from '../shared/body-edits.js';
 import { attachmentsDirFor } from '../attachments/storage.js';
 import { normalizeKey } from '../types.js';
+import { readFile as readRemoteFile, writeFile as writeRemoteFile, joinRemoteFolderPath } from '../remote/folderfoo-client.js';
 /** Uppercases and strips everything but letters/digits — used to compare keys that differ only in
  * punctuation/whitespace formatting (e.g. `RMXS-15` and `RMXS15` strip to the same `RMXS15`). */
 export function stripKey(s) {
@@ -35,13 +38,21 @@ function rowToDoc(row) {
 export class MemoryRepository {
     db;
     folders;
+    remoteFolders;
+    credentialsBaseDir;
     syncSpec;
     watcher;
-    constructor(db, folders) {
+    constructor(db, folders, remoteFolders = [], credentialsBaseDir) {
         this.db = db;
         this.folders = folders;
+        this.remoteFolders = remoteFolders;
+        this.credentialsBaseDir = credentialsBaseDir;
         this.syncSpec = memorySyncSpec(folders);
     }
+    /** The RemoteFolder a NamedFolder name resolves to, or undefined for a local (non-remote) folder. */
+    remoteFor(folderName) {
+        return this.remoteFolders.find((f) => f.name === folderName);
+    }
     /** Attaches the live chokidar watcher so addFolder/removeFolder can mutate it without a restart. */
     setWatcher(watcher) {
         this.watcher = watcher;
@@ -49,6 +60,14 @@ export class MemoryRepository {
     listFolders() {
         return [...this.folders];
     }
+    /** Full RemoteFolder records (server/tenantId/folderPath/mirrorDir) for every connected remote source — for matching an incoming folderfoo-file-open address back to a configured source. */
+    listRemoteFolders() {
+        return [...this.remoteFolders];
+    }
+    /** Same as listFolders(), but tags each entry with whether it's a remote (folderfoo) source — for the web UI's folder list, e.g. to render remote folders in a distinct color. */
+    listFoldersWithRemoteInfo() {
+        return this.folders.map((f) => ({ ...f, remote: !!this.remoteFor(f.name) }));
+    }
     resolveFolder(folderName) {
         if (folderName) {
             const found = this.folders.find((f) => f.name === folderName);
@@ -64,6 +83,24 @@ export class MemoryRepository {
         }
         throw new Error(`multiple memory folders configured — specify folder: one of ${this.folders.map((f) => f.name).join(', ')}`);
     }
+    /**
+     * Registers a new REMOTE (folderfoo) folder: creates its local mirror
+     * directory, registers it exactly like a local addFolder (so it starts
+     * watching/scanning immediately — empty at first, since nothing's been
+     * pulled from folderfoo yet), and records the folderfoo coordinates so
+     * get()/create()/update() know to treat this folder as remote. Does NOT
+     * perform the initial pull itself — the caller (the web route) does one
+     * immediate poll right after this returns, so content shows up without
+     * waiting for the first interval tick.
+     */
+    registerRemoteFolder(remote) {
+        if (this.folders.some((f) => f.name === remote.name)) {
+            throw new Error(`a memory folder named "${remote.name}" already exists`);
+        }
+        fs.mkdirSync(remote.mirrorDir, { recursive: true });
+        this.remoteFolders.push(remote);
+        this.addFolder({ name: remote.name, path: remote.mirrorDir });
+    }
     /** Registers a new folder: appends it, scans it once, and starts watching it live. */
     addFolder(folder) {
         if (this.folders.some((f) => f.name === folder.name)) {
@@ -149,13 +186,40 @@ export class MemoryRepository {
             throw new SearchQueryError(query, err);
         }
     }
-    get(id) {
+    /**
+     * For a doc in a LOCAL folder, returns the cached row unchanged (identical behavior to before
+     * remote sources existed). For a doc in a REMOTE folder, the cached `body` is only ever a
+     * poll-interval-stale mirror snapshot — per the settled design, `get` always fetches the current
+     * body live from folderfoo instead of trusting it, so a caller never sees stale content just
+     * because the last poll tick hasn't run yet.
+     */
+    async get(id) {
         const row = this.db.prepare(`SELECT * FROM memory_docs WHERE id = ?`).get(id);
-        return row ? rowToDoc(row) : null;
+        if (!row)
+            return null;
+        const doc = rowToDoc(row);
+        const remote = this.remoteFor(doc.folder);
+        if (!remote || !this.credentialsBaseDir)
+            return doc;
+        const relPath = path.relative(remote.mirrorDir, doc.source_path).replace(/\.md$/, '');
+        const dir = joinRemoteFolderPath(remote.folderPath, path.dirname(relPath));
+        const name = path.basename(relPath);
+        // readRemoteFile returns the file's RAW bytes as folderfoo stored them -
+        // the whole markdown file, frontmatter block included, since folderfoo
+        // has no concept of frontmatter/body separation (that's purely a
+        // mem-bucket/gray-matter concept). Using this raw content directly as
+        // `body` was a real bug: the next update() would writeMarkdownFile a
+        // FRESH frontmatter block wrapped around this already-frontmattered
+        // blob, nesting one level deeper on every single edit (confirmed via a
+        // real corrupted doc: 3 levels of self-nested frontmatter+body after 3
+        // edits). Must parse it exactly like a local file read would.
+        const liveBody = matter(await readRemoteFile(remote.server, this.credentialsBaseDir, remote.tenantId, dir, name)).content.trim();
+        return { ...doc, body: liveBody };
     }
     /** Fetches many memory docs by id in one call — e.g. hydrating full bodies for a batch of search() hits. Missing ids are simply absent from the result, not errors. */
-    bulkGet(ids) {
-        return ids.map((id) => this.get(id)).filter((doc) => doc !== null);
+    async bulkGet(ids) {
+        const docs = await Promise.all(ids.map((id) => this.get(id)));
+        return docs.filter((doc) => doc !== null);
     }
     listKeys(keyPrefix) {
         const rows = this.db
@@ -195,10 +259,21 @@ export class MemoryRepository {
             .slice(0, limit)
             .map(({ key, docCount }) => ({ key, docCount }));
     }
-    create(input) {
+    async create(input) {
         const normalizedKey = normalizeKey(input.key);
-        const id = `${slugify(normalizedKey)}-${slugify(input.description)}-${randomUUID().slice(0, 8)}`;
         const targetFolder = this.resolveFolder(input.folder);
+        let id = `${slugify(normalizedKey)}-${slugify(input.description)}-${randomUUID().slice(0, 8)}`;
+        // folderfoo's POST /save/:filename silently strips every character
+        // outside [0-9a-zA-Z_] from the final filename segment (hyphens
+        // included) - a remote-bound id must not contain characters folderfoo
+        // will drop, or the name mem-bucket thinks the file is called
+        // permanently diverges from what folderfoo actually stored it as the
+        // moment it's written, breaking every future get/update for that doc
+        // with a 404 (confirmed: this is exactly what happened before this
+        // fix). Stripped ONLY for remote-bound docs - local-only folders keep
+        // the more readable hyphenated id unchanged.
+        if (this.remoteFor(targetFolder.name))
+            id = id.replace(/-/g, '');
         const filePath = resolveWithinBase(targetFolder.path, input.subfolder, `${id}.md`);
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
         const fm = {
@@ -216,6 +291,18 @@ export class MemoryRepository {
             folder: targetFolder.name,
         };
         writeMarkdownFile(filePath, stripSourcePath(fm), input.body);
+        // Remote write happens BEFORE upsertFile, live/synchronous per the settled design (no local
+        // staging) — if folderfoo rejects the write, this throws and the mirror is never indexed as
+        // if the doc were successfully saved. Reads the just-written mirror file back so folderfoo
+        // gets writeMarkdownFile's own formatting verbatim, not a hand-reconstructed string.
+        const remote = this.remoteFor(targetFolder.name);
+        if (remote && this.credentialsBaseDir) {
+            const relPath = path.relative(remote.mirrorDir, filePath).replace(/\.md$/, '');
+            const dir = joinRemoteFolderPath(remote.folderPath, path.dirname(relPath));
+            const name = path.basename(relPath);
+            const fileContents = fs.readFileSync(filePath, 'utf-8');
+            await writeRemoteFile(remote.server, this.credentialsBaseDir, remote.tenantId, dir, name, fileContents);
+        }
         upsertFile(this.db, this.syncSpec, filePath);
         return { ...fm, body: input.body, paused: false };
     }
@@ -224,19 +311,21 @@ export class MemoryRepository {
      * create()'s input. Returns per-key results (with the id filled in on
      * success) so one bad entry doesn't abort the rest of the batch.
      */
-    bulkCreate(entries) {
-        return entries.map((entry) => {
+    async bulkCreate(entries) {
+        const results = [];
+        for (const entry of entries) {
             try {
-                const doc = this.create(entry);
-                return { key: entry.key, ok: true, id: doc.id };
+                const doc = await this.create(entry);
+                results.push({ key: entry.key, ok: true, id: doc.id });
             }
             catch (err) {
-                return { key: entry.key, ok: false, error: err.message };
+                results.push({ key: entry.key, ok: false, error: err.message });
             }
-        });
+        }
+        return results;
     }
-    update(id, frontmatter, body) {
-        const existing = this.get(id);
+    async update(id, frontmatter, body, bodyEdits) {
+        const existing = await this.get(id);
         if (!existing)
             throw new Error(`memory doc with id "${id}" not found`);
         // `paused` is local-cache-only and must never reach writeMarkdownFile — split it off of
@@ -248,8 +337,16 @@ export class MemoryRepository {
             id: existing.id,
             key: frontmatter?.key ? normalizeKey(frontmatter.key) : existing.key,
         };
-        const newBody = body ?? existing.body;
+        const newBody = bodyEdits ? applyBodyEdits(existing.body, bodyEdits).body : (body ?? existing.body);
         writeMarkdownFile(existing.source_path, stripSourcePath(merged), newBody);
+        const remote = this.remoteFor(existing.folder);
+        if (remote && this.credentialsBaseDir) {
+            const relPath = path.relative(remote.mirrorDir, existing.source_path).replace(/\.md$/, '');
+            const dir = joinRemoteFolderPath(remote.folderPath, path.dirname(relPath));
+            const name = path.basename(relPath);
+            const fileContents = fs.readFileSync(existing.source_path, 'utf-8');
+            await writeRemoteFile(remote.server, this.credentialsBaseDir, remote.tenantId, dir, name, fileContents);
+        }
         upsertFile(this.db, this.syncSpec, existing.source_path);
         return { ...merged, body: newBody, paused: existingPaused };
     }
@@ -261,10 +358,11 @@ export class MemoryRepository {
      * when provided. Never touches body. Returns per-id results so partial
      * failures (e.g. an unknown id) don't abort the rest of the batch.
      */
-    bulkUpdate(ids, changes) {
-        return ids.map((id) => {
+    async bulkUpdate(ids, changes) {
+        const results = [];
+        for (const id of ids) {
             try {
-                const existing = this.get(id);
+                const existing = await this.get(id);
                 if (!existing)
                     throw new Error(`memory doc with id "${id}" not found`);
                 let tags = existing.tags;
@@ -272,18 +370,19 @@ export class MemoryRepository {
                     tags = Array.from(new Set([...tags, ...changes.add_tags]));
                 if (changes.remove_tags?.length)
                     tags = tags.filter((t) => !changes.remove_tags.includes(t));
-                this.update(id, {
+                await this.update(id, {
                     tags,
                     ...(changes.status !== undefined ? { status: changes.status } : {}),
                     ...(changes.related_to !== undefined ? { related_to: changes.related_to } : {}),
                     ...(changes.deprecated !== undefined ? { deprecated: changes.deprecated } : {}),
                 });
-                return { id, ok: true };
+                results.push({ id, ok: true });
             }
             catch (err) {
-                return { id, ok: false, error: err.message };
+                results.push({ id, ok: false, error: err.message });
             }
-        });
+        }
+        return results;
     }
     /**
      * Pauses/resumes memory docs by id — a local-only toggle stored directly in this cache file's
@@ -293,22 +392,24 @@ export class MemoryRepository {
      * local-only, the flag does not follow the doc to another machine's cache or survive the cache
      * file being deleted. Returns per-id results so one bad id doesn't abort the rest of the batch.
      */
-    setPaused(ids, paused) {
-        return ids.map((id) => {
+    async setPaused(ids, paused) {
+        const results = [];
+        for (const id of ids) {
             try {
-                const existing = this.get(id);
+                const existing = await this.get(id);
                 if (!existing)
                     throw new Error(`memory doc with id "${id}" not found`);
                 this.db.prepare(`UPDATE memory_docs SET paused = ? WHERE id = ?`).run(paused ? 1 : 0, id);
-                return { id, ok: true };
+                results.push({ id, ok: true });
             }
             catch (err) {
-                return { id, ok: false, error: err.message };
+                results.push({ id, ok: false, error: err.message });
             }
-        });
+        }
+        return results;
     }
-    delete(id) {
-        const existing = this.get(id);
+    async delete(id) {
+        const existing = await this.get(id);
         if (!existing)
             throw new Error(`memory doc with id "${id}" not found`);
         // The <id>/ wrapper directory exists solely to hold attachments/ for this doc (memory docs
@@ -326,8 +427,8 @@ export class MemoryRepository {
      * deriveFrontmatter's fallback, so the caller should treat this doc as gone under its old id
      * once this returns (look it up by the new filename-derived id/key instead).
      */
-    stripFrontmatter(id) {
-        const existing = this.get(id);
+    async stripFrontmatter(id) {
+        const existing = await this.get(id);
         if (!existing)
             throw new Error(`memory doc with id "${id}" not found`);
         writeMarkdownFile(existing.source_path, {}, existing.body);
@@ -338,16 +439,18 @@ export class MemoryRepository {
      * abandoned docs found via search(). Returns per-id results so one bad id
      * doesn't abort the rest of the batch.
      */
-    bulkDelete(ids) {
-        return ids.map((id) => {
+    async bulkDelete(ids) {
+        const results = [];
+        for (const id of ids) {
             try {
-                this.delete(id);
-                return { id, ok: true };
+                await this.delete(id);
+                results.push({ id, ok: true });
             }
             catch (err) {
-                return { id, ok: false, error: err.message };
+                results.push({ id, ok: false, error: err.message });
             }
-        });
+        }
+        return results;
     }
 }
 function stripSourcePath(fm) {