studiograph 1.3.48-next.13 → 1.3.48-next.130

package/dist/mcp/tools.js

@@ -5,11 +5,21 @@
  * methods — no new business logic. Results are returned as JSON text so the
  * MCP client (Claude Desktop) can process structured data.
  *
+ * Every tool enforces per-user access control via `services/access-control.ts`.
+ * Callers (the HTTP /mcp route, the stdio MCP server) must resolve a user
+ * identity before registering tools — `registerTools` requires a user in its
+ * `McpAccessContext` argument so there is no anonymous MCP path.
+ *
  * Note: `inputSchema` is cast to `any` at each call site because the MCP SDK's
  * ZodRawShapeCompat type does not accept ZodObject in TypeScript's strict mode.
  * Runtime schema validation is handled correctly by the SDK regardless.
  */
 import { z } from 'zod';
+import { ENTITY_SCHEMAS } from '../core/validation.js';
+import { getAccessibleRepos, hasRepoAccess, canWriteRepo, getAccessibleEntityIds, filterWikilinks, } from '../services/access-control.js';
+import { createSharedFolder, FolderCreationError } from '../services/folder-creation.js';
+import { isCuratedEntityType } from '../core/entity-types-catalog.js';
+import { getAgentAllowedEntityTypes } from '../agent/prompts/entity-types-section.js';
 // ── helpers ───────────────────────────────────────────────────────────────────
 function ok(data) {
     return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
@@ -18,30 +28,137 @@ function fail(err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { content: [{ type: 'text', text: msg }], isError: true };
 }
+/** Deny-without-leaking helper — same wording as a missing repo/entity. */
+function notFound(repo) {
+    return fail(new Error(`Folder "${repo}" not found`));
+}
 // Strip frontmatter fields that duplicate the top-level id/type keys
 function shape(id, entityType, data, extra) {
     const { id: _id, entity_type: _et, ...rest } = data;
     return { id, type: entityType, ...rest, ...extra };
 }
 // ── tool registration ─────────────────────────────────────────────────────────
-export function registerTools(server, wm, authService) {
+export function registerTools(server, wm, authService, ctx) {
+    const { user, wsHub, apiTokenName } = ctx;
+    // External-agent identity: "<owner>'s <token name>", or "<owner>'s agent"
+    // as a fallback when the token has no name (older tokens or contexts that
+    // didn't thread the token through). `userId` lets the client paint the chip
+    // with the same accent as the owning user's avatar.
+    const agentLabel = apiTokenName
+        ? `${user.displayName}'s ${apiTokenName}`
+        : `${user.displayName}'s agent`;
+    const agentIdentity = {
+        kind: 'external',
+        label: agentLabel,
+        userId: String(user.id),
+    };
+    // Match the broadcast shape used by src/server/routes/graph-api.ts so the
+    // realtime listener in web/src/lib/stores/realtime.svelte.ts treats MCP
+    // mutations identically to web-UI mutations. The `agent` tag lets clients
+    // distinguish agent-driven mutations from human-driven ones.
+    function emitEntityChange(action, repo, entityType, entityId) {
+        wsHub?.broadcast({
+            type: 'entity_change',
+            action,
+            repo,
+            entityType,
+            entityId,
+            actor: user.displayName,
+            source: 'api',
+            agent: agentIdentity,
+            timestamp: new Date().toISOString(),
+        });
+    }
+    /**
+     * Wrap a mutation tool call so the sidebar can show a live "X's agent is
+     * acting" chip in the affected folder. `enter` fires before the work,
+     * `leave` after — wsHub TTL-cleans on crash. `verb` shapes the chip copy.
+     */
+    async function withAgentActivity(repo, verb, fn) {
+        wsHub?.handleAgentActivity('enter', repo, agentIdentity, verb);
+        try {
+            return await fn();
+        }
+        finally {
+            wsHub?.handleAgentActivity('leave', repo, agentIdentity, verb);
+        }
+    }
+    // Entity types the MCP surface may create. Matches the agent's allowlist so
+    // a workspace looks identical across the main app and MCP clients: the full
+    // canonical catalog plus workspace custom types. See
+    // src/core/entity-types-catalog.ts.
+    const builtinTypeKeys = new Set(Object.keys(ENTITY_SCHEMAS));
+    const customWorkspaceTypes = wm.getSchemaRegistry().getAllTypes()
+        .filter(t => !builtinTypeKeys.has(t));
+    const mcpAllowedCreateTypes = getAgentAllowedEntityTypes(customWorkspaceTypes);
+    const mcpAllowedSet = new Set(mcpAllowedCreateTypes);
     // ── list_repos ────────────────────────────────────────────────────────────
-    server.registerTool('list_repos', { description: 'List all collections in the Studiograph workspace' }, async () => ok(wm.getAllRepoConfigs()));
+    server.registerTool('list_repos', { description: 'List folders in the Studiograph workspace that you have access to' }, async () => ok(getAccessibleRepos(user, wm, authService)));
+    // ── create_repo ───────────────────────────────────────────────────────────
+    //
+    // Creates a new shared folder in the workspace and grants the
+    // caller folder-admin access. Shares its implementation with the web route
+    // POST /api/repos via services/folder-creation.ts so both surfaces behave
+    // identically. After creation, use create_entity with the new folder name
+    // to add entries. Folder names are immutable slugs; the display name is
+    // editable later via the web UI.
+    const createRepoSchema = z.object({
+        name: z.string().describe('Folder slug — lowercase kebab-case (letters, digits, hyphens; must start with a letter or digit). ' +
+            'This becomes the folder id and directory name; it cannot be changed without a rename.'),
+        display_name: z.string().optional().describe('Human-readable name shown in the UI (e.g. "Client Projects"). Defaults to the slug.'),
+        description: z.string().optional().describe('Short description of what this folder is for.'),
+    });
+    server.registerTool('create_repo', {
+        description: 'Create a new shared folder in the workspace. Use this when an agent or ' +
+            'user needs a fresh container for a new project, client area, or topic and no existing ' +
+            'folder fits. The caller is automatically granted folder-admin access. ' +
+            'Follow up with create_entity (passing the new folder name as `repo`) to seed entries. ' +
+            'Folder names must be kebab-case and unique; the private per-user "entries-<id>" ' +
+            'namespace is reserved and will be rejected.',
+        inputSchema: createRepoSchema,
+    }, async (args) => {
+        const { name, display_name, description } = createRepoSchema.parse(args);
+        try {
+            const repo = await createSharedFolder(wm, authService, { name, display_name, description }, user, wsHub);
+            return ok({ success: true, ...repo });
+        }
+        catch (err) {
+            if (err instanceof FolderCreationError) {
+                return fail(new Error(err.message));
+            }
+            return fail(err);
+        }
+    });
     // ── list_entities ─────────────────────────────────────────────────────────
     const listEntitiesSchema = z.object({
-        repo: z.string().optional().describe('Collection name — omit to list across all collections'),
-        entity_type: z.string().optional().describe('Entity type filter (project, client, person, meeting…)'),
+        repo: z.string().optional().describe('Folder name — omit to list across all folders'),
+        entity_type: z.string().optional().describe('Entity type filter (project, client, person, event…)'),
         limit: z.number().int().positive().optional().describe('Maximum number of results'),
     });
-    server.registerTool('list_entities', { description: 'List entities in a collection (or all collections). Optionally filter by entity type.', inputSchema: listEntitiesSchema }, async (args) => {
+    server.registerTool('list_entities', { description: 'List entities in a folder (or all folders). Optionally filter by entity type.', inputSchema: listEntitiesSchema }, async (args) => {
         const { repo, entity_type, limit } = listEntitiesSchema.parse(args);
         try {
             if (repo) {
+                if (!hasRepoAccess(user, repo, wm, authService))
+                    return notFound(repo);
                 const entities = wm.getGraph(repo).list(entity_type, limit);
                 return ok(entities.map(e => shape(e.id, e.entityType, e.data)));
             }
-            const entities = wm.list(entity_type, limit);
-            return ok(entities.map(e => shape(e.id, e.entityType, e.data, { repo: e.repoName })));
+            // No repo specified → iterate only over the user's accessible folders.
+            const accessible = getAccessibleRepos(user, wm, authService);
+            const results = [];
+            for (const r of accessible) {
+                try {
+                    const list = wm.getGraph(r.name).list(entity_type);
+                    for (const e of list) {
+                        results.push(shape(e.id, e.entityType, e.data, { repo: r.name }));
+                        if (limit && results.length >= limit)
+                            return ok(results);
+                    }
+                }
+                catch { /* skip unmounted repos */ }
+            }
+            return ok(results);
         }
         catch (err) {
             return fail(err);
@@ -49,12 +166,14 @@ export function registerTools(server, wm, authService) {
     });
     // ── get_entity ────────────────────────────────────────────────────────────
     const getEntitySchema = z.object({
-        repo: z.string().describe('Collection name'),
+        repo: z.string().describe('Folder name'),
         entity_type: z.string().describe('Entity type (project, client, person…)'),
         entity_id: z.string().describe('Entity ID (kebab-case slug)'),
     });
     server.registerTool('get_entity', { description: 'Get a specific entity — includes full markdown content and frontmatter', inputSchema: getEntitySchema }, async (args) => {
         const { repo, entity_type, entity_id } = getEntitySchema.parse(args);
+        if (!hasRepoAccess(user, repo, wm, authService))
+            return notFound(repo);
         try {
             const entity = wm.getGraph(repo).get(entity_type, entity_id);
             return ok({ id: entity.id, type: entity.entityType, data: entity.data, content: entity.document.content });
@@ -67,13 +186,19 @@ export function registerTools(server, wm, authService) {
     const searchSchema = z.object({
         query: z.string().optional().describe('Text search query'),
         entity_type: z.string().optional().describe('Filter by entity type'),
-        repos: z.array(z.string()).optional().describe('Limit to specific collection names'),
+        repos: z.array(z.string()).optional().describe('Limit to specific folder names'),
         limit: z.number().int().positive().optional().describe('Maximum number of results'),
     });
-    server.registerTool('search_entities', { description: 'Full-text search for entities across all collections', inputSchema: searchSchema }, async (args) => {
+    server.registerTool('search_entities', { description: 'Full-text search for entities across folders you can access', inputSchema: searchSchema }, async (args) => {
         const { query, entity_type, repos, limit } = searchSchema.parse(args);
         try {
-            const results = await wm.search({ query, entityType: entity_type, repoNames: repos, limit });
+            const accessibleNames = new Set(getAccessibleRepos(user, wm, authService).map(r => r.name));
+            const scoped = repos
+                ? repos.filter(r => accessibleNames.has(r))
+                : [...accessibleNames];
+            if (scoped.length === 0)
+                return ok([]);
+            const results = await wm.search({ query, entityType: entity_type, repoNames: scoped, limit });
             return ok(results.map(e => shape(e.id, e.entityType, e.data, { repo: e.repoName })));
         }
         catch (err) {
@@ -81,62 +206,104 @@ export function registerTools(server, wm, authService) {
         }
     });
     // ── create_entity ─────────────────────────────────────────────────────────
+    // Constrain `entity_type` to the allowlist so MCP clients (e.g. Claude Desktop)
+    // see the same type surface as the main agent. Existing canonical-type entities
+    // remain readable/updatable via other tools.
+    const createEntityTypeSchema = mcpAllowedCreateTypes.length > 0
+        ? z.enum(mcpAllowedCreateTypes)
+        : z.string();
     const createSchema = z.object({
-        repo: z.string().describe('Collection name'),
-        entity_type: z.string().describe('Entity type'),
+        repo: z.string().describe('Folder name'),
+        entity_type: createEntityTypeSchema.describe(`Entity type. Allowed: ${mcpAllowedCreateTypes.join(', ')}.`),
         entity_id: z.string().describe('Entity ID (kebab-case slug)'),
-        data: z.record(z.unknown()).describe('Frontmatter fields as a JSON object'),
+        data: z.record(z.string(), z.unknown()).describe('Frontmatter fields as a JSON object'),
         content: z.string().optional().describe('Markdown body content'),
     });
-    server.registerTool('create_entity', { description: 'Create a new entity in a collection. Commits to git automatically.', inputSchema: createSchema }, async (args) => {
+    server.registerTool('create_entity', { description: 'Create a new entity in a folder. Commits to git automatically.', inputSchema: createSchema }, async (args) => {
         const { repo, entity_type, entity_id, data, content } = createSchema.parse(args);
-        try {
-            const entity = await wm.getGraph(repo).create({
-                entityType: entity_type,
-                entityId: entity_id,
-                data: data,
-                content,
-            });
-            return ok({ success: true, id: entity.id, type: entity.entityType });
+        if (!hasRepoAccess(user, repo, wm, authService))
+            return notFound(repo);
+        if (!canWriteRepo(user, repo, wm, authService)) {
+            return fail(new Error(`You do not have write access to folder "${repo}"`));
         }
-        catch (err) {
-            return fail(err);
+        // Defense in depth: MCP SDK may not enforce zod enum strictly on all clients.
+        if (!mcpAllowedSet.has(entity_type)) {
+            if (entity_type === 'asset') {
+                // The enum already excludes `asset` (see getAgentAllowedEntityTypes).
+                // This handles MCP clients that bypass the enum schema.
+                return fail(new Error('Asset entities cannot be created via create_entity — they require a binary blob plus a sidecar text file. Use the workspace upload UI or POST /api/repos/:repo/assets directly.'));
+            }
+            const hint = isCuratedEntityType(entity_type)
+                ? '' // shouldn't happen for any other curated type — they're all allowed
+                : ` Allowed: ${mcpAllowedCreateTypes.join(', ')}.`;
+            return fail(new Error(`Entity type "${entity_type}" is not a known canonical or workspace custom type.${hint}`));
         }
+        return withAgentActivity(repo, 'creating', async () => {
+            try {
+                const entity = await wm.getGraph(repo).create({
+                    entityType: entity_type,
+                    entityId: entity_id,
+                    data: data,
+                    content,
+                });
+                emitEntityChange('created', repo, entity.entityType, entity.id);
+                return ok({ success: true, id: entity.id, type: entity.entityType });
+            }
+            catch (err) {
+                return fail(err);
+            }
+        });
     });
     // ── update_entity ─────────────────────────────────────────────────────────
     const updateSchema = z.object({
-        repo: z.string().describe('Collection name'),
+        repo: z.string().describe('Folder name'),
         entity_type: z.string().describe('Entity type'),
         entity_id: z.string().describe('Entity ID'),
-        data: z.record(z.unknown()).optional().describe('Frontmatter fields to update (merged with existing)'),
+        data: z.record(z.string(), z.unknown()).optional().describe('Frontmatter fields to update (merged with existing)'),
         content: z.string().optional().describe('New markdown body content'),
     });
     server.registerTool('update_entity', { description: 'Update an existing entity. Data fields are merged with existing frontmatter.', inputSchema: updateSchema }, async (args) => {
         const { repo, entity_type, entity_id, data, content } = updateSchema.parse(args);
-        try {
-            const entity = await wm.getGraph(repo).update({
-                entityType: entity_type,
-                entityId: entity_id,
-                data: data,
-                content,
-            });
-            return ok({ success: true, id: entity.id, type: entity.entityType });
-        }
-        catch (err) {
-            return fail(err);
+        if (!hasRepoAccess(user, repo, wm, authService))
+            return notFound(repo);
+        if (!canWriteRepo(user, repo, wm, authService)) {
+            return fail(new Error(`You do not have write access to folder "${repo}"`));
         }
+        return withAgentActivity(repo, 'editing', async () => {
+            try {
+                const entity = await wm.getGraph(repo).update({
+                    entityType: entity_type,
+                    entityId: entity_id,
+                    data: data,
+                    content,
+                });
+                emitEntityChange('updated', repo, entity.entityType, entity.id);
+                return ok({ success: true, id: entity.id, type: entity.entityType });
+            }
+            catch (err) {
+                return fail(err);
+            }
+        });
     });
     // ── validate_wikilinks ────────────────────────────────────────────────────
     const validateWikilinksSchema = z.object({
-        repo: z.string().describe('Collection name'),
+        repo: z.string().describe('Folder name'),
         entity_type: z.string().describe('Entity type'),
         entity_id: z.string().describe('Entity ID'),
     });
     server.registerTool('validate_wikilinks', { description: 'Check which wikilinks in an entity resolve to real entities and which are broken', inputSchema: validateWikilinksSchema }, async (args) => {
         const { repo, entity_type, entity_id } = validateWikilinksSchema.parse(args);
+        if (!hasRepoAccess(user, repo, wm, authService))
+            return notFound(repo);
         try {
             const result = wm.getGraph(repo).validateWikilinks(entity_type, entity_id);
-            return ok({ entity_id, valid: result.valid, broken: result.broken, total: result.valid.length + result.broken.length });
+            const accessibleIds = getAccessibleEntityIds(user, wm, authService);
+            const valid = filterWikilinks(result.valid, accessibleIds);
+            // Anything the user can't see is reported as broken rather than valid —
+            // it shouldn't leak the target's existence.
+            const hiddenFromValid = result.valid.filter(id => !valid.includes(id));
+            const broken = [...result.broken, ...hiddenFromValid];
+            return ok({ entity_id, valid, broken, total: valid.length + broken.length });
         }
         catch (err) {
             return fail(err);
@@ -144,7 +311,7 @@ export function registerTools(server, wm, authService) {
     });
     // ── find_related ──────────────────────────────────────────────────────────
     const relatedSchema = z.object({
-        repo: z.string().describe('Collection name'),
+        repo: z.string().describe('Folder name'),
         entity_type: z.string().describe('Entity type'),
         entity_id: z.string().describe('Entity ID'),
         direction: z.enum(['outgoing', 'incoming', 'both']).default('both')
@@ -152,15 +319,26 @@ export function registerTools(server, wm, authService) {
     });
     server.registerTool('find_related', { description: 'Find entities related via wikilinks (outgoing) or backlinks (incoming)', inputSchema: relatedSchema }, async (args) => {
         const { repo, entity_type, entity_id, direction } = relatedSchema.parse(args);
+        if (!hasRepoAccess(user, repo, wm, authService))
+            return notFound(repo);
         try {
+            const accessibleIds = getAccessibleEntityIds(user, wm, authService);
             const results = [];
             if (direction === 'outgoing' || direction === 'both') {
                 const related = wm.getGraph(repo).getRelated(entity_type, entity_id);
-                results.push(...related.map(e => shape(e.id, e.entityType, e.data, { direction: 'outgoing' })));
+                for (const e of related) {
+                    if (accessibleIds && !accessibleIds.has(e.id))
+                        continue;
+                    results.push(shape(e.id, e.entityType, e.data, { direction: 'outgoing' }));
+                }
             }
             if (direction === 'incoming' || direction === 'both') {
                 const backlinks = wm.getBacklinks(repo, entity_type, entity_id);
-                results.push(...backlinks.map(e => shape(e.id, e.entityType, e.data, { direction: 'incoming', repo: e.repoName })));
+                for (const e of backlinks) {
+                    if (!hasRepoAccess(user, e.repoName, wm, authService))
+                        continue;
+                    results.push(shape(e.id, e.entityType, e.data, { direction: 'incoming', repo: e.repoName }));
+                }
             }
             return ok(results);
         }
@@ -168,84 +346,337 @@ export function registerTools(server, wm, authService) {
             return fail(err);
         }
     });
-    // ── View management tools ────────────────────────────────────────────────
-    if (authService) {
-        server.registerTool('list_views', { description: 'List the current user\'s saved views.', inputSchema: z.object({}) }, async () => {
-            try {
-                return ok(authService.getUserViews(0));
-            }
-            catch (err) {
-                return fail(err);
+    // ── list_skills ──────────────────────────────────────────────────────────
+    //
+    // Surfaces user-authored `skill` entities to external MCP clients so
+    // connected agents (Claude Desktop, Cursor, etc.) can discover and run
+    // the workspace's codified workflows. Only graph skills (entities) are
+    // exposed; bundled filesystem skills (onboarding/interview/enrichment
+    // prompts) stay internal to Studiograph's own agent.
+    const listSkillsSchema = z.object({
+        repo: z.string().optional().describe('Folder name — omit to list across all folders you have access to'),
+    });
+    function projectSkill(entity, repo) {
+        const data = entity.data;
+        return {
+            id: entity.id,
+            name: data.name || entity.id,
+            description: data.description ?? '',
+            repo,
+            loading: data.loading === 'eager' ? 'eager' : 'on-demand',
+        };
+    }
+    // `graph.list('skill')` is lenient — root-level .md files without a
+    // declared `entity_type` (READMEs, CHANGELOGs) get tagged as whatever the
+    // caller asks for. For MCP we want only real skills, so require the
+    // frontmatter to explicitly say `entity_type: skill`.
+    function isRealSkill(entity) {
+        return entity.data.entity_type === 'skill';
+    }
+    server.registerTool('list_skills', {
+        description: 'List skills (reusable agent instructions) available in the Studiograph workspace. ' +
+            'Skills are user-authored markdown — call get_skill to read the full body and follow ' +
+            'its instructions. Optionally filter by folder.',
+        inputSchema: listSkillsSchema,
+    }, async (args) => {
+        const { repo } = listSkillsSchema.parse(args);
+        try {
+            if (repo) {
+                if (!hasRepoAccess(user, repo, wm, authService))
+                    return notFound(repo);
+                const skills = wm.getGraph(repo).list('skill');
+                return ok(skills.filter(isRealSkill).map(e => projectSkill(e, repo)));
             }
-        });
-        const createViewSchema = z.object({
-            name: z.string().describe('View name'),
-            selected_type: z.string().optional().describe('Entity type filter (e.g. "task")'),
-            group_by: z.string().optional().describe('Column to group by (e.g. "status")'),
-        });
-        server.registerTool('create_view', { description: 'Create a new saved view. Views appear as tabs in the web UI toolbar.', inputSchema: createViewSchema }, async (args) => {
-            const { name, selected_type, group_by } = createViewSchema.parse(args);
-            try {
-                const config = {
-                    selectedType: selected_type ?? null,
-                    groupBy: group_by ?? null,
-                    sortKey: 'name',
-                    sortAsc: true,
-                    filters: { text: {}, enum: {}, date: {} },
-                };
-                const view = authService.createUserView(0, name, 'list', config);
-                return ok({ success: true, view: { id: view.id, name: view.name, config: view.config } });
+            const accessible = getAccessibleRepos(user, wm, authService);
+            const results = [];
+            for (const r of accessible) {
+                try {
+                    const skills = wm.getGraph(r.name).list('skill');
+                    for (const e of skills) {
+                        if (isRealSkill(e))
+                            results.push(projectSkill(e, r.name));
+                    }
+                }
+                catch { /* skip unmounted repos */ }
             }
-            catch (err) {
-                return fail(err);
+            return ok(results);
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    // ── get_skill ────────────────────────────────────────────────────────────
+    //
+    // Returns the full markdown body of a skill alongside its metadata. The
+    // body is instructions to follow — the MCP client is the runtime. No
+    // server-side agent loop, no parameter substitution in v1.
+    const getSkillSchema = z.object({
+        name: z.string().describe('Skill id (the entity_id of the skill entity)'),
+        repo: z.string().optional().describe('Folder to look in. Omit to search across all accessible folders.'),
+    });
+    server.registerTool('get_skill', {
+        description: 'Fetch the full content of a skill. Returns the skill\'s markdown body along with its ' +
+            'metadata. The body contains instructions to follow — read it and apply it to the current task.',
+        inputSchema: getSkillSchema,
+    }, async (args) => {
+        const { name, repo } = getSkillSchema.parse(args);
+        try {
+            if (repo) {
+                if (!hasRepoAccess(user, repo, wm, authService))
+                    return notFound(repo);
+                try {
+                    const entity = wm.getGraph(repo).get('skill', name);
+                    if (!isRealSkill({ data: entity.data })) {
+                        return fail(new Error(`Skill "${name}" not found`));
+                    }
+                    return ok({
+                        ...projectSkill({ id: entity.id, data: entity.data }, repo),
+                        content: entity.document.content,
+                    });
+                }
+                catch {
+                    return fail(new Error(`Skill "${name}" not found`));
+                }
             }
-        });
-        const updateViewSchema = z.object({
-            id: z.number().describe('View ID'),
-            name: z.string().optional().describe('New view name'),
-            selected_type: z.string().optional().describe('Entity type filter (use "all" to clear)'),
-            group_by: z.string().optional().describe('Column to group by (use "none" to clear)'),
-        });
-        server.registerTool('update_view', { description: 'Update a saved view\'s name or configuration.', inputSchema: updateViewSchema }, async (args) => {
-            const { id, name, selected_type, group_by } = updateViewSchema.parse(args);
-            try {
-                const existing = authService.getUserView(id, 0);
-                if (!existing)
-                    return fail(`View ${id} not found`);
-                const fields = {};
-                if (name)
-                    fields.name = name;
-                if (selected_type !== undefined || group_by !== undefined) {
-                    const config = { ...existing.config };
-                    if (selected_type !== undefined)
-                        config.selectedType = selected_type === 'all' ? null : selected_type;
-                    if (group_by !== undefined)
-                        config.groupBy = group_by === 'none' ? null : group_by;
-                    fields.config = config;
+            // No repo — search accessible folders for the skill by id.
+            const accessible = getAccessibleRepos(user, wm, authService);
+            const matches = [];
+            for (const r of accessible) {
+                try {
+                    const entity = wm.getGraph(r.name).get('skill', name);
+                    if (!isRealSkill({ data: entity.data }))
+                        continue;
+                    matches.push({ repo: r.name, entity });
                 }
-                authService.updateUserView(id, 0, fields);
-                return ok({ success: true });
+                catch { /* not in this repo */ }
             }
-            catch (err) {
-                return fail(err);
+            if (matches.length === 0)
+                return fail(new Error(`Skill "${name}" not found`));
+            if (matches.length > 1) {
+                const folders = matches.map(m => m.repo).join(', ');
+                return fail(new Error(`Skill "${name}" exists in multiple folders (${folders}). Specify repo.`));
             }
-        });
-        const deleteViewSchema = z.object({
-            id: z.number().describe('View ID to delete'),
-        });
-        server.registerTool('delete_view', { description: 'Delete a saved view.', inputSchema: deleteViewSchema }, async (args) => {
-            const { id } = deleteViewSchema.parse(args);
+            const { repo: matchRepo, entity } = matches[0];
+            return ok({
+                ...projectSkill({ id: entity.id, data: entity.data }, matchRepo),
+                content: entity.document.content,
+            });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    // ── Git history tools ──────────────────────────────────────────────────────
+    //
+    // Mirrors the agent's history-tools.ts surface so external MCP clients get
+    // the same primitives. Reads gated on hasRepoAccess; restore_file gated on
+    // canWriteRepo. Single-entity scope only — multi-entity rollback is
+    // intentionally absent (deferred to a future revert_commit).
+    const listFileHistorySchema = z.object({
+        repo: z.string().describe('Folder name'),
+        entity_type: z.string().describe('Entity type'),
+        entity_id: z.string().describe('Entry ID'),
+        limit: z.number().optional().describe('Max commits (default 20, max 100)'),
+    });
+    server.registerTool('list_file_history', { description: 'List commits that touched a single entry, newest first.', inputSchema: listFileHistorySchema }, async (args) => {
+        const { repo, entity_type, entity_id, limit } = listFileHistorySchema.parse(args);
+        try {
+            if (!hasRepoAccess(user, repo, wm, authService))
+                return fail(`Folder "${repo}" not found`);
+            const graph = wm.getGraph(repo);
+            const gitService = graph.getGitService();
+            if (!gitService)
+                return fail('Folder is not git-backed');
+            let entityPath;
             try {
-                const existing = authService.getUserView(id, 0);
-                if (!existing)
-                    return fail(`View ${id} not found`);
-                authService.deleteUserView(id, 0);
-                return ok({ success: true, message: `Deleted view "${existing.name}"` });
+                const entity = graph.get(entity_type, entity_id);
+                const { relative: relativePath } = await import('path');
+                entityPath = relativePath(graph.getRepoPath(), entity.path);
             }
-            catch (err) {
-                return fail(err);
+            catch {
+                const idLower = `${entity_id}.md`.toLowerCase();
+                const match = gitService.listRecentDeletions(30).find((d) => d.filePath.toLowerCase().endsWith(idLower));
+                if (!match)
+                    return fail(`Entry ${entity_type}/${entity_id} not found in "${repo}".`);
+                entityPath = match.filePath;
             }
-        });
-    }
+            const cap = Math.min(100, Math.max(1, limit ?? 20));
+            const commits = gitService.getFileHistory(entityPath, cap).map((c) => ({
+                hash: c.hash.slice(0, 8),
+                fullHash: c.hash,
+                author: c.author,
+                timestamp: c.timestamp,
+                message: c.message,
+            }));
+            return ok({ repo, entityType: entity_type, entityId: entity_id, commits });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    const listFolderHistorySchema = z.object({
+        repo: z.string().describe('Folder name'),
+        limit: z.number().optional().describe('Max commits (default 30, max 200)'),
+    });
+    server.registerTool('list_folder_history', { description: 'List recent commits across an entire folder.', inputSchema: listFolderHistorySchema }, async (args) => {
+        const { repo, limit } = listFolderHistorySchema.parse(args);
+        try {
+            if (!hasRepoAccess(user, repo, wm, authService))
+                return fail(`Folder "${repo}" not found`);
+            const gitService = wm.getGraph(repo).getGitService();
+            if (!gitService)
+                return fail('Folder is not git-backed');
+            const cap = Math.min(200, Math.max(1, limit ?? 30));
+            const commits = gitService.getHistory(cap).map((c) => ({
+                hash: c.hash.slice(0, 8),
+                fullHash: c.hash,
+                author: c.author,
+                timestamp: c.timestamp,
+                message: c.message,
+            }));
+            return ok({ repo, commits });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    const listRecentDeletionsSchema = z.object({
+        repo: z.string().describe('Folder name'),
+        within_days: z.number().optional().describe('Lookback window (default 7, max 90)'),
+    });
+    server.registerTool('list_recent_deletions', { description: 'List entries deleted within the last N days. Use before restore_file to find a target.', inputSchema: listRecentDeletionsSchema }, async (args) => {
+        const { repo, within_days } = listRecentDeletionsSchema.parse(args);
+        try {
+            if (!hasRepoAccess(user, repo, wm, authService))
+                return fail(`Folder "${repo}" not found`);
+            const gitService = wm.getGraph(repo).getGitService();
+            if (!gitService)
+                return fail('Folder is not git-backed');
+            const days = Math.min(90, Math.max(1, within_days ?? 7));
+            const raw = gitService.listRecentDeletions(days);
+            // Naive coords: use filename basename for entity_id; entity_type
+            // sniffed from frontmatter at lastVersionCommit.
+            const deletions = raw.map((d) => {
+                const idMatch = d.filePath.match(/([^/]+)\.md$/i);
+                const entityId = idMatch ? idMatch[1] : null;
+                const content = entityId ? gitService.getFileAtCommit(d.filePath, d.lastVersionCommit) : null;
+                let entityType = null;
+                if (content) {
+                    const fm = content.match(/^---\s*\n([\s\S]*?)\n---/);
+                    const tm = fm?.[1].match(/^entity_type:\s*['"]?([\w-]+)['"]?\s*$/m);
+                    if (tm)
+                        entityType = tm[1];
+                }
+                if (!entityId || !entityType)
+                    return null;
+                return {
+                    entityType,
+                    entityId,
+                    deletedAt: d.deletedAt,
+                    deletedBy: d.deletedBy.name,
+                    deletedInCommit: d.deletedAtCommit.slice(0, 8),
+                    lastVersionCommit: d.lastVersionCommit,
+                    commitMessage: d.commitMessage,
+                    path: d.filePath,
+                };
+            }).filter((x) => x !== null);
+            return ok({ repo, withinDays: days, deletions });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    const readFileAtCommitSchema = z.object({
+        repo: z.string().describe('Folder name'),
+        entity_type: z.string().describe('Entity type'),
+        entity_id: z.string().describe('Entry ID'),
+        commit_hash: z.string().describe('Commit hash (short or full)'),
+    });
+    server.registerTool('read_file_at_commit', { description: 'Read an entry\'s full content at a specific commit.', inputSchema: readFileAtCommitSchema }, async (args) => {
+        const { repo, entity_type, entity_id, commit_hash } = readFileAtCommitSchema.parse(args);
+        try {
+            if (!hasRepoAccess(user, repo, wm, authService))
+                return fail(`Folder "${repo}" not found`);
+            const graph = wm.getGraph(repo);
+            const found = graph.getEntityAtCommit(entity_type, entity_id, commit_hash);
+            if (!found)
+                return fail(`Entry ${entity_type}/${entity_id} not found at commit ${commit_hash}`);
+            return ok({ repo, entityType: entity_type, entityId: entity_id, commitHash: commit_hash, path: found.path, content: found.content });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    const restoreFileSchema = z.object({
+        repo: z.string().describe('Folder name'),
+        entity_type: z.string().describe('Entity type'),
+        entity_id: z.string().describe('Entry ID'),
+        commit_hash: z.string().describe('Commit hash to restore from'),
+        confirm: z.boolean().optional().describe('Set to true ONLY after the user has approved the preview. Defaults to false.'),
+    });
+    server.registerTool('restore_file', { description: 'Restore an entry to its content at a specific commit. Preview-then-confirm: first call returns the preview payload, re-invoke with confirm: true to execute.', inputSchema: restoreFileSchema }, async (args) => {
+        const { repo, entity_type, entity_id, commit_hash, confirm } = restoreFileSchema.parse(args);
+        try {
+            if (!hasRepoAccess(user, repo, wm, authService))
+                return fail(`Folder "${repo}" not found`);
+            if (!canWriteRepo(user, repo, wm, authService))
+                return fail(`You don't have permission to write to "${repo}". Editor or admin role required.`);
+            const graph = wm.getGraph(repo);
+            if (confirm !== true) {
+                const found = graph.getEntityAtCommit(entity_type, entity_id, commit_hash);
+                if (!found)
+                    return fail(`Entry ${entity_type}/${entity_id} not found at commit ${commit_hash}`);
+                let action = 'recreate';
+                try {
+                    graph.get(entity_type, entity_id);
+                    action = 'overwrite';
+                }
+                catch { }
+                const sizeBytes = Buffer.byteLength(found.content, 'utf-8');
+                const shortHash = commit_hash.length > 8 ? commit_hash.slice(0, 8) : commit_hash;
+                return ok({
+                    success: false,
+                    code: 'PREVIEW_REQUIRED',
+                    preview: { action, targetPath: found.path, sizeBytes, commitHash: shortHash },
+                    message: `Will ${action} ${entity_type}/${entity_id} from ${shortHash} (${sizeBytes} bytes). Re-invoke with confirm: true after approval.`,
+                });
+            }
+            const result = await withAgentActivity(repo, 'editing', async () => {
+                const { PathConflictError } = await import('../core/graph.js');
+                try {
+                    return await graph.restoreFile(entity_type, entity_id, commit_hash);
+                }
+                catch (err) {
+                    if (err instanceof PathConflictError) {
+                        return { conflict: { path: err.path, occupiedBy: err.occupiedBy } };
+                    }
+                    throw err;
+                }
+            });
+            if ('conflict' in result) {
+                return ok({
+                    success: false,
+                    code: 'PATH_CONFLICT',
+                    conflict: result.conflict,
+                    message: `Cannot restore — ${result.conflict.path} is occupied by ${result.conflict.occupiedBy.entityType}/${result.conflict.occupiedBy.entityId}.`,
+                });
+            }
+            emitEntityChange(result.action === 'recreate' ? 'created' : 'updated', repo, entity_type, entity_id);
+            const shortHash = commit_hash.length > 8 ? commit_hash.slice(0, 8) : commit_hash;
+            return ok({
+                success: true,
+                repo,
+                entityType: entity_type,
+                entityId: entity_id,
+                action: result.action,
+                path: result.path,
+                commitHash: shortHash,
+                message: `Restored ${entity_type}/${entity_id} from ${shortHash} (${result.action}).`,
+            });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
 }
 //# sourceMappingURL=tools.js.map