mcp-memory-bucket 0.12.6 → 0.13.0

package/dist/client/index.html

@@ -44,7 +44,7 @@
       z-index: 2147483000;
     }
   </style>
-  <script type="module" crossorigin src="/assets/index-B4HSkaso.js"></script>
+  <script type="module" crossorigin src="/assets/index-CGe-JXLz.js"></script>
 </head>
 <body>
   <mem-bucket-app></mem-bucket-app>

package/dist/src/memory/repository.js

@@ -13,6 +13,7 @@ import { normalizeKey } from '../types.js';
 import { readFile as readRemoteFile, writeFile as writeRemoteFile, writeBinaryFile as writeRemoteBinaryFile, renameFile as renameRemoteFile, trashFile as trashRemoteFile, joinRemoteFolderPath, assertRemoteFolderExists, FolderfooRequestError } from '../remote/folderfoo-client.js';
 import { isFolderVisible } from '../remote/identity.js';
 import { writeRemoteThenLocal } from '../remote/write-order.js';
+import { isSharedFolderName, sharedItemReadOnlyError } from '../remote/shared-items.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) {
@@ -136,8 +137,12 @@ export class MemoryRepository {
                     best = folder;
             }
         }
-        if (!best)
-            return undefined;
+        if (!best) {
+            // An item-level share's mirror lives outside every configured folder — it is addressed by
+            // the folder its cache row is filed under instead (see get()).
+            const shared = this.db.prepare(`SELECT folder FROM memory_docs WHERE source_path = ?`).get(sourcePath);
+            return shared && isSharedFolderName(shared.folder) ? { folder: shared.folder, filename: path.basename(sourcePath) } : undefined;
+        }
         return { folder: best.name, filename: path.relative(path.resolve(best.path), resolved) };
     }
     /** Normalizes an agent-supplied filename to always end in `.md`, matching how docs are stored on disk. */
@@ -425,10 +430,7 @@ export class MemoryRepository {
         params.push(limit, offset);
         try {
             // shared_items is LEFT JOINed on m.source_path (== mirror_path for an item-level share —
-            // see remote/shared-items.ts) to surface owner/role on any hit that came from a share, since
-            // a shared item's own `folder` column is always '' (its mirror path is outside every
-            // configured source directory, so folderForFile can't attribute it to one) and would
-            // otherwise look identical to any other unfoldered local doc.
+            // see remote/shared-items.ts) to surface owner/role on any hit that came from a share.
             const rows = this.db
                 .prepare(`SELECT m.source_path, m.key, m.description, m.doc_type, m.folder,
                   snippet(search_index, 3, '<<', '>>', '…', 20) AS snippet,
@@ -461,6 +463,14 @@ export class MemoryRepository {
      * because the last poll tick hasn't run yet.
      */
     async get(folder, filename) {
+        // A shared item has no configured folder to resolve a path against — match it by filename
+        // among the rows filed under its shared folder. Its mirror is the only copy this side has.
+        if (isSharedFolderName(folder)) {
+            const wanted = MemoryRepository.normalizeFilename(filename);
+            const rows = this.db.prepare(`SELECT * FROM memory_docs WHERE folder = ?`).all(folder);
+            const shared = rows.find((r) => path.basename(r.source_path) === wanted);
+            return shared ? rowToDoc(shared) : null;
+        }
         const sourcePath = this.sourcePathFor(folder, filename);
         const row = this.db.prepare(`SELECT * FROM memory_docs WHERE source_path = ?`).get(sourcePath);
         if (!row)
@@ -629,6 +639,8 @@ export class MemoryRepository {
         const existing = await this.get(folder, filename);
         if (!existing)
             throw new Error(`memory doc "${filename}" not found`);
+        if (isSharedFolderName(existing.folder))
+            throw sharedItemReadOnlyError(filename);
         // `paused` is local-cache-only and `body` is written separately as the markdown body, not
         // frontmatter — both must be split off of `existing` before spreading the rest into
         // `merged`, or they'd ride along into the MemoryFrontmatter written to disk (duplicating the
@@ -718,6 +730,8 @@ export class MemoryRepository {
         const existing = await this.get(folder, filename);
         if (!existing)
             throw new Error(`memory doc "${filename}" not found`);
+        if (isSharedFolderName(existing.folder))
+            throw sharedItemReadOnlyError(filename);
         // Archive the remote copy FIRST, before touching anything local — otherwise a deleted-locally-
         // but-still-present-remotely doc gets silently pulled right back in on the next poll (exactly
         // the "deleted doc reappears" bug this fixes). Soft-delete (trash), not a hard remote delete —
@@ -754,6 +768,8 @@ export class MemoryRepository {
         const existing = await this.get(folder, filename);
         if (!existing)
             throw new Error(`memory doc "${filename}" not found`);
+        if (isSharedFolderName(existing.folder))
+            throw sharedItemReadOnlyError(filename);
         const normalizedNew = MemoryRepository.normalizeFilename(newFilename);
         const newPath = path.join(path.dirname(existing.source_path), normalizedNew);
         if (newPath === existing.source_path)
@@ -807,6 +823,8 @@ export class MemoryRepository {
         const existing = await this.get(folder, filename);
         if (!existing)
             throw new Error(`memory doc "${filename}" not found`);
+        if (isSharedFolderName(existing.folder))
+            throw sharedItemReadOnlyError(filename);
         writeMarkdownFile(existing.source_path, {}, existing.body);
         upsertFile(this.db, this.syncSpec, existing.source_path);
     }

package/dist/src/remote/folderfoo-client.js

@@ -172,6 +172,20 @@ export async function createPublicLink(server, baseDir, tenantId, folderPath, na
         body: JSON.stringify({ path: joinRemoteFolderPath(folderPath, name), kind }),
     }), (res) => res.json());
 }
+/**
+ * Reads a public link's target via folderfoo's GET /public/:token — no login, the token is the
+ * only credential. `content` is the raw file text for a file stored as raw bytes (every memory
+ * doc/skill), or parsed JSON for folderfoo's legacy .json form. A revoked, expired, or deleted
+ * link is a 404 (FolderfooRequestError).
+ */
+export async function fetchPublicLink(server, token) {
+    const res = await fetch(`${server}/public/${encodeURIComponent(token)}`);
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({}));
+        throw new FolderfooRequestError(res.status, body.error ?? res.statusText);
+    }
+    return (await res.json());
+}
 /** Thrown when a write targets a remote folder that no longer exists on folderfoo (deleted server-side since the last connect/UI-open sync). */
 export class RemoteFolderGoneError extends Error {
     constructor(folderName) {

package/dist/src/remote/shared-items.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { getSharedWithMe, readFile, joinRemoteFolderPath } from './folderfoo-client.js';
+import { getSharedWithMe, readFile, fetchPublicLink, joinRemoteFolderPath, FolderfooAuthError, FolderfooRequestError, } from './folderfoo-client.js';
 import { upsertFile, removeFile } from '../store/sync.js';
 import { sanitizeFolderName } from '../config.js';
 /**
@@ -12,38 +12,101 @@ import { sanitizeFolderName } from '../config.js';
  * mirrorDirFor nests remote folders under {mode}_{username}, so items from
  * two different folderfoo deployments/tenants never collide on disk.
  */
+export function sharedItemsMirrorRoot(baseDir) {
+    return path.join(baseDir, '.memory-bucket-shared-items');
+}
 export function sharedItemsMirrorDir(baseDir, server, tenantId) {
     const serverSegment = sanitizeFolderName(server.replace(/^https?:\/\//, ''));
-    return path.join(baseDir, '.memory-bucket-shared-items', serverSegment, sanitizeFolderName(tenantId));
+    return path.join(sharedItemsMirrorRoot(baseDir), serverSegment, sanitizeFolderName(tenantId));
+}
+/**
+ * The `folder` a shared item's cache row is filed under. A shared item lives outside every
+ * configured source directory, so without this every one of them landed in folder '' — where two
+ * shared skills with the same name collide on the (folder, id) key and the second is never indexed,
+ * and where nothing could tell a shared row from an ordinary one. The prefix is also what the
+ * repositories key their read-only guard on (see isSharedFolderName).
+ */
+const SHARED_FOLDER_PREFIX = 'shared-by-';
+export function sharedFolderName(owner) {
+    return `${SHARED_FOLDER_PREFIX}${sanitizeFolderName(owner) || 'unknown'}`;
+}
+export function isSharedFolderName(folderName) {
+    return !!folderName && folderName.startsWith(SHARED_FOLDER_PREFIX);
+}
+/** Thrown by a repository write against a doc that is someone else's shared item. */
+export function sharedItemReadOnlyError(name) {
+    return new Error(`"${name}" is shared with you and read-only here — copy it into your own folder with bucket_fork_shared_item (or "Fork to mine" in the web UI) to edit it`);
+}
+// origin_id becomes a directory name under the mirror root (and that directory is removed
+// recursively on revoke), so it must be exactly the uuid folderfoo mints — never a path fragment.
+const ORIGIN_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** A row belongs to `username` when it was granted to that login, or isn't login-scoped at all (public link / legacy row). */
+function isVisibleTo(row, username) {
+    return row.username === '' || row.username === username;
+}
+function indexMirror(db, specs, row) {
+    const folder = sharedFolderName(row.owner);
+    const table = row.kind === 'skill' ? 'skills' : 'memory_docs';
+    // upsertFile skips a file whose mtime it has already seen, so a row filed under a different
+    // folder (e.g. '' from before shared items had their own) would otherwise keep it forever.
+    const existing = db.prepare(`SELECT folder FROM ${table} WHERE source_path = ?`).get(row.mirror_path);
+    if (existing && existing.folder !== folder)
+        removeFile(db, table, row.mirror_path);
+    // Branched (not a single `const spec = kind === 'skill' ? ... : ...`) because upsertFile<T> is
+    // generic over TFrontmatter and the ternary's union type satisfies neither call signature.
+    if (row.kind === 'skill')
+        upsertFile(db, specs.skill, row.mirror_path, folder);
+    else
+        upsertFile(db, specs.memory, row.mirror_path, folder);
+}
+function removeMirror(db, baseDir, row) {
+    removeFile(db, row.kind === 'skill' ? 'skills' : 'memory_docs', row.mirror_path);
+    const dir = path.resolve(path.dirname(row.mirror_path));
+    const root = path.resolve(sharedItemsMirrorRoot(baseDir));
+    if (dir.startsWith(root + path.sep))
+        fs.rmSync(dir, { recursive: true, force: true });
+}
+function publicContentToMarkdown(content) {
+    return typeof content === 'string' ? content : JSON.stringify(content, null, 2);
 }
 /**
- * Registers a newly-accepted share (from the share-link accept flow, or a
- * direct username share the user just picked up) into shared_items and pulls
- * its content immediately — this one fetch is the explicit act of accepting
- * a share, not a background resync, so it doesn't violate "refresh is a
- * UI-only action" (see refreshSharedItems below, which IS that action).
- * Idempotent on origin_id: re-adding an already-tracked share just refreshes
- * its content once, e.g. if `addSharedItem` is called again by mistake, or
- * the item was previously revoked and got re-shared with the same origin.
+ * Registers a share into shared_items and pulls its content immediately. Called for an accepted
+ * share/public link (the explicit act of accepting — see routes.ts) and by refreshSharedItems for
+ * a direct share it just discovered. Idempotent on origin_id: re-adding an already-tracked share
+ * (or one previously revoked and re-shared) just refreshes it.
+ *
+ * `publicToken` marks a public-link item: it has no `shares` row on folderfoo, so its content can
+ * only be read back through the link itself (no login), never the owner-addressed read.
+ * `paused` files the item hidden from agent-facing list/search until the user unpauses it — used
+ * for a share nobody on this side explicitly accepted.
  */
 export async function addSharedItem(db, baseDir, skillSpec, memorySpec, entry) {
-    const role = entry.role ?? 'member';
+    if (!ORIGIN_ID_PATTERN.test(entry.originId))
+        throw new Error('invalid originId');
+    const role = entry.publicToken ? 'member' : (entry.role ?? 'member');
     const mirrorDir = sharedItemsMirrorDir(baseDir, entry.server, entry.tenantId);
-    const localFilename = entry.kind === 'skill' ? 'SKILL.md' : path.basename(entry.path);
+    const remoteName = path.basename(entry.path);
+    if (!remoteName || remoteName === '.' || remoteName === '..')
+        throw new Error('invalid shared item path');
+    // A memory doc pushed before remote names kept their extension has none (see memorySyncSpec's
+    // remoteFilename.toLocal) — its mirror still needs one to be addressable by filename.
+    const localFilename = entry.kind === 'skill' ? 'SKILL.md' : remoteName.endsWith('.md') ? remoteName : `${remoteName}.md`;
     // One subdirectory per origin_id — a skill's SKILL.md needs its own parent
     // directory anyway (skill identity is (folder, id), i.e. the containing
     // directory's name), and giving every shared item (memory or skill) the
     // same shape keeps this code path uniform instead of branching on kind.
     const mirrorPath = path.join(mirrorDir, entry.originId, localFilename);
+    const content = entry.publicToken
+        ? publicContentToMarkdown((await fetchPublicLink(entry.server, entry.publicToken)).content)
+        : await readFile(entry.server, baseDir, entry.tenantId, dirname(entry.path), remoteName, entry.owner);
     fs.mkdirSync(path.dirname(mirrorPath), { recursive: true });
-    const content = await readFile(entry.server, baseDir, entry.tenantId, dirname(entry.path), path.basename(entry.path), entry.owner);
     fs.writeFileSync(mirrorPath, content);
-    const now = new Date().toISOString();
-    db.prepare(`INSERT INTO shared_items (origin_id, owner, server, tenant_id, kind, role, remote_path, mirror_path, last_seen_modified_at, status, added_at)
-     VALUES (@origin_id, @owner, @server, @tenant_id, @kind, @role, @remote_path, @mirror_path, @last_seen_modified_at, 'active', @added_at)
+    db.prepare(`INSERT INTO shared_items (origin_id, owner, server, tenant_id, kind, role, remote_path, mirror_path, last_seen_modified_at, status, added_at, username, public_token)
+     VALUES (@origin_id, @owner, @server, @tenant_id, @kind, @role, @remote_path, @mirror_path, @last_seen_modified_at, 'active', @added_at, @username, @public_token)
      ON CONFLICT(origin_id) DO UPDATE SET
        owner = excluded.owner, kind = excluded.kind, role = excluded.role, remote_path = excluded.remote_path,
-       mirror_path = excluded.mirror_path, last_seen_modified_at = excluded.last_seen_modified_at, status = 'active'`).run({
+       mirror_path = excluded.mirror_path, last_seen_modified_at = excluded.last_seen_modified_at, status = 'active',
+       username = excluded.username, public_token = excluded.public_token`).run({
         origin_id: entry.originId,
         owner: entry.owner,
         server: entry.server,
@@ -52,17 +115,15 @@ export async function addSharedItem(db, baseDir, skillSpec, memorySpec, entry) {
         role,
         remote_path: entry.path,
         mirror_path: mirrorPath,
-        last_seen_modified_at: null,
-        added_at: now,
+        last_seen_modified_at: entry.modifiedAt ?? null,
+        added_at: new Date().toISOString(),
+        username: entry.publicToken ? '' : (entry.username ?? ''),
+        public_token: entry.publicToken ?? null,
     });
-    // Branched (not a single `const spec = kind === 'skill' ? skillSpec : memorySpec`) because
-    // upsertFile<T> is generic over TFrontmatter — a ternary's inferred union type
-    // TableSyncSpec<SkillFrontmatter> | TableSyncSpec<MemoryFrontmatter> doesn't satisfy either
-    // single-generic call signature, even though each branch alone is perfectly type-safe.
-    if (entry.kind === 'skill')
-        upsertFile(db, skillSpec, mirrorPath);
-    else
-        upsertFile(db, memorySpec, mirrorPath);
+    indexMirror(db, { skill: skillSpec, memory: memorySpec }, { kind: entry.kind, owner: entry.owner, mirror_path: mirrorPath });
+    if (entry.paused) {
+        db.prepare(`UPDATE ${entry.kind === 'skill' ? 'skills' : 'memory_docs'} SET paused = 1 WHERE source_path = ?`).run(mirrorPath);
+    }
 }
 /** folderfoo's `path` field for a file is relative to the owner's root — everything but the last segment is its containing folder path. */
 function dirname(remotePath) {
@@ -70,64 +131,85 @@ function dirname(remotePath) {
     return idx === -1 ? '' : remotePath.slice(0, idx);
 }
 /**
- * The ONLY place shared_items ever changes after the initial addSharedItem —
- * called from the web UI's recycle-icon button AND automatically once when
- * the "Shared with me" panel is opened (see mem-bucket-app.ts's #setView),
- * so a direct (non-link) share is discoverable without the user knowing to
- * click refresh first. Still no poller/timer while the panel stays closed —
- * this is "refresh on demand," not a background sync. Diffs
- * GET /shared-with-me (one call per distinct server+tenant the caller is
- * connected to via a remote folder — see `remoteFolders` below, NOT just the
- * servers/tenants already present in shared_items, so a share that never
- * went through the link-redeem flow at all — e.g. folderfoo's Share Manager
- * UI adding a username directly, or bucket_share_item — is still discovered
- * here, not only shares that started life as a link) against locally-tracked
- * origin_ids:
- *  - origin_id present live but NOT locally tracked → a new direct share
- *    (never accepted via a link, so addSharedItem never ran for it) — added
- *    via addSharedItem exactly as the accept route would.
- *  - origin_id missing from the response → the share was revoked (or the
- *    item deleted) — evict from the cache/search-index via removeFile and
- *    mark the row 'revoked' (kept for the UI's dismissible "no longer
- *    shared with you" row, not silently dropped — see routes.ts).
- *  - origin_id present with a newer modifiedAt → refetch content, rewrite
- *    the mirror file, re-run upsertFile (which auto-invalidates search_index
- *    for the new content).
- *  - origin_id present with an unchanged modifiedAt → left alone.
- * A rename on the owner's side is NOT distinguished from a content edit
- * here — both just mean "modifiedAt moved and remote_path may differ" — the
- * mirror_path is deliberately kept path-independent (path.join(mirrorDir,
- * originId, filename)) so a rename never needs a file move, only the
- * `remote_path` bookkeeping column changes.
+ * Brings shared_items in line with folderfoo for the CURRENT login — called from the web UI's
+ * recycle-icon button and once when the "Shared with me" panel opens. Still no poller/timer:
+ * this is "refresh on demand," not a background sync.
+ *
+ * Login-granted items: one GET /shared-with-me per server+tenant in `servers` (plus any already
+ * tracked), diffed by origin_id against the rows granted to `username`. Rows granted to a
+ * different login are never touched — the other login's shares are simply absent from this
+ * response, which is not a revocation.
+ *  - live but not tracked → a direct share nobody here accepted; added PAUSED, so content someone
+ *    else chose to push is not agent-visible until the user unpauses it.
+ *  - tracked but not live → revoked (or deleted); evicted from the cache and mirror, row kept as
+ *    'revoked' for the UI's dismissible "no longer shared with you" entry.
+ *  - newer modifiedAt, or the mirror file is gone → refetched and reindexed.
+ *  - otherwise only the bookkeeping columns (role, remote_path) are brought up to date — an
+ *    owner-side rename or role change does not move modifiedAt.
+ * The mirror path is origin_id-based, so a rename never needs a file move.
+ *
+ * Public-link items have no /shared-with-me entry; each is re-read through its own link.
  */
-export async function refreshSharedItems(db, baseDir, skillSpec, memorySpec, remoteFolders) {
-    const summary = { added: 0, updated: 0, revoked: 0, unchanged: 0 };
-    const tracked = db.prepare(`SELECT * FROM shared_items WHERE status = 'active'`).all();
-    const byServerTenant = new Map();
-    for (const row of tracked) {
-        const key = `${row.server}::${row.tenant_id}`;
-        const list = byServerTenant.get(key) ?? [];
-        list.push(row);
-        byServerTenant.set(key, list);
+export async function refreshSharedItems(db, baseDir, skillSpec, memorySpec, servers, username) {
+    const summary = { added: 0, updated: 0, revoked: 0, unchanged: 0, errors: [], authExpired: false };
+    const specs = { skill: skillSpec, memory: memorySpec };
+    const noteError = (what, err) => {
+        if (err instanceof FolderfooAuthError)
+            summary.authExpired = true;
+        summary.errors.push(`${what}: ${err.message}`);
+        console.error(`[memory-bucket] ${what}:`, err);
+    };
+    const revoke = (row) => {
+        removeMirror(db, baseDir, row);
+        db.prepare(`UPDATE shared_items SET status = 'revoked' WHERE origin_id = ?`).run(row.origin_id);
+        summary.revoked++;
+    };
+    const active = db.prepare(`SELECT * FROM shared_items WHERE status = 'active'`).all();
+    for (const row of active.filter((r) => r.public_token)) {
+        try {
+            const content = publicContentToMarkdown((await fetchPublicLink(row.server, row.public_token)).content);
+            const current = fs.existsSync(row.mirror_path) ? fs.readFileSync(row.mirror_path, 'utf-8') : null;
+            if (current === content) {
+                summary.unchanged++;
+                continue;
+            }
+            fs.mkdirSync(path.dirname(row.mirror_path), { recursive: true });
+            fs.writeFileSync(row.mirror_path, content);
+            indexMirror(db, specs, row);
+            summary.updated++;
+        }
+        catch (err) {
+            // 404 is folderfoo's answer for a revoked, expired, or deleted link — anything else is a
+            // transient failure that must not be mistaken for a revocation.
+            if (err instanceof FolderfooRequestError && err.status === 404)
+                revoke(row);
+            else
+                noteError(`failed to refresh public item ${row.origin_id}`, err);
+        }
     }
-    // Union in every connected remote folder's server+tenant too, even ones with zero tracked shared
-    // items yet — otherwise a user who's never accepted a share link has no known server to poll at
-    // all, and a fresh direct share would never surface no matter how many times they hit refresh.
-    for (const { server, tenantId } of remoteFolders) {
+    if (username === null)
+        return summary;
+    const byServerTenant = new Map();
+    const groupFor = (server, tenantId) => {
         const key = `${server}::${tenantId}`;
-        if (!byServerTenant.has(key))
-            byServerTenant.set(key, []);
+        let group = byServerTenant.get(key);
+        if (!group)
+            byServerTenant.set(key, (group = { server, tenantId, rows: [] }));
+        return group;
+    };
+    for (const row of active) {
+        if (!row.public_token && isVisibleTo(row, username))
+            groupFor(row.server, row.tenant_id).rows.push(row);
     }
-    for (const [key, rows] of byServerTenant) {
-        const sepIdx = key.indexOf('::');
-        const server = key.slice(0, sepIdx);
-        const tenantId = key.slice(sepIdx + 2);
+    for (const { server, tenantId } of servers)
+        groupFor(server, tenantId);
+    for (const { server, tenantId, rows } of byServerTenant.values()) {
         let live;
         try {
             live = await getSharedWithMe(server, baseDir, tenantId);
         }
         catch (err) {
-            console.error(`[memory-bucket] failed to refresh shared items for ${server}:`, err);
+            noteError(`failed to refresh shared items from ${server}`, err);
             continue;
         }
         const liveByOrigin = new Map(live.filter((e) => e.originId).map((e) => [e.originId, e]));
@@ -135,38 +217,33 @@ export async function refreshSharedItems(db, baseDir, skillSpec, memorySpec, rem
         for (const row of rows) {
             const liveEntry = liveByOrigin.get(row.origin_id);
             if (!liveEntry) {
-                removeFile(db, row.kind === 'skill' ? 'skills' : 'memory_docs', row.mirror_path);
-                db.prepare(`UPDATE shared_items SET status = 'revoked' WHERE origin_id = ?`).run(row.origin_id);
-                fs.rmSync(path.dirname(row.mirror_path), { recursive: true, force: true });
-                summary.revoked++;
-                continue;
-            }
-            if (liveEntry.modifiedAt === row.last_seen_modified_at) {
-                summary.unchanged++;
+                revoke(row);
                 continue;
             }
+            const role = liveEntry.role ?? row.role;
             try {
-                const content = await readFile(server, baseDir, tenantId, dirname(liveEntry.name), path.basename(liveEntry.name), liveEntry.owner);
-                fs.writeFileSync(row.mirror_path, content);
-                const mtimeDate = new Date(liveEntry.modifiedAt);
-                fs.utimesSync(row.mirror_path, mtimeDate, mtimeDate);
-                if (row.kind === 'skill')
-                    upsertFile(db, skillSpec, row.mirror_path);
-                else
-                    upsertFile(db, memorySpec, row.mirror_path);
-                db.prepare(`UPDATE shared_items SET remote_path = ?, last_seen_modified_at = ?, role = ? WHERE origin_id = ?`).run(liveEntry.name, liveEntry.modifiedAt, liveEntry.role ?? row.role, row.origin_id);
-                summary.updated++;
+                if (liveEntry.modifiedAt !== row.last_seen_modified_at || !fs.existsSync(row.mirror_path)) {
+                    const content = await readFile(server, baseDir, tenantId, dirname(liveEntry.name), path.basename(liveEntry.name), liveEntry.owner);
+                    fs.mkdirSync(path.dirname(row.mirror_path), { recursive: true });
+                    fs.writeFileSync(row.mirror_path, content);
+                    const mtimeDate = new Date(liveEntry.modifiedAt);
+                    fs.utimesSync(row.mirror_path, mtimeDate, mtimeDate);
+                    indexMirror(db, specs, row);
+                    summary.updated++;
+                }
+                else {
+                    summary.unchanged++;
+                }
+                db.prepare(`UPDATE shared_items SET remote_path = ?, last_seen_modified_at = ?, role = ?, username = ? WHERE origin_id = ?`).run(liveEntry.name, liveEntry.modifiedAt, role, username, row.origin_id);
             }
             catch (err) {
-                console.error(`[memory-bucket] failed to refresh shared item ${row.origin_id}:`, err);
+                noteError(`failed to refresh shared item ${row.origin_id}`, err);
             }
         }
-        // Anything live for this server/tenant that isn't already tracked is a share this app never
-        // saw an accept event for (a direct-username share, or one made before this feature existed) —
-        // file it exactly as the accept route would, kind-filtered since a plain (non-mcp-memory-
-        // bucket) file/folder share has kind:null and nothing here knows how to mirror it.
+        // kind-filtered: a plain (non-mcp-memory-bucket) file/folder share has kind:null and nothing
+        // here knows how to mirror it.
         for (const entry of live) {
-            if (!entry.originId || !entry.kind || trackedOrigins.has(entry.originId))
+            if (entry.type !== 'file' || !entry.originId || !entry.kind || trackedOrigins.has(entry.originId))
                 continue;
             try {
                 await addSharedItem(db, baseDir, skillSpec, memorySpec, {
@@ -177,42 +254,103 @@ export async function refreshSharedItems(db, baseDir, skillSpec, memorySpec, rem
                     originId: entry.originId,
                     kind: entry.kind,
                     role: entry.role ?? 'member',
+                    username,
+                    modifiedAt: entry.modifiedAt,
+                    paused: true,
                 });
                 summary.added++;
             }
             catch (err) {
-                console.error(`[memory-bucket] failed to add newly-discovered shared item ${entry.originId}:`, err);
+                noteError(`failed to add newly-discovered shared item ${entry.originId}`, err);
             }
         }
     }
     return summary;
 }
+/**
+ * Makes the skills/memory_docs cache agree with shared_items for the current login: an item the
+ * login can see is indexed from its mirror file, anything else (another login's item, a revoked
+ * one) is evicted. Run at startup, on every login/logout, and after a cache rebuild — the rebuild
+ * wipes both tables and rescans only the configured source directories, which never include the
+ * shared mirror. A visible item whose mirror file is gone is marked for refetch on the next refresh.
+ */
+export function syncSharedItemsIndex(db, skillSpec, memorySpec, username) {
+    const rows = db.prepare(`SELECT * FROM shared_items`).all();
+    for (const row of rows) {
+        try {
+            if (row.status !== 'active' || !isVisibleTo(row, username)) {
+                removeFile(db, row.kind === 'skill' ? 'skills' : 'memory_docs', row.mirror_path);
+            }
+            else if (fs.existsSync(row.mirror_path)) {
+                indexMirror(db, { skill: skillSpec, memory: memorySpec }, row);
+            }
+            else {
+                db.prepare(`UPDATE shared_items SET last_seen_modified_at = NULL WHERE origin_id = ?`).run(row.origin_id);
+            }
+        }
+        catch (err) {
+            console.error(`[memory-bucket] failed to index shared item ${row.origin_id}:`, err);
+        }
+    }
+}
 /** Dismisses a revoked row from the "Shared with me" panel — no-ops (does not un-revoke) for a still-active row; use refreshSharedItems to detect revocation in the first place. */
 export function dismissRevokedSharedItem(db, originId) {
     db.prepare(`DELETE FROM shared_items WHERE origin_id = ? AND status = 'revoked'`).run(originId);
 }
-/** Single-row lookup by origin_id — used by the "fork to mine" route (routes.ts) to read the
- * mirror_path/kind it needs before handing off to MemoryRepository.create/SkillRepository.create. */
+/** Single-row lookup by origin_id. */
 export function getSharedItem(db, originId) {
     return db.prepare(`SELECT * FROM shared_items WHERE origin_id = ?`).get(originId);
 }
+/**
+ * The shared item a "fork to mine" may copy, or the reason it can't — shared by the web route and
+ * bucket_fork_shared_item so a revoked item (mirror already evicted) or another login's item fails
+ * with a clear message instead of a raw ENOENT from reading the missing mirror file.
+ */
+export function getForkableSharedItem(db, originId, username) {
+    const item = getSharedItem(db, originId);
+    if (!item || !isVisibleTo(item, username))
+        return { error: `no shared item found with origin_id "${originId}"` };
+    if (item.status !== 'active')
+        return { error: 'this item is no longer shared with you' };
+    if (!fs.existsSync(item.mirror_path))
+        return { error: 'this shared item has no local copy yet — refresh "Shared with me" in the web UI first' };
+    return item;
+}
 /**
  * Resolves a table/id doc into the folderfoo coordinates (folderPath, name — the name folderfoo
  * actually stores it under) needed to call shareWithUser/unshareWithUser/createShareLink/
- * createPublicLink. Shared by the web UI's share routes (routes.ts) AND the bucket_share_item/
- * bucket_unshare_item/bucket_fork_shared_item MCP tools (shared/bucket-share-tool.ts) so the "must
- * be remote, must exist under a connected folder" resolution logic lives in exactly one place.
- * Returns null if the doc isn't remote (a purely local doc has nothing on folderfoo to address).
+ * createPublicLink, or the reason it can't be shared. Shared by the web UI's share routes
+ * (routes.ts) AND the bucket_share_item/bucket_unshare_item MCP tools so this resolution lives in
+ * exactly one place. `folder` disambiguates a skill name that exists in more than one folder
+ * (skill ids are unique per folder only); a memory doc's id is its source_path, already unique.
  */
-export function resolveShareTarget(db, repos, table, id) {
+export function resolveShareTarget(db, repos, table, id, folder) {
     const idCol = table === 'skills' ? 'id' : 'source_path';
-    const row = db.prepare(`SELECT source_path, folder FROM ${table} WHERE ${idCol} = ?`).get(id);
-    if (!row)
-        return null;
+    const rows = (folder !== undefined && table === 'skills'
+        ? db.prepare(`SELECT source_path, folder FROM skills WHERE id = ? AND folder = ?`).all(id, folder)
+        : db.prepare(`SELECT source_path, folder FROM ${table} WHERE ${idCol} = ?`).all(id));
+    // A same-named item someone shared with the caller is never the one meant here — it only
+    // counts when it is the sole match, so the error below can say why it can't be shared.
+    const own = rows.filter((r) => !isSharedFolderName(r.folder));
+    const candidates = own.length > 0 ? own : rows;
+    if (candidates.length === 0)
+        return { error: 'not found' };
+    if (candidates.length > 1) {
+        return { error: `exists in more than one folder (${candidates.map((r) => r.folder).join(', ')}) — specify folder` };
+    }
+    const row = candidates[0];
+    if (isSharedFolderName(row.folder)) {
+        return { error: 'this item is shared with you, not yours to share — fork it into your own folder first' };
+    }
     const repo = table === 'skills' ? repos.skill : repos.memory;
     const remote = repo.listRemoteFolders().find((f) => f.name === row.folder);
     if (!remote)
-        return null;
+        return { error: 'not connected to a folderfoo remote folder — sharing requires a remote-backed doc' };
+    // folderfoo only lets a file's owner share it (POST /share rejects any other caller), and
+    // addressing remote.folderPath without the owner would resolve inside the CALLER's own tree.
+    if (remote.owner) {
+        return { error: `lives in a folder ${remote.owner} shared with you — only ${remote.owner} can share it; fork it into your own folder first` };
+    }
     // Skills push to folderfoo under the fixed remote name "SKILL" regardless of local filename
     // (see sync.ts's remoteFilename.toRemote) — the folderfoo-relative NAME is therefore the
     // skill's containing directory, with "SKILL" as the addressed file, while memory docs keep
@@ -224,14 +362,13 @@ export function resolveShareTarget(db, repos, table, id) {
     const folderPath = relDir && relDir !== '.' ? joinRemoteFolderPath(remote.folderPath, relDir) : remote.folderPath;
     return { server: remote.server, tenantId: remote.tenantId, folderPath, name, kind };
 }
-export function listSharedItems(db) {
-    const rows = db.prepare(`SELECT * FROM shared_items ORDER BY added_at DESC`).all();
-    return rows.map((row) => {
-        if (row.kind === 'memory') {
-            const found = db.prepare(`SELECT source_path FROM memory_docs WHERE source_path = ?`).get(row.mirror_path);
-            return { ...row, entryId: found?.source_path ?? null };
-        }
-        const found = db.prepare(`SELECT id FROM skills WHERE source_path = ?`).get(row.mirror_path);
-        return { ...row, entryId: found?.id ?? null };
+/** Shared items the given login can see (its own, plus public-link items), newest first — never another login's. */
+export function listSharedItems(db, username) {
+    const rows = db.prepare(`SELECT * FROM shared_items ORDER BY added_at DESC`).all().filter((row) => isVisibleTo(row, username));
+    return rows.map(({ public_token, ...row }) => {
+        const table = row.kind === 'memory' ? 'memory_docs' : 'skills';
+        const idCol = row.kind === 'memory' ? 'source_path' : 'id';
+        const found = db.prepare(`SELECT ${idCol} AS id, folder, paused FROM ${table} WHERE source_path = ?`).get(row.mirror_path);
+        return { ...row, public: public_token !== null, entryId: found?.id ?? null, folder: found?.folder ?? null, paused: found?.paused === 1 };
     });
 }