mcp-memory-bucket 0.5.3 → 0.5.4

package/dist/src/skills/repository.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { writeMarkdownFile } from '../store/markdown-file.js';
 import { assertValidSkillName } from '../store/skill-name.js';
 import { resolveWithinBase } from '../store/safe-path.js';
-import { upsertFile, removeFile, scanSingleRoot, unregisterRoot, skillSyncSpec } from '../store/sync.js';
+import { upsertFile, removeFile, scanSingleFolder, unregisterFolder, skillSyncSpec } from '../store/sync.js';
 import { SearchQueryError } from '../store/search.js';
 function rowToDoc(row) {
     return {
@@ -16,77 +16,77 @@ function rowToDoc(row) {
         paused: !!row.paused,
         created_at: row.created_at ?? undefined,
         source_path: row.source_path,
-        root: row.root,
+        folder: row.folder,
         body: row.body,
     };
 }
 export class SkillRepository {
     db;
-    roots;
+    folders;
     syncSpec;
     watcher;
-    /** `roots[0]` is always the builtin skills dir — never exposed for create()/removal. */
-    constructor(db, roots) {
+    /** `folders[0]` is always the builtin skills dir — never exposed for create()/removal. */
+    constructor(db, folders) {
         this.db = db;
-        this.roots = roots;
-        this.syncSpec = skillSyncSpec(roots);
+        this.folders = folders;
+        this.syncSpec = skillSyncSpec(folders);
     }
-    /** Attaches the live chokidar watcher so addRoot/removeRoot can mutate it without a restart. */
+    /** Attaches the live chokidar watcher so addFolder/removeFolder can mutate it without a restart. */
     setWatcher(watcher) {
         this.watcher = watcher;
     }
-    /** User-addable roots — excludes the always-present builtin skills dir at roots[0]. */
-    listRoots() {
-        return this.roots.slice(1);
+    /** User-addable folders — excludes the always-present builtin skills dir at folders[0]. */
+    listFolders() {
+        return this.folders.slice(1);
     }
-    resolveRoot(rootName) {
-        const userRoots = this.listRoots();
-        if (rootName) {
-            const found = userRoots.find((r) => r.name === rootName);
+    resolveFolder(folderName) {
+        const userFolders = this.listFolders();
+        if (folderName) {
+            const found = userFolders.find((f) => f.name === folderName);
             if (!found) {
-                throw new Error(`unknown skill root "${rootName}" — valid roots: ${userRoots.map((r) => r.name).join(', ') || '(none configured)'}`);
+                throw new Error(`unknown skill folder "${folderName}" — valid folders: ${userFolders.map((f) => f.name).join(', ') || '(none configured)'}`);
             }
             return found;
         }
-        if (userRoots.length === 1)
-            return userRoots[0];
-        if (userRoots.length === 0) {
-            throw new Error('no skill root configured — add one first (see bucket_open_ui)');
+        if (userFolders.length === 1)
+            return userFolders[0];
+        if (userFolders.length === 0) {
+            throw new Error('no skill folder configured — add one first (see bucket_open_ui)');
         }
-        throw new Error(`multiple skill roots configured — specify root: one of ${userRoots.map((r) => r.name).join(', ')}`);
+        throw new Error(`multiple skill folders configured — specify folder: one of ${userFolders.map((f) => f.name).join(', ')}`);
     }
-    /** Registers a new root: appends it, scans it once, and starts watching it live. */
-    addRoot(root) {
-        if (this.roots.some((r) => r.name === root.name)) {
-            throw new Error(`a skill root named "${root.name}" already exists`);
+    /** 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)) {
+            throw new Error(`a skill folder named "${folder.name}" already exists`);
         }
-        this.roots.push(root);
-        scanSingleRoot(this.db, this.syncSpec, root.path);
-        this.watcher?.add(root.path);
+        this.folders.push(folder);
+        scanSingleFolder(this.db, this.syncSpec, folder.path);
+        this.watcher?.add(folder.path);
     }
-    /** Unregisters a root: stops watching it and drops its cached rows. Never touches files on disk. */
-    removeRoot(name) {
-        const idx = this.roots.findIndex((r) => r.name === name);
+    /** Unregisters a folder: stops watching it and drops its cached rows. Never touches files on disk. */
+    removeFolder(name) {
+        const idx = this.folders.findIndex((f) => f.name === name);
         if (idx <= 0)
-            throw new Error(`skill root "${name}" not found or is not removable`); // index 0 is builtin
-        const [removed] = this.roots.splice(idx, 1);
+            throw new Error(`skill folder "${name}" not found or is not removable`); // index 0 is builtin
+        const [removed] = this.folders.splice(idx, 1);
         this.watcher?.unwatch(removed.path);
-        unregisterRoot(this.db, 'skills', name);
+        unregisterFolder(this.db, 'skills', name);
     }
     /** `includePaused` defaults to false: paused skills are hidden from discovery (see setPaused). */
-    list(query, root, opts = {}) {
+    list(query, folder, opts = {}) {
         const conditions = [];
         const params = [];
-        if (root) {
-            conditions.push('root = ?');
-            params.push(root);
+        if (folder) {
+            conditions.push('folder = ?');
+            params.push(folder);
         }
         if (!opts.includePaused) {
             conditions.push('paused = 0');
         }
         const where = conditions.length ? ` WHERE ${conditions.join(' AND ')}` : '';
         const rows = this.db
-            .prepare(`SELECT id, description, owner, status, tags, trigger_phrases, root, paused FROM skills${where}`)
+            .prepare(`SELECT id, description, owner, status, tags, trigger_phrases, folder, paused FROM skills${where}`)
             .all(...params);
         const needle = query?.trim().toLowerCase();
         const items = rows.map((r) => ({
@@ -96,7 +96,7 @@ export class SkillRepository {
             status: r.status,
             tags: JSON.parse(r.tags),
             triggerPhrases: JSON.parse(r.trigger_phrases),
-            root: r.root,
+            folder: r.folder,
             paused: !!r.paused,
         }));
         const filtered = needle
@@ -109,16 +109,16 @@ export class SkillRepository {
     /**
      * Full-text search over skill description/body/tags via FTS5 — `query` is
      * raw FTS5 MATCH syntax (AND/OR/NOT, "phrases", prefix*). Ranked by bm25.
-     * Optional metadata filters (root/status/owner/tag) apply before limit/offset,
+     * Optional metadata filters (folder/status/owner/tag) apply before limit/offset,
      * so pagination stays correct even when filtering narrows the FTS hit set.
      */
     search(query, opts = {}) {
-        const { root, status, owner, tag, limit = 20, offset = 0, includePaused = false } = opts;
+        const { folder, status, owner, tag, limit = 20, offset = 0, includePaused = false } = opts;
         const conditions = [];
         const params = [query];
-        if (root) {
-            conditions.push('s.root = ?');
-            params.push(root);
+        if (folder) {
+            conditions.push('s.folder = ?');
+            params.push(folder);
         }
         if (status) {
             conditions.push('s.status = ?');
@@ -138,7 +138,7 @@ export class SkillRepository {
         params.push(limit, offset);
         try {
             const rows = this.db
-                .prepare(`SELECT s.id AS name, s.description, s.root,
+                .prepare(`SELECT s.id AS name, s.description, s.folder,
                   snippet(search_index, 3, '<<', '>>', '…', 20) AS snippet,
                   -bm25(search_index) AS score
            FROM search_index
@@ -162,18 +162,18 @@ export class SkillRepository {
         return names.map((name) => this.get(name)).filter((doc) => doc !== null);
     }
     /**
-     * Creates <root>/[folder/]<name>/SKILL.md — folder-per-skill, per the
+     * Creates <folder>/[subfolder/]<name>/SKILL.md — folder-per-skill, per the
      * agentskills.io spec (`name` must equal the containing folder's name).
-     * `root` selects which configured skill root to write into; required only
-     * when more than one user root is configured.
+     * `folder` selects which configured skill folder to write into; required only
+     * when more than one user folder is configured.
      */
-    create(frontmatter, body, folder, root) {
+    create(frontmatter, body, subfolder, folder) {
         assertValidSkillName(frontmatter.name);
         if (this.get(frontmatter.name)) {
             throw new Error(`skill with name "${frontmatter.name}" already exists`);
         }
-        const targetRoot = this.resolveRoot(root);
-        const skillDir = resolveWithinBase(targetRoot.path, folder, frontmatter.name);
+        const targetFolder = this.resolveFolder(folder);
+        const skillDir = resolveWithinBase(targetFolder.path, subfolder, frontmatter.name);
         if (fs.existsSync(skillDir)) {
             throw new Error(`skill directory already exists at ${skillDir}`);
         }
@@ -194,7 +194,7 @@ export class SkillRepository {
             deprecated: false,
             created_at: new Date().toISOString(),
             source_path: filePath,
-            root: targetRoot.name,
+            folder: targetFolder.name,
         };
         writeMarkdownFile(filePath, stripSourcePath(fm), body);
         upsertFile(this.db, this.syncSpec, filePath);
@@ -208,7 +208,7 @@ export class SkillRepository {
     bulkCreate(entries) {
         return entries.map((entry) => {
             try {
-                this.create(entry.frontmatter, entry.body, entry.folder, entry.root);
+                this.create(entry.frontmatter, entry.body, entry.subfolder, entry.folder);
                 return { name: entry.frontmatter.name, ok: true };
             }
             catch (err) {
@@ -216,9 +216,9 @@ export class SkillRepository {
             }
         });
     }
-    /** Name of the always-present, non-removable builtin root (roots[0]) — never user content, never deprecatable. */
+    /** Name of the always-present, non-removable builtin folder (folders[0]) — never user content, never deprecatable. */
     isBuiltin(doc) {
-        return doc.root === this.roots[0]?.name;
+        return doc.folder === this.folders[0]?.name;
     }
     update(name, frontmatter, body) {
         const existing = this.get(name);
@@ -248,7 +248,7 @@ export class SkillRepository {
         return { ...merged, body: newBody, paused: existingPaused };
     }
     /**
-     * Renames a skill: moves <sourceDir>/[folder/]<oldName>/ to .../<newName>/ (keeping any
+     * Renames a skill: moves <sourceDir>/[subfolder/]<oldName>/ to .../<newName>/ (keeping any
      * scripts/references/assets alongside SKILL.md) and updates the `name` frontmatter field to match.
      */
     rename(name, newName) {
@@ -380,6 +380,6 @@ export class SkillRepository {
     }
 }
 function stripSourcePath(fm) {
-    const { source_path: _sp, root: _root, ...rest } = fm;
+    const { source_path: _sp, folder: _folder, ...rest } = fm;
     return rest;
 }

package/dist/src/skills/tools.js

@@ -4,20 +4,20 @@ const SKILL_STATUS_DEFAULTS = ['stable', 'beta', 'unreviewed'];
 const SKILL_NAME_DESCRIPTION = 'stable id, must be 1-64 chars, lowercase letters/numbers/hyphens only, no leading/trailing/consecutive hyphens — this becomes the skill\'s folder name (agentskills.io spec requirement)';
 const AUTHORING_SKILL_HINT = "Before your first call in a session, run skill_get(\"memory-bucket-authoring\") to learn the exact frontmatter schema and conventions — don't guess the shape.";
 export function registerSkillTools(mcp, repo) {
-    const roots = repo.listRoots();
-    const multiRoot = roots.length > 1;
-    const rootNames = roots.map((r) => r.name).join(', ');
-    mcp.tool('skill_list', 'Lists skills (reusable coding patterns, one SKILL.md per folder per the agentskills.io open standard), optionally filtered by a keyword matched against description/tags/trigger phrases. Paused skills are hidden by default — pass include_paused to see them.', multiRoot
+    const folders = repo.listFolders();
+    const multiFolder = folders.length > 1;
+    const folderNames = folders.map((f) => f.name).join(', ');
+    mcp.tool('skill_list', 'Lists skills (reusable coding patterns, one SKILL.md per folder per the agentskills.io open standard), optionally filtered by a keyword matched against description/tags/trigger phrases. Paused skills are hidden by default — pass include_paused to see them.', multiFolder
         ? {
             query: z.string().optional(),
-            root: z.string().optional().describe(`filter to one root: ${rootNames}`),
+            folder: z.string().optional().describe(`filter to one folder: ${folderNames}`),
             include_paused: z.boolean().optional().describe('include paused skills, which are hidden by default (see skill_set_paused)'),
         }
         : {
             query: z.string().optional(),
             include_paused: z.boolean().optional().describe('include paused skills, which are hidden by default (see skill_set_paused)'),
-        }, async ({ query, root, include_paused }) => {
-        const items = repo.list(query, root, { includePaused: include_paused });
+        }, async ({ query, folder, include_paused }) => {
+        const items = repo.list(query, folder, { includePaused: include_paused });
         return { content: [{ type: 'text', text: JSON.stringify(items, null, 2) }] };
     });
     mcp.tool('skill_search', 'Full-text search over skill description/body/tags (grep/find-like, ranked by relevance) — unlike skill_list\'s substring metadata filter, this searches the full markdown body. `query` is raw SQLite FTS5 MATCH syntax: bare words, "exact phrases", prefix* wildcards, AND/OR/NOT boolean operators; hyphenated/punctuated terms must be quoted, e.g. "blue-green". Can be combined with status/owner/tag filters. Returns ranked hits with a highlighted snippet, not the full body — call skill_get on a hit\'s name for that. Paused skills are hidden by default — pass include_paused to see them.', {
@@ -28,10 +28,10 @@ export function registerSkillTools(mcp, repo) {
         limit: z.number().int().positive().max(100).optional(),
         offset: z.number().int().nonnegative().optional(),
         include_paused: z.boolean().optional().describe('include paused skills, which are hidden by default (see skill_set_paused)'),
-        ...(multiRoot ? { root: z.string().optional().describe(`filter to one root: ${rootNames}`) } : {}),
-    }, async ({ query, status, owner, tag, limit, offset, root, include_paused }) => {
+        ...(multiFolder ? { folder: z.string().optional().describe(`filter to one folder: ${folderNames}`) } : {}),
+    }, async ({ query, status, owner, tag, limit, offset, folder, include_paused }) => {
         try {
-            const hits = repo.search(query, { root, status, owner, tag, limit, offset, includePaused: include_paused });
+            const hits = repo.search(query, { folder, status, owner, tag, limit, offset, includePaused: include_paused });
             return { content: [{ type: 'text', text: JSON.stringify(hits, null, 2) }] };
         }
         catch (err) {
@@ -61,7 +61,7 @@ export function registerSkillTools(mcp, repo) {
         const docs = repo.bulkGet(names);
         return { content: [{ type: 'text', text: JSON.stringify(docs, null, 2) }] };
     });
-    mcp.tool('skill_create', `Creates a new skill as <root>/[folder/]<name>/SKILL.md, per the agentskills.io open standard — a folder containing SKILL.md, optionally alongside scripts/references/assets subfolders you create separately on disk. ${AUTHORING_SKILL_HINT}`, {
+    mcp.tool('skill_create', `Creates a new skill as <folder>/[subfolder/]<name>/SKILL.md, per the agentskills.io open standard — a folder containing SKILL.md, optionally alongside scripts/references/assets subfolders you create separately on disk. ${AUTHORING_SKILL_HINT}`, {
         name: z.string().describe(SKILL_NAME_DESCRIPTION),
         description: z
             .string()
@@ -75,11 +75,11 @@ export function registerSkillTools(mcp, repo) {
         tags: z.array(z.string()).optional(),
         trigger_phrases: z.array(z.string()).optional(),
         extends: z.string().optional().describe('reserved for a future overlay mechanism — stored in frontmatter.metadata'),
-        folder: z.string().optional().describe('optional subdirectory under the skill root, e.g. "frontend"'),
-        ...(multiRoot ? { root: z.string().describe(`which configured skill root to write into: ${rootNames}`) } : {}),
-    }, async ({ name, description, body, license, compatibility, owner, status, tags, trigger_phrases, extends: extendsId, folder, root }) => {
+        subfolder: z.string().optional().describe('optional subdirectory under the skill folder, e.g. "frontend"'),
+        ...(multiFolder ? { folder: z.string().describe(`which configured skill folder to write into: ${folderNames}`) } : {}),
+    }, async ({ name, description, body, license, compatibility, owner, status, tags, trigger_phrases, extends: extendsId, subfolder, folder }) => {
         try {
-            const doc = repo.create({ name, description, license, compatibility, owner, status, tags, trigger_phrases, extends: extendsId }, body, folder, root);
+            const doc = repo.create({ name, description, license, compatibility, owner, status, tags, trigger_phrases, extends: extendsId }, body, subfolder, folder);
             return { content: [{ type: 'text', text: JSON.stringify(doc, null, 2) }] };
         }
         catch (err) {
@@ -97,8 +97,8 @@ export function registerSkillTools(mcp, repo) {
         tags: z.array(z.string()).optional(),
         trigger_phrases: z.array(z.string()).optional(),
         extends: z.string().optional(),
-        folder: z.string().optional(),
-        ...(multiRoot ? { root: z.string().describe(`which configured skill root to write into: ${rootNames}`) } : {}),
+        subfolder: z.string().optional(),
+        ...(multiFolder ? { folder: z.string().describe(`which configured skill folder to write into: ${folderNames}`) } : {}),
     });
     mcp.tool('skill_bulk_create', `Creates many skills in one call — each entry is the same shape as skill_create's args. Returns per-name success/failure so one bad entry (duplicate name, invalid name, existing directory) doesn't abort the rest of the batch. ${AUTHORING_SKILL_HINT}`, { entries: z.array(skillEntrySchema).min(1) }, async ({ entries }) => {
         const results = repo.bulkCreate(entries.map((e) => ({
@@ -114,8 +114,8 @@ export function registerSkillTools(mcp, repo) {
                 extends: e.extends,
             },
             body: e.body,
+            subfolder: e.subfolder,
             folder: e.folder,
-            root: e.root,
         })));
         return { content: [{ type: 'text', text: JSON.stringify(results, null, 2) }] };
     });

package/dist/src/store/db.js

@@ -12,7 +12,7 @@ export function openCache(dbPath) {
       trigger_phrases TEXT NOT NULL,  -- JSON array
       extends TEXT,
       source_path TEXT NOT NULL UNIQUE, -- path to SKILL.md
-      root TEXT NOT NULL DEFAULT '',  -- name of the configured root this file lives under
+      folder TEXT NOT NULL DEFAULT '',  -- name of the configured folder this file lives under
       deprecated INTEGER NOT NULL DEFAULT 0,
       paused INTEGER NOT NULL DEFAULT 0, -- local-only: never synced from/to SKILL.md, cache-file scoped
       created_at TEXT,
@@ -30,7 +30,7 @@ export function openCache(dbPath) {
       status TEXT NOT NULL,
       related_to TEXT,
       source_path TEXT NOT NULL UNIQUE,
-      root TEXT NOT NULL DEFAULT '',  -- name of the configured root this file lives under
+      folder TEXT NOT NULL DEFAULT '',  -- name of the configured folder this file lives under
       deprecated INTEGER NOT NULL DEFAULT 0,
       paused INTEGER NOT NULL DEFAULT 0, -- local-only: never synced from/to the doc's markdown file, cache-file scoped
       created_at TEXT,
@@ -59,13 +59,13 @@ export function openCache(dbPath) {
     CREATE INDEX IF NOT EXISTS idx_doc_dates_ref ON doc_dates(ref_table, ref_id);
   `);
     ensureColumns(db, 'skills', [
-        ['root', "TEXT NOT NULL DEFAULT ''"],
+        ['folder', "TEXT NOT NULL DEFAULT ''"],
         ['deprecated', 'INTEGER NOT NULL DEFAULT 0'],
         ['paused', 'INTEGER NOT NULL DEFAULT 0'],
         ['created_at', 'TEXT'],
     ]);
     ensureColumns(db, 'memory_docs', [
-        ['root', "TEXT NOT NULL DEFAULT ''"],
+        ['folder', "TEXT NOT NULL DEFAULT ''"],
         ['deprecated', 'INTEGER NOT NULL DEFAULT 0'],
         ['paused', 'INTEGER NOT NULL DEFAULT 0'],
         ['created_at', 'TEXT'],

package/dist/src/store/search.js

@@ -101,7 +101,7 @@ export function searchCombined(db, query, limit = 20, offset = 0) {
         return db
             .prepare(`SELECT ref_table, ref_id AS id,
                 COALESCE(s.description, m.description) AS description,
-                COALESCE(s.root, m.root) AS root,
+                COALESCE(s.folder, m.folder) AS folder,
                 snippet(search_index, 3, '<<', '>>', '…', 20) AS snippet,
                 -bm25(search_index) AS score
          FROM search_index

package/dist/src/store/sync.js

@@ -74,15 +74,15 @@ export function memorySyncSpec(sources) {
  * synchronously right after their own writes — the watcher's own event for
  * that same write becomes a harmless no-op re-check once mtime matches.
  */
-/** Which configured root a file lives under, by longest matching path prefix. */
-function rootForFile(sources, filePath) {
+/** Which configured folder a file lives under, by longest matching path prefix. */
+function folderForFile(sources, filePath) {
     const resolved = path.resolve(filePath);
     let best;
-    for (const root of sources) {
-        const rootPath = path.resolve(root.path);
-        if (resolved === rootPath || resolved.startsWith(rootPath + path.sep)) {
-            if (!best || rootPath.length > path.resolve(best.path).length)
-                best = root;
+    for (const folder of sources) {
+        const folderPath = path.resolve(folder.path);
+        if (resolved === folderPath || resolved.startsWith(folderPath + path.sep)) {
+            if (!best || folderPath.length > path.resolve(best.path).length)
+                best = folder;
         }
     }
     return best?.name ?? '';
@@ -103,9 +103,9 @@ export function upsertFile(db, spec, filePath) {
         return;
     }
     const row = spec.toRow(frontmatter, filePath, parsed.mtimeMs);
-    const root = rootForFile(spec.sources, filePath);
-    const cols = [...spec.columns, 'source_path', 'root', 'body', 'mtime_ms'];
-    const values = [...spec.columns.map((c) => row[c]), filePath, root, parsed.body, parsed.mtimeMs];
+    const folder = folderForFile(spec.sources, filePath);
+    const cols = [...spec.columns, 'source_path', 'folder', 'body', 'mtime_ms'];
+    const values = [...spec.columns.map((c) => row[c]), filePath, folder, parsed.body, parsed.mtimeMs];
     const placeholders = cols.map(() => '?').join(', ');
     const updateClause = cols
         .filter((c) => c !== 'id')
@@ -138,10 +138,10 @@ export function removeFile(db, table, filePath) {
 }
 /** Full scan of all configured source dirs — used once at startup before the watcher takes over. */
 export function initialScan(db, spec) {
-    for (const root of spec.sources) {
-        if (!fs.existsSync(root.path))
+    for (const folder of spec.sources) {
+        if (!fs.existsSync(folder.path))
             continue;
-        for (const file of walkMarkdownFiles(root.path)) {
+        for (const file of walkMarkdownFiles(folder.path)) {
             if (!spec.matchesFile(file))
                 continue;
             try {
@@ -153,8 +153,8 @@ export function initialScan(db, spec) {
         }
     }
 }
-/** Full scan of a single dir — used when a new root is added live, after registering it in spec.sources. */
-export function scanSingleRoot(db, spec, dirPath) {
+/** Full scan of a single dir — used when a new folder is added live, after registering it in spec.sources. */
+export function scanSingleFolder(db, spec, dirPath) {
     if (!fs.existsSync(dirPath))
         return;
     for (const file of walkMarkdownFiles(dirPath)) {
@@ -168,10 +168,10 @@ export function scanSingleRoot(db, spec, dirPath) {
         }
     }
 }
-/** Drops all cached rows (and search index entries) belonging to a removed root. Never touches files on disk. */
-export function unregisterRoot(db, table, rootName) {
-    const rows = db.prepare(`SELECT id FROM ${table} WHERE root = ?`).all(rootName);
-    db.prepare(`DELETE FROM ${table} WHERE root = ?`).run(rootName);
+/** Drops all cached rows (and search index entries) belonging to a removed folder. Never touches files on disk. */
+export function unregisterFolder(db, table, folderName) {
+    const rows = db.prepare(`SELECT id FROM ${table} WHERE folder = ?`).all(folderName);
+    db.prepare(`DELETE FROM ${table} WHERE folder = ?`).run(folderName);
     for (const row of rows) {
         db.prepare(`DELETE FROM search_index WHERE ref_table = ? AND ref_id = ?`).run(table, row.id);
     }
@@ -188,7 +188,7 @@ function* walkMarkdownFiles(dir) {
     }
 }
 export function watchSources(db, spec) {
-    const watcher = chokidar.watch(spec.sources.map((r) => r.path), { ignoreInitial: true, persistent: true, depth: 10 });
+    const watcher = chokidar.watch(spec.sources.map((f) => f.path), { ignoreInitial: true, persistent: true, depth: 10 });
     watcher
         .on('add', (filePath) => {
         if (!spec.matchesFile(filePath))

package/dist/src/web/routes.js

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import express from 'express';
 import matter from 'gray-matter';
-import { saveRoot, removeRoot as removeRootFromConfig, sanitizeRootName } from '../config.js';
+import { saveFolder, removeFolder as removeFolderFromConfig, sanitizeFolderName } from '../config.js';
 import { initialScan } from '../store/sync.js';
 function asArray(v) {
     if (v === undefined)
@@ -23,7 +23,7 @@ function queryEntries(db, req) {
     const owners = asArray(req.query.owner);
     const docTypes = asArray(req.query.doc_type);
     const keyTypes = asArray(req.query.key_type);
-    const roots = asArray(req.query.root);
+    const folders = asArray(req.query.folder);
     const q = req.query.q?.trim();
     const deprecatedParam = req.query.deprecated;
     const deprecated = deprecatedParam === '0' || deprecatedParam === '1' ? deprecatedParam : undefined;
@@ -43,10 +43,10 @@ function queryEntries(db, req) {
     }
     const results = [];
     if (type === 'skill' || type === 'all') {
-        results.push(...queryTable(db, 'skills', { tags, statuses, owners, docTypes: [], keyTypes: [], roots, deprecated, paused }, intersectIds(matchedIds?.skills, dateIds?.skills)));
+        results.push(...queryTable(db, 'skills', { tags, statuses, owners, docTypes: [], keyTypes: [], folders, deprecated, paused }, intersectIds(matchedIds?.skills, dateIds?.skills)));
     }
     if (type === 'memory' || type === 'all') {
-        results.push(...queryTable(db, 'memory_docs', { tags, statuses, owners: [], docTypes, keyTypes, roots, deprecated, paused }, intersectIds(matchedIds?.memory_docs, dateIds?.memory_docs)));
+        results.push(...queryTable(db, 'memory_docs', { tags, statuses, owners: [], docTypes, keyTypes, folders, deprecated, paused }, intersectIds(matchedIds?.memory_docs, dateIds?.memory_docs)));
     }
     const sort = req.query.sort ?? 'mtime_desc';
     results.sort((a, b) => {
@@ -91,9 +91,9 @@ function queryTable(db, table, filters, restrictToIds) {
         where += ` AND key_type IN (${filters.keyTypes.map(() => '?').join(', ')})`;
         params.push(...filters.keyTypes);
     }
-    if (filters.roots.length > 0) {
-        where += ` AND root IN (${filters.roots.map(() => '?').join(', ')})`;
-        params.push(...filters.roots);
+    if (filters.folders.length > 0) {
+        where += ` AND folder IN (${filters.folders.map(() => '?').join(', ')})`;
+        params.push(...filters.folders);
     }
     if (filters.deprecated !== undefined) {
         where += ` AND deprecated = ?`;
@@ -109,7 +109,7 @@ function queryTable(db, table, filters, restrictToIds) {
     }
     if (table === 'skills') {
         const rows = db
-            .prepare(`SELECT id, description, owner, status, tags, root, mtime_ms, deprecated, paused, created_at FROM skills WHERE ${where}`)
+            .prepare(`SELECT id, description, owner, status, tags, folder, mtime_ms, deprecated, paused, created_at FROM skills WHERE ${where}`)
             .all(...params);
         return rows.map((r) => ({
             _table: 'skills',
@@ -121,7 +121,7 @@ function queryTable(db, table, filters, restrictToIds) {
             owner: r.owner,
             doc_type: null,
             key_type: null,
-            root: r.root,
+            folder: r.folder,
             mtime_ms: r.mtime_ms,
             deprecated: !!r.deprecated,
             paused: !!r.paused,
@@ -129,7 +129,7 @@ function queryTable(db, table, filters, restrictToIds) {
         }));
     }
     const rows = db
-        .prepare(`SELECT id, key, description, doc_type, key_type, status, tags, root, mtime_ms, deprecated, paused, created_at FROM memory_docs WHERE ${where}`)
+        .prepare(`SELECT id, key, description, doc_type, key_type, status, tags, folder, mtime_ms, deprecated, paused, created_at FROM memory_docs WHERE ${where}`)
         .all(...params);
     return rows.map((r) => ({
         _table: 'memory_docs',
@@ -141,7 +141,7 @@ function queryTable(db, table, filters, restrictToIds) {
         owner: null,
         doc_type: r.doc_type,
         key_type: r.key_type,
-        root: r.root,
+        folder: r.folder,
         mtime_ms: r.mtime_ms,
         deprecated: !!r.deprecated,
         paused: !!r.paused,
@@ -203,27 +203,27 @@ function buildFacets(db, type) {
     const owners = new Set();
     const docTypes = new Set();
     const keyTypes = new Set();
-    const roots = new Set();
+    const folders = new Set();
     if (type === 'skill' || type === 'all') {
-        const rows = db.prepare(`SELECT tags, status, owner, root FROM skills`).all();
+        const rows = db.prepare(`SELECT tags, status, owner, folder FROM skills`).all();
         for (const r of rows) {
             JSON.parse(r.tags).forEach((t) => tags.add(t));
             statuses.add(r.status);
             if (r.owner)
                 owners.add(r.owner);
-            if (r.root)
-                roots.add(r.root);
+            if (r.folder)
+                folders.add(r.folder);
         }
     }
     if (type === 'memory' || type === 'all') {
-        const rows = db.prepare(`SELECT tags, status, doc_type, key_type, root FROM memory_docs`).all();
+        const rows = db.prepare(`SELECT tags, status, doc_type, key_type, folder FROM memory_docs`).all();
         for (const r of rows) {
             JSON.parse(r.tags).forEach((t) => tags.add(t));
             statuses.add(r.status);
             docTypes.add(r.doc_type);
             keyTypes.add(r.key_type);
-            if (r.root)
-                roots.add(r.root);
+            if (r.folder)
+                folders.add(r.folder);
         }
     }
     return {
@@ -232,7 +232,7 @@ function buildFacets(db, type) {
         owners: [...owners].sort(),
         doc_types: [...docTypes].sort(),
         key_types: [...keyTypes].sort(),
-        roots: [...roots].sort(),
+        folders: [...folders].sort(),
     };
 }
 function buildHealth(db) {
@@ -494,13 +494,13 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
     router.get('/api/health', (_req, res) => {
         res.json(buildHealth(db));
     });
-    router.get('/api/roots', (_req, res) => {
+    router.get('/api/folders', (_req, res) => {
         res.json({
-            skill: skillRepo.listRoots().map((r) => ({ ...r, kind: 'skill' })),
-            memory: memoryRepo.listRoots().map((r) => ({ ...r, kind: 'memory' })),
+            skill: skillRepo.listFolders().map((f) => ({ ...f, kind: 'skill' })),
+            memory: memoryRepo.listFolders().map((f) => ({ ...f, kind: 'memory' })),
         });
     });
-    router.post('/api/roots', (req, res) => {
+    router.post('/api/folders', (req, res) => {
         const { kind, name, path: dirPath } = req.body;
         if (kind !== 'skill' && kind !== 'memory') {
             res.status(400).json({ error: 'kind must be "skill" or "memory"' });
@@ -514,35 +514,35 @@ export function buildWebRouter(db, config, skillRepo, memoryRepo, skillSpec, mem
             res.status(400).json({ error: `not a directory: ${dirPath}` });
             return;
         }
-        const rootName = sanitizeRootName(name || path.basename(dirPath));
-        if (!rootName) {
-            res.status(400).json({ error: 'could not derive a valid root name — provide one explicitly' });
+        const folderName = sanitizeFolderName(name || path.basename(dirPath));
+        if (!folderName) {
+            res.status(400).json({ error: 'could not derive a valid folder name — provide one explicitly' });
             return;
         }
         const repo = kind === 'skill' ? skillRepo : memoryRepo;
         try {
-            repo.addRoot({ name: rootName, path: dirPath });
-            saveRoot(config, kind, { name: rootName, path: dirPath });
-            res.json({ name: rootName, path: dirPath, kind });
+            repo.addFolder({ name: folderName, path: dirPath });
+            saveFolder(config, kind, { name: folderName, path: dirPath });
+            res.json({ name: folderName, path: dirPath, kind });
         }
         catch (err) {
             res.status(409).json({ error: err.message });
         }
     });
-    router.delete('/api/roots/:kind/:name', (req, res) => {
+    router.delete('/api/folders/:kind/:name', (req, res) => {
         const { kind, name } = req.params;
         if (kind !== 'skill' && kind !== 'memory') {
             res.status(400).json({ error: 'kind must be "skill" or "memory"' });
             return;
         }
         if (!name) {
-            res.status(400).json({ error: 'root name is required' });
+            res.status(400).json({ error: 'folder name is required' });
             return;
         }
         const repo = kind === 'skill' ? skillRepo : memoryRepo;
         try {
-            repo.removeRoot(name);
-            removeRootFromConfig(config, kind, name);
+            repo.removeFolder(name);
+            removeFolderFromConfig(config, kind, name);
             res.json({ removed: name, kind });
         }
         catch (err) {