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

package/dist/agent/tools/graph-tools.js

@@ -7,11 +7,13 @@
  * - Manage wikilinks
  * - Upload assets
  */
-import { Type as T } from '@sinclair/typebox';
+import { Type as T } from 'typebox';
 import { ENTITY_SCHEMAS } from '../../core/validation.js';
 import { lintWorkspace } from '../../services/lint-service.js';
 import { findOrphans } from '../../services/orphan-service.js';
-import { isAdminOrOwner } from '../../services/auth-service.js';
+import * as access from '../../services/access-control.js';
+import { isCuratedEntityType } from '../../core/entity-types-catalog.js';
+import { getAgentAllowedEntityTypes } from '../prompts/entity-types-section.js';
 /**
  * Helper to wrap tool results in AgentToolResult format
  */
@@ -31,139 +33,229 @@ function cleanData(data) {
     return rest;
 }
 /**
- * Per-request user context for collection access filtering.
- * When getCurrentUser returns a non-admin user, tools filter results
- * to only collections the user has been granted access to.
+ * Undo JSON-string escapes that sometimes leak into content when the LLM
+ * serializes markdown as a quoted string instead of raw text. Handles `\n`,
+ * `\t`, `\r`, `\"`, `\\` in a single pass so escape sequences aren't
+ * re-processed. Also strips stray surrounding quotes from a fully-quoted
+ * payload.
  */
-/** Check if a user can see a private repo (only the owner can). */
-function canSeePrivateRepo(repoConfig, user) {
-    if (!repoConfig?.private)
-        return true;
-    if (!user)
-        return !repoConfig.owner_id; // API key / open mode — only if no owner set
-    if (!repoConfig.owner_id)
-        return false; // Private without owner — hidden from all users
-    return user.id === repoConfig.owner_id;
-}
-/** Check if the current user is an admin. Returns an error result if not. */
-function adminOnly(getUser) {
-    const user = getUser();
-    if (!user)
-        return null; // API key / open mode → allow
-    if (isAdminOrOwner(user.role))
-        return null;
-    return 'This operation requires admin access.';
+function sanitizeLlmContent(content) {
+    if (!content)
+        return '';
+    const unescaped = content.replace(/\\([ntr"\\])/g, (_, c) => {
+        if (c === 'n')
+            return '\n';
+        if (c === 't')
+            return '\t';
+        if (c === 'r')
+            return '\r';
+        return c;
+    });
+    return unescaped.replace(/^"+|"+$/g, '');
 }
+/**
+ * Per-request user context for folder access filtering.
+ * When getCurrentUser returns a user, tools filter results to only
+ * folders the user is a member of (via folder_access).
+ */
 function getAccessibleRepoNames(workspaceManager, getCurrentUser, authService) {
     const user = getCurrentUser();
     if (!user)
         return null; // API key / open mode → no filtering
     if (!authService)
         return null;
-    const allRepos = workspaceManager.getAllRepoConfigs();
-    if (isAdminOrOwner(user.role)) {
-        // Admins/owners see all non-private + their own private repos
-        const hidden = allRepos.filter(r => !canSeePrivateRepo(r, user)).map(r => r.name);
-        if (hidden.length === 0)
-            return null; // No filtering needed
-        const visible = new Set(allRepos.filter(r => canSeePrivateRepo(r, user)).map(r => r.name));
-        return visible;
-    }
-    const allowed = authService.getUserCollections(user.id);
-    const visible = allRepos.filter(r => canSeePrivateRepo(r, user) && (r.private && r.owner_id === user.id || allowed.includes(r.name)));
-    return new Set(visible.map(r => r.name));
+    // Delegate to the shared helper so personal-folder restrictions and
+    // owner-on-shared-folder semantics apply consistently with the HTTP layer.
+    return new Set(access.getAccessibleRepos(user, workspaceManager, authService).map(r => r.name));
 }
 function canAccessRepo(repoName, workspaceManager, getCurrentUser, authService) {
     const user = getCurrentUser();
-    const repoConfig = workspaceManager.getRepoConfig(repoName);
-    if (!canSeePrivateRepo(repoConfig, user))
-        return false;
     if (!user)
         return true;
-    if (repoConfig?.private && repoConfig?.owner_id === user.id)
-        return true;
-    if (isAdminOrOwner(user.role))
-        return true;
     if (!authService)
         return true;
-    return authService.getUserCollections(user.id).includes(repoName);
+    return access.hasRepoAccess(user, repoName, workspaceManager, authService);
 }
-export function createGraphTools(workspaceManager, gitUser, workspacePath, onHighlight, onMutation, getCurrentUser, authService) {
+export function createGraphTools(workspaceManager, gitUser, workspacePath, onHighlight, onMutation, getCurrentUser, authService, 
+/**
+ * Called after an entity's content is written to disk (create/update), so
+ * callers can push the new content into any active Y.Doc. Without this,
+ * agent edits bypass live editors and cause CRDT duplication on resync.
+ */
+onContentSync, 
+/**
+ * Called at the start (`enter`) and end (`leave`) of any mutation tool
+ * call. Surfaces the active-agent chip in the sidebar via the WS hub. The
+ * orchestrator wires this through to wsHub.handleAgentActivity.
+ */
+onAgentActivity) {
     const getUser = getCurrentUser ?? (() => null);
     const authSvc = authService ?? null;
-    /** Resolve "private" or "entries" to the current user's actual private collection name. */
+    /**
+     * Resolve the identity to stamp on writes. If the tool call is running on
+     * behalf of a real user (chat / quick-capture from the web), credit them
+     * by their handle — a stable email-free slug. The fake-domain email keeps
+     * git commit metadata well-formed without putting real addresses into
+     * workspace history. Fall back to the orchestrator-level gitUser for
+     * unauthenticated contexts (CLI, tests, server-only automations).
+     */
+    function effectiveGitUser() {
+        const user = getUser();
+        if (user?.handle) {
+            return {
+                id: user.handle,
+                name: user.displayName ?? user.handle,
+                email: `${user.handle}@studiograph.local`,
+            };
+        }
+        return gitUser;
+    }
+    /** Resolve "private" or "entries" to the current user's actual private folder name. */
     function resolvePrivateRepo(repoName) {
         if (repoName !== 'private' && repoName !== 'entries')
             return repoName;
         const user = getUser();
         if (!user)
             return repoName;
-        const privateRepo = workspaceManager.getUserPrivateRepo(user.id);
-        return privateRepo?.name ?? repoName;
+        const personalRepo = workspaceManager.getUserPersonalRepo(user.id);
+        return personalRepo?.name ?? repoName;
+    }
+    /**
+     * Eager skills are inlined into every system prompt for everyone with folder
+     * access. Creating one in a shared folder requires admin/owner so a rogue
+     * member can't bloat everyone's context. Eager skills in the user's own
+     * private folder are fine — they only bloat that user's own prompt.
+     * Returns an error string or null if the operation is allowed.
+     */
+    function checkEagerSkillPermission(entityType, data, repoName) {
+        if (entityType !== 'skill')
+            return null;
+        if (!data || data.loading !== 'eager')
+            return null;
+        const user = getUser();
+        if (!user)
+            return null; // non-authenticated contexts (CLI, tests) bypass
+        const personalRepo = workspaceManager.getUserPersonalRepo(user.id);
+        if (personalRepo && personalRepo.name === repoName)
+            return null;
+        if (authSvc?.isFolderAdmin(user.id, repoName))
+            return null;
+        if (user.role === 'owner')
+            return null;
+        return `Creating an eager skill in a shared folder requires folder admin or workspace owner. Save this skill to your private folder (repo: "private") or set loading to "on-demand".`;
+    }
+    // Compute the set of entity types the agent is allowed to create in this
+    // workspace: the full canonical catalog plus any custom types defined via
+    // schema_extensions. The launch-time allowlist was removed — the catalog
+    // now grows with the user via the New Entry picker's progressive disclosure.
+    const builtinTypeKeys = new Set(Object.keys(ENTITY_SCHEMAS));
+    const customWorkspaceTypes = workspaceManager.getSchemaRegistry().getAllTypes()
+        .filter(t => !builtinTypeKeys.has(t));
+    const agentAllowedTypes = getAgentAllowedEntityTypes(customWorkspaceTypes);
+    const agentAllowedTypeSet = new Set(agentAllowedTypes);
+    function rejectDisallowedCreateType(entityType) {
+        if (agentAllowedTypeSet.has(entityType))
+            return null;
+        if (entityType === 'asset') {
+            // The schema enum already excludes `asset` (see
+            // getAgentAllowedEntityTypes). This is the runtime defense-in-depth
+            // path for clients that bypass the enum.
+            return wrapToolResult({
+                success: false,
+                error: 'Asset entries cannot be created via create_entity — they require a binary blob plus a sidecar text file. Use the import_file tool with a local file path, or have the user upload via the workspace import dialog.',
+            });
+        }
+        const hint = isCuratedEntityType(entityType)
+            ? '' // shouldn't happen for any other curated type — they're all allowed
+            : ` Allowed types: ${agentAllowedTypes.join(', ')}.`;
+        return wrapToolResult({
+            success: false,
+            error: `Entry type "${entityType}" is not a known canonical or workspace custom type.${hint}`,
+        });
     }
     return [
         // Create entity
         {
             name: 'create_entity',
             label: 'Create Entry',
-            description: 'Create a new entry in a collection. Always validate required fields before calling. Collection is auto-resolved for app-defined entry types.',
+            description: 'Create a new entry in a folder. Always validate required fields before calling. Folder is auto-resolved for app-defined entry types.',
             parameters: T.Object({
-                repo: T.Optional(T.String({ description: 'Collection name (auto-resolved for app entity types)' })),
-                entityType: T.String({ description: 'Entity type (project, client, decision, etc.)' }),
+                repo: T.Optional(T.String({ description: 'Folder name (auto-resolved for app entity types)' })),
+                entityType: T.Union(agentAllowedTypes.map(t => T.Literal(t)), { description: `Entity type. Must be one of: ${agentAllowedTypes.join(', ')}.` }),
                 entityId: T.String({ description: 'Unique entity ID in kebab-case' }),
                 data: T.Object({}, { description: 'Entity data (YAML frontmatter)', additionalProperties: true }),
                 content: T.Optional(T.String({ description: 'Markdown content (optional)' })),
+                folder_path: T.Optional(T.String({ description: 'Repo-relative subfolder for the entry (e.g. "clients/acme"). Omit to land at repo root. Parent folders are auto-created.' })),
                 commitMessage: T.Optional(T.String({ description: 'Custom commit message (optional)' })),
             }),
             execute: async (toolCallId, params) => {
                 try {
+                    // Defense in depth: LLMs occasionally pass strings that don't match the
+                    // enum schema. Runtime check ensures the launch allowlist is enforced
+                    // even if the schema layer is bypassed.
+                    const typeRejection = rejectDisallowedCreateType(params.entityType);
+                    if (typeRejection)
+                        return typeRejection;
                     let repoName = params.repo;
                     if (!repoName) {
-                        repoName = workspaceManager.getAppForEntityType(params.entityType);
-                        if (!repoName)
-                            return wrapToolResult({ success: false, error: `repo is required — could not auto-resolve repo for type "${params.entityType}"` });
+                        return wrapToolResult({ success: false, error: `repo is required — must specify which folder to use for type "${params.entityType}"` });
                     }
                     repoName = resolvePrivateRepo(repoName);
                     if (!canAccessRepo(repoName, workspaceManager, getUser, authSvc)) {
-                        return wrapToolResult({ success: false, error: `Collection "${repoName}" not found` });
+                        return wrapToolResult({ success: false, error: `Folder "${repoName}" not found` });
                     }
+                    const eagerError = checkEagerSkillPermission(params.entityType, params.data, repoName);
+                    if (eagerError)
+                        return wrapToolResult({ success: false, error: eagerError });
                     const graph = workspaceManager.getGraph(repoName);
                     // Workspace-level dedup: warn if an entity with this ID already exists elsewhere
                     const existing = workspaceManager.findEntityById(params.entityId);
                     if (existing && existing.repoName !== repoName) {
-                        return wrapToolResult({ success: false, error: `An entity with ID "${params.entityId}" already exists in the "${existing.repoName}" collection (type: ${existing.data?.entity_type}). Use a unique ID or link to the existing entity with [[${params.entityId}]].` });
+                        return wrapToolResult({ success: false, error: `An entity with ID "${params.entityId}" already exists in the "${existing.repoName}" folder (type: ${existing.data?.entity_type}). Use a unique ID or link to the existing entity with [[${params.entityId}]].` });
                     }
                     // Add timestamps and user info
+                    const actor = effectiveGitUser();
                     const now = new Date().toISOString();
                     const dataWithMeta = {
                         ...params.data,
                         entity_id: params.entityId,
                         created_at: now,
                         updated_at: now,
-                        created_by: gitUser.id,
-                        updated_by: gitUser.id,
+                        created_by: actor.id,
+                        updated_by: actor.id,
                     };
-                    // Sanitize LLM JSON output: double-escaped newlines and stray quotes
-                    let sanitizedContent = (params.content || '').replace(/\\n/g, '\n').replace(/^"+|"+$/g, '');
-                    const entity = await graph.create({
-                        entityType: params.entityType,
-                        entityId: params.entityId,
-                        data: dataWithMeta,
-                        content: sanitizedContent,
-                        commitMessage: params.commitMessage,
-                    });
-                    onMutation?.({ action: 'created', repo: repoName, entityType: params.entityType, entityId: params.entityId });
-                    return wrapToolResult({
-                        success: true,
-                        entity: {
-                            entityId: entity.id,
-                            entityType: entity.entityType,
-                            repo: repoName,
-                            path: entity.path,
-                            data: cleanData(entity.data),
-                        },
-                        message: `Created ${params.entityType}: ${params.entityId} in ${repoName}. Auto-committed — ready to push.`,
-                    });
+                    const sanitizedContent = sanitizeLlmContent(params.content);
+                    // Surface a live "<user>'s agent is acting" chip in the sidebar for
+                    // the duration of the mutation. `leave` is always emitted via the
+                    // inner finally so a thrown error doesn't leave the chip stuck.
+                    onAgentActivity?.('enter', repoName);
+                    try {
+                        const entity = await graph.create({
+                            entityType: params.entityType,
+                            entityId: params.entityId,
+                            data: dataWithMeta,
+                            content: sanitizedContent,
+                            commitMessage: params.commitMessage,
+                            user: actor,
+                            folderPath: params.folder_path,
+                        });
+                        onContentSync?.(repoName, params.entityType, params.entityId);
+                        onMutation?.({ action: 'created', repo: repoName, entityType: params.entityType, entityId: params.entityId });
+                        return wrapToolResult({
+                            success: true,
+                            entity: {
+                                entityId: entity.id,
+                                entityType: entity.entityType,
+                                repo: repoName,
+                                path: entity.path,
+                                data: cleanData(entity.data),
+                            },
+                            message: `Created ${params.entityType}: ${params.entityId} in ${repoName}. Auto-committed — ready to push.`,
+                        });
+                    }
+                    finally {
+                        onAgentActivity?.('leave', repoName);
+                    }
                 }
                 catch (error) {
                     return wrapToolResult({
@@ -179,7 +271,7 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
             label: 'Get Entry',
             description: 'Retrieve full entry details. Use repo, entityType, entityId from search/list results. entityType is optional — if omitted it is read from the file.',
             parameters: T.Object({
-                repo: T.String({ description: 'Collection name' }),
+                repo: T.String({ description: 'Folder name' }),
                 entityType: T.Optional(T.String({ description: 'Entity type (optional — resolved from frontmatter if omitted)' })),
                 entityId: T.String({ description: 'Entity ID' }),
             }),
@@ -187,12 +279,25 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
                 try {
                     const repo = resolvePrivateRepo(params.repo);
                     if (!canAccessRepo(repo, workspaceManager, getUser, authSvc)) {
-                        return wrapToolResult({ success: false, error: `Collection "${repo}" not found` });
+                        return wrapToolResult({ success: false, error: `Folder "${repo}" not found` });
                     }
                     const graph = workspaceManager.getGraph(repo);
-                    const entity = params.entityType
-                        ? graph.get(params.entityType, params.entityId)
-                        : graph.getById(params.entityId);
+                    // If the agent passes the wrong entityType (e.g. based on stale
+                    // search results), graph.get computes the wrong filesystem path
+                    // and throws. Fall back to getById, which scans all type subdirs
+                    // under the folder and resolves the actual location.
+                    let entity;
+                    if (params.entityType) {
+                        try {
+                            entity = graph.get(params.entityType, params.entityId);
+                        }
+                        catch {
+                            entity = graph.getById(params.entityId);
+                        }
+                    }
+                    else {
+                        entity = graph.getById(params.entityId);
+                    }
                     return wrapToolResult({
                         success: true,
                         entity: {
@@ -218,9 +323,9 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
         {
             name: 'update_entity',
             label: 'Update Entry',
-            description: 'Update an existing entry. Collection is auto-resolved for app-defined types.',
+            description: 'Update an existing entry. Folder is auto-resolved for app-defined types.',
             parameters: T.Object({
-                repo: T.Optional(T.String({ description: 'Collection name (auto-resolved for app entity types)' })),
+                repo: T.Optional(T.String({ description: 'Folder name (auto-resolved for app entity types)' })),
                 entityType: T.String({ description: 'Entity type' }),
                 entityId: T.String({ description: 'Entity ID' }),
                 data: T.Optional(T.Object({}, { description: 'Updated data fields', additionalProperties: true })),
@@ -231,44 +336,58 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
                 try {
                     let repoName = params.repo;
                     if (!repoName) {
-                        repoName = workspaceManager.getAppForEntityType(params.entityType);
-                        if (!repoName)
-                            return wrapToolResult({ success: false, error: `repo is required — could not auto-resolve repo for type "${params.entityType}"` });
+                        return wrapToolResult({ success: false, error: `repo is required — must specify which folder to use for type "${params.entityType}"` });
                     }
                     repoName = resolvePrivateRepo(repoName);
                     if (!canAccessRepo(repoName, workspaceManager, getUser, authSvc)) {
-                        return wrapToolResult({ success: false, error: `Collection "${repoName}" not found` });
+                        return wrapToolResult({ success: false, error: `Folder "${repoName}" not found` });
                     }
+                    const eagerError = checkEagerSkillPermission(params.entityType, params.data, repoName);
+                    if (eagerError)
+                        return wrapToolResult({ success: false, error: eagerError });
                     const graph = workspaceManager.getGraph(repoName);
                     // Add update metadata
+                    const actor = effectiveGitUser();
                     const dataWithMeta = params.data
                         ? {
                             ...params.data,
                             updated_at: new Date().toISOString(),
-                            updated_by: gitUser.id,
+                            updated_by: actor.id,
                         }
                         : undefined;
-                    // Sanitize LLM JSON output: double-escaped newlines and stray quotes
                     const sanitizedContent = params.content !== undefined
-                        ? params.content.replace(/\\n/g, '\n').replace(/^"+|"+$/g, '') : params.content;
-                    const entity = await graph.update({
-                        entityType: params.entityType,
-                        entityId: params.entityId,
-                        data: dataWithMeta,
-                        content: sanitizedContent,
-                        commitMessage: params.commitMessage,
-                    });
-                    onMutation?.({ action: 'updated', repo: repoName, entityType: params.entityType, entityId: params.entityId });
-                    return wrapToolResult({
-                        success: true,
-                        entity: {
-                            entityId: entity.id,
-                            entityType: entity.entityType,
-                            repo: repoName,
-                            data: cleanData(entity.data),
-                        },
-                        message: `Updated ${params.entityType}: ${params.entityId}. Auto-committed — ready to push.`,
-                    });
+                        ? sanitizeLlmContent(params.content)
+                        : params.content;
+                    onAgentActivity?.('enter', repoName);
+                    try {
+                        const entity = await graph.update({
+                            entityType: params.entityType,
+                            entityId: params.entityId,
+                            data: dataWithMeta,
+                            content: sanitizedContent,
+                            commitMessage: params.commitMessage,
+                            user: actor,
+                        });
+                        // Only sync Y.Doc when the body was actually rewritten. Pure
+                        // metadata edits don't touch content and shouldn't thrash.
+                        if (sanitizedContent !== undefined) {
+                            onContentSync?.(repoName, params.entityType, params.entityId);
+                        }
+                        onMutation?.({ action: 'updated', repo: repoName, entityType: params.entityType, entityId: params.entityId });
+                        return wrapToolResult({
+                            success: true,
+                            entity: {
+                                entityId: entity.id,
+                                entityType: entity.entityType,
+                                repo: repoName,
+                                data: cleanData(entity.data),
+                            },
+                            message: `Updated ${params.entityType}: ${params.entityId}. Auto-committed — ready to push.`,
+                        });
+                    }
+                    finally {
+                        onAgentActivity?.('leave', repoName);
+                    }
                 }
                 catch (error) {
                     return wrapToolResult({
@@ -282,9 +401,9 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
         {
             name: 'delete_entity',
             label: 'Delete Entry',
-            description: 'Delete an entry. Use with caution! Collection is auto-resolved for app-defined types.',
+            description: 'Delete an entry. Use with caution! Folder is auto-resolved for app-defined types.',
             parameters: T.Object({
-                repo: T.Optional(T.String({ description: 'Collection name (auto-resolved for app entity types)' })),
+                repo: T.Optional(T.String({ description: 'Folder name (auto-resolved for app entity types)' })),
                 entityType: T.String({ description: 'Entity type' }),
                 entityId: T.String({ description: 'Entity ID' }),
                 commitMessage: T.Optional(T.String({ description: 'Custom commit message' })),
@@ -293,21 +412,25 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
                 try {
                     let repoName = params.repo;
                     if (!repoName) {
-                        repoName = workspaceManager.getAppForEntityType(params.entityType);
-                        if (!repoName)
-                            return wrapToolResult({ success: false, error: `repo is required — could not auto-resolve repo for type "${params.entityType}"` });
+                        return wrapToolResult({ success: false, error: `repo is required — must specify which folder to use for type "${params.entityType}"` });
                     }
                     repoName = resolvePrivateRepo(repoName);
                     if (!canAccessRepo(repoName, workspaceManager, getUser, authSvc)) {
-                        return wrapToolResult({ success: false, error: `Collection "${repoName}" not found` });
+                        return wrapToolResult({ success: false, error: `Folder "${repoName}" not found` });
                     }
                     const graph = workspaceManager.getGraph(repoName);
-                    await graph.delete(params.entityType, params.entityId, params.commitMessage);
-                    onMutation?.({ action: 'deleted', repo: repoName, entityType: params.entityType, entityId: params.entityId });
-                    return wrapToolResult({
-                        success: true,
-                        message: `Deleted ${params.entityType}: ${params.entityId}. Auto-committed — ready to push.`,
-                    });
+                    onAgentActivity?.('enter', repoName);
+                    try {
+                        await graph.delete(params.entityType, params.entityId, params.commitMessage);
+                        onMutation?.({ action: 'deleted', repo: repoName, entityType: params.entityType, entityId: params.entityId });
+                        return wrapToolResult({
+                            success: true,
+                            message: `Deleted ${params.entityType}: ${params.entityId}. Auto-committed — ready to push.`,
+                        });
+                    }
+                    finally {
+                        onAgentActivity?.('leave', repoName);
+                    }
                 }
                 catch (error) {
                     return wrapToolResult({
@@ -321,46 +444,93 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
         {
             name: 'import_file',
             label: 'Import File',
-            description: 'Import a local file as a Studiograph entry. Supports .md and .txt (→ note) and .csv (→ dataset). The file is read from the local filesystem and converted to an entry with appropriate frontmatter.',
+            description: 'Import a local file as a Studiograph entry. Text formats become typed entries (.md/.txt → note, .csv → dataset). Binary formats (PDF, images, design files, video, audio, archives) become asset entries.',
             parameters: T.Object({
                 path: T.String({ description: 'Absolute path or ~/relative path to the file' }),
-                collection: T.String({ description: 'Target collection name' }),
-                entityType: T.Optional(T.String({ description: 'Override entity type (default: auto-detect from extension)' })),
+                folder: T.String({ description: 'Target folder name' }),
+                entityType: T.Optional(T.String({ description: 'Override entity type (default: auto-detect from extension; ignored for asset uploads)' })),
                 entityId: T.Optional(T.String({ description: 'Override entity ID (default: from filename)' })),
             }),
             execute: async (toolCallId, params) => {
                 try {
-                    if (!canAccessRepo(params.collection, workspaceManager, getUser, authSvc)) {
-                        return wrapToolResult({ success: false, error: `Collection "${params.collection}" not found` });
+                    if (!canAccessRepo(params.folder, workspaceManager, getUser, authSvc)) {
+                        return wrapToolResult({ success: false, error: `Folder "${params.folder}" not found` });
                     }
                     const { readFileSync, existsSync } = await import('fs');
-                    const { resolve } = await import('path');
+                    const { resolve, basename, sep } = await import('path');
                     const { homedir } = await import('os');
                     const { importFile, isSupportedFile } = await import('../../services/import-service.js');
+                    const { isAssetUploadExtension } = await import('../../services/assets/base.js');
+                    const { uploadAsset } = await import('../../services/asset-upload-service.js');
                     const filePath = params.path.startsWith('~/')
                         ? resolve(homedir(), params.path.slice(2))
                         : resolve(params.path);
                     if (!existsSync(filePath)) {
                         return wrapToolResult({ success: false, error: `File not found: ${filePath}` });
                     }
+                    const graph = workspaceManager.getGraph(params.folder);
+                    const fname = basename(filePath);
+                    // Path-exfil guard: the agent reads bytes off disk and uploads
+                    // them as a workspace asset, accessible via /api/assets/* by any
+                    // folder member. Without an allowlist, an LLM prompt injection in
+                    // an imported note can ask the agent to grab ~/.ssh/id_rsa, .env
+                    // files, kubeconfigs, etc. by renaming them to a permitted
+                    // extension. Restrict to roots a user would plausibly drop files
+                    // from: the workspace itself, ~/Downloads, ~/Documents.
+                    const home = homedir();
+                    const workspaceRoot = graph.getWorkspaceRoot();
+                    const allowedRoots = [
+                        workspaceRoot,
+                        resolve(home, 'Downloads'),
+                        resolve(home, 'Documents'),
+                    ].filter((r) => Boolean(r)).map(r => r.endsWith(sep) ? r : r + sep);
+                    const isInAllowedRoot = allowedRoots.some(root => filePath === root.slice(0, -1) || filePath.startsWith(root));
+                    if (!isInAllowedRoot) {
+                        return wrapToolResult({
+                            success: false,
+                            error: `Path "${filePath}" is outside the import allowlist. Files must live under the workspace, ~/Downloads, or ~/Documents.`,
+                        });
+                    }
+                    // Binary extensions → asset wrapper. The text-import path doesn't
+                    // know how to handle .indd / .pptx / etc. and would either reject
+                    // them or (for .pdf) mistakenly land them as a `note` entity with
+                    // extracted body text. Route to uploadAsset for parity with the
+                    // web import dispatcher.
+                    if (isAssetUploadExtension(fname)) {
+                        const buffer = readFileSync(filePath);
+                        const result = await uploadAsset({
+                            graph,
+                            filename: fname,
+                            buffer,
+                            workspacePath: graph.getWorkspaceRoot(),
+                        });
+                        onMutation?.({ action: 'created', repo: params.folder, entityType: 'asset', entityId: result.entityId });
+                        return wrapToolResult({
+                            success: true,
+                            entityType: 'asset',
+                            entityId: result.entityId,
+                            asset_kind: result.asset_kind,
+                            asset_size: result.asset_size,
+                            pages: result.pages,
+                            message: `Imported ${fname} as asset/${result.entityId} in ${params.folder}`,
+                        });
+                    }
                     if (!isSupportedFile(filePath)) {
-                        return wrapToolResult({ success: false, error: `Unsupported file type. Supported: .md, .txt, .csv` });
+                        return wrapToolResult({ success: false, error: `Unsupported file type for ${fname}` });
                     }
-                    const graph = workspaceManager.getGraph(params.collection);
                     const content = readFileSync(filePath);
-                    const { basename } = await import('path');
-                    const result = await importFile(graph, basename(filePath), content, {
+                    const result = await importFile(graph, fname, content, {
                         entityType: params.entityType,
                         entityId: params.entityId,
                     });
                     if (result.status === 'created') {
-                        onMutation?.({ action: 'created', repo: params.collection, entityType: result.entityType, entityId: result.entityId });
+                        onMutation?.({ action: 'created', repo: params.folder, entityType: result.entityType, entityId: result.entityId });
                     }
                     return wrapToolResult({
                         success: result.status === 'created',
                         ...result,
                         message: result.status === 'created'
-                            ? `Imported ${basename(filePath)} as ${result.entityType}/${result.entityId} in ${params.collection}`
+                            ? `Imported ${fname} as ${result.entityType}/${result.entityId} in ${params.folder}`
                             : result.error,
                     });
                 }
@@ -376,9 +546,9 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
         {
             name: 'rename_entity',
             label: 'Rename Entry',
-            description: 'Rename an entry by changing its ID. Preserves all data, content, and source_ref. The old ID will no longer exist. Collection is auto-resolved for app-defined types.',
+            description: 'Rename an entry by changing its ID. Preserves all data, content, and source_ref. The old ID will no longer exist. Folder is auto-resolved for app-defined types.',
             parameters: T.Object({
-                repo: T.Optional(T.String({ description: 'Collection name (auto-resolved for app entity types)' })),
+                repo: T.Optional(T.String({ description: 'Folder name (auto-resolved for app entity types)' })),
                 entityType: T.String({ description: 'Entity type' }),
                 oldId: T.String({ description: 'Current entity ID' }),
                 newId: T.String({ description: 'New entity ID (kebab-case)' }),
@@ -387,13 +557,11 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
                 try {
                     let repoName = params.repo;
                     if (!repoName) {
-                        repoName = workspaceManager.getAppForEntityType(params.entityType);
-                        if (!repoName)
-                            return wrapToolResult({ success: false, error: `repo is required — could not auto-resolve repo for type "${params.entityType}"` });
+                        return wrapToolResult({ success: false, error: `repo is required — must specify which folder to use for type "${params.entityType}"` });
                     }
                     repoName = resolvePrivateRepo(repoName);
                     if (!canAccessRepo(repoName, workspaceManager, getUser, authSvc)) {
-                        return wrapToolResult({ success: false, error: `Collection "${repoName}" not found` });
+                        return wrapToolResult({ success: false, error: `Folder "${repoName}" not found` });
                     }
                     const graph = workspaceManager.getGraph(repoName);
                     const result = await graph.rename(params.entityType, params.oldId, params.newId);
@@ -413,41 +581,41 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
                 }
             },
         },
-        // Move entity between repos
+        // Transfer entity across repos (cross-repo move). Distinct from
+        // folder-tools' `move_entity`, which relocates within one repo.
         {
-            name: 'move_entity',
-            label: 'Move Entry',
-            description: 'Move an entry from one collection to another (admin only). Preserves all data, content, and wikilinks.',
+            name: 'transfer_entity',
+            label: 'Transfer Entry',
+            description: 'Move an entry from one repo to another. Preserves all data, content, and wikilinks. Requires access to both folders. For relocating within the same repo (folder_path change), use move_entity instead.',
             parameters: T.Object({
-                sourceRepo: T.String({ description: 'Source collection name' }),
-                targetRepo: T.String({ description: 'Target collection name' }),
+                sourceRepo: T.String({ description: 'Source repo name' }),
+                targetRepo: T.String({ description: 'Target repo name' }),
                 entityType: T.String({ description: 'Entity type' }),
                 entityId: T.String({ description: 'Entity ID' }),
                 commitMessage: T.Optional(T.String({ description: 'Custom commit message (optional)' })),
             }),
             execute: async (toolCallId, params) => {
                 try {
-                    const denied = adminOnly(getUser);
-                    if (denied)
-                        return wrapToolResult({ success: false, error: denied });
                     if (!canAccessRepo(params.sourceRepo, workspaceManager, getUser, authSvc)) {
-                        return wrapToolResult({ success: false, error: `Collection "${params.sourceRepo}" not found` });
+                        return wrapToolResult({ success: false, error: `Folder "${params.sourceRepo}" not found` });
                     }
                     if (!canAccessRepo(params.targetRepo, workspaceManager, getUser, authSvc)) {
-                        return wrapToolResult({ success: false, error: `Collection "${params.targetRepo}" not found` });
+                        return wrapToolResult({ success: false, error: `Folder "${params.targetRepo}" not found` });
                     }
                     const sourceGraph = workspaceManager.getGraph(params.sourceRepo);
                     const targetGraph = workspaceManager.getGraph(params.targetRepo);
                     // Read the full entity from source
                     const entity = sourceGraph.get(params.entityType, params.entityId);
                     // Create in target repo
+                    const actor = effectiveGitUser();
                     const now = new Date().toISOString();
                     await targetGraph.create({
                         entityType: params.entityType,
                         entityId: params.entityId,
-                        data: { ...entity.data, updated_at: now, updated_by: gitUser.id },
+                        data: { ...entity.data, updated_at: now, updated_by: actor.id },
                         content: entity.document.content || '',
                         commitMessage: params.commitMessage || `Move ${params.entityType} ${params.entityId} from ${params.sourceRepo} to ${params.targetRepo}`,
+                        user: actor,
                     });
                     // Delete from source repo
                     await sourceGraph.delete(params.entityType, params.entityId, `Move ${params.entityType} ${params.entityId} to ${params.targetRepo}`);
@@ -470,11 +638,11 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
         {
             name: 'search_entities',
             label: 'Search Entries',
-            description: 'Search for entries across collections with filters.',
+            description: 'Search for entries across folders with filters.',
             parameters: T.Object({
                 query: T.Optional(T.String({ description: 'Search query (full-text)' })),
                 entityType: T.Optional(T.String({ description: 'Filter by entity type' })),
-                repoNames: T.Optional(T.Array(T.String(), { description: 'Limit to specific collections' })),
+                repoNames: T.Optional(T.Array(T.String(), { description: 'Limit to specific folders' })),
                 visibility: T.Optional(T.Array(T.String(), { description: 'Filter by visibility (public, team, admin, restricted)' })),
                 tags: T.Optional(T.Array(T.String(), { description: 'Filter by tags' })),
                 dateRange: T.Optional(T.Object({
@@ -486,7 +654,7 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
             }),
             execute: async (toolCallId, params) => {
                 try {
-                    // Scope search to accessible collections
+                    // Scope search to accessible folders
                     const allowed = getAccessibleRepoNames(workspaceManager, getUser, authSvc);
                     let repoNames = params.repoNames?.map((r) => resolvePrivateRepo(r));
                     if (allowed) {
@@ -535,7 +703,7 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
             execute: async (toolCallId, params) => {
                 try {
                     let results = workspaceManager.list(params.entityType, params.limit);
-                    // Filter to accessible collections
+                    // Filter to accessible folders
                     const allowed = getAccessibleRepoNames(workspaceManager, getUser, authSvc);
                     if (allowed) {
                         results = results.filter(r => allowed.has(r.repoName));
@@ -563,9 +731,9 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
         {
             name: 'get_related',
             label: 'Get Related Entries',
-            description: 'Get entries related to a given entry via wikilinks (cross-collection supported). Pass repo, entityType, entityId from search/list results.',
+            description: 'Get entries related to a given entry via wikilinks (cross-folder supported). Pass repo, entityType, entityId from search/list results.',
             parameters: T.Object({
-                repo: T.String({ description: 'Collection name' }),
+                repo: T.String({ description: 'Folder name' }),
                 entityType: T.String({ description: 'Entity type' }),
                 entityId: T.String({ description: 'Entity ID' }),
             }),
@@ -573,10 +741,10 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
                 try {
                     const repo = resolvePrivateRepo(params.repo);
                     if (!canAccessRepo(repo, workspaceManager, getUser, authSvc)) {
-                        return wrapToolResult({ success: false, error: `Collection "${repo}" not found` });
+                        return wrapToolResult({ success: false, error: `Folder "${repo}" not found` });
                     }
                     let related = workspaceManager.getRelated(repo, params.entityType, params.entityId);
-                    // Filter cross-collection results to accessible repos
+                    // Filter cross-folder results to accessible repos
                     const allowed = getAccessibleRepoNames(workspaceManager, getUser, authSvc);
                     if (allowed) {
                         related = related.filter(r => allowed.has(r.repoName));
@@ -604,19 +772,19 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
         {
             name: 'get_backlinks',
             label: 'Get Backlinks',
-            description: 'Get entries that link to a given entry (cross-collection supported). Pass repo, entityType, entityId from search/list results.',
+            description: 'Get entries that link to a given entry (cross-folder supported). Pass repo, entityType, entityId from search/list results.',
             parameters: T.Object({
-                repo: T.String({ description: 'Collection name' }),
+                repo: T.String({ description: 'Folder name' }),
                 entityType: T.String({ description: 'Entity type' }),
                 entityId: T.String({ description: 'Entity ID' }),
             }),
             execute: async (toolCallId, params) => {
                 try {
                     if (!canAccessRepo(params.repo, workspaceManager, getUser, authSvc)) {
-                        return wrapToolResult({ success: false, error: `Collection "${params.repo}" not found` });
+                        return wrapToolResult({ success: false, error: `Folder "${params.repo}" not found` });
                     }
                     let backlinks = workspaceManager.getBacklinks(params.repo, params.entityType, params.entityId);
-                    // Filter cross-collection results to accessible repos
+                    // Filter cross-folder results to accessible repos
                     const allowed = getAccessibleRepoNames(workspaceManager, getUser, authSvc);
                     if (allowed) {
                         backlinks = backlinks.filter(r => allowed.has(r.repoName));
@@ -644,16 +812,16 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
         {
             name: 'validate_wikilinks',
             label: 'Validate Wikilinks',
-            description: 'Validate all wikilinks in an entry (checks same collection and cross-collection)',
+            description: 'Validate all wikilinks in an entry (checks same folder and cross-folder)',
             parameters: T.Object({
-                repo: T.String({ description: 'Collection name' }),
+                repo: T.String({ description: 'Folder name' }),
                 entityType: T.String({ description: 'Entity type' }),
                 entityId: T.String({ description: 'Entity ID' }),
             }),
             execute: async (toolCallId, params) => {
                 try {
                     if (!canAccessRepo(params.repo, workspaceManager, getUser, authSvc)) {
-                        return wrapToolResult({ success: false, error: `Collection "${params.repo}" not found` });
+                        return wrapToolResult({ success: false, error: `Folder "${params.repo}" not found` });
                     }
                     const validation = workspaceManager.validateWikilinks(params.repo, params.entityType, params.entityId);
                     return wrapToolResult({
@@ -688,7 +856,7 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
                     const summary = workspaceManager.getSummary();
                     const allowed = getAccessibleRepoNames(workspaceManager, getUser, authSvc);
                     if (allowed) {
-                        // Filter summary to accessible collections only
+                        // Filter summary to accessible folders only
                         const filteredByRepo = {};
                         let filteredTotal = 0;
                         for (const [repo, count] of Object.entries(summary.entitiesByRepo)) {
@@ -700,19 +868,19 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
                         return wrapToolResult({
                             success: true,
                             summary: {
-                                totalCollections: allowed.size,
+                                totalFolders: allowed.size,
                                 totalEntities: filteredTotal,
-                                entitiesByCollection: filteredByRepo,
+                                entitiesByFolder: filteredByRepo,
                             },
                         });
                     }
                     return wrapToolResult({
                         success: true,
                         summary: {
-                            totalCollections: summary.totalRepos,
+                            totalFolders: summary.totalRepos,
                             totalEntities: summary.totalEntities,
                             entitiesByType: summary.entitiesByType,
-                            entitiesByCollection: summary.entitiesByRepo,
+                            entitiesByFolder: summary.entitiesByRepo,
                         },
                     });
                 }
@@ -724,11 +892,11 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
                 }
             },
         },
-        // List collections
+        // List folders
         {
             name: 'list_repos',
-            label: 'List Collections',
-            description: 'List all collections in the workspace',
+            label: 'List Folders',
+            description: 'List all folders in the workspace',
             parameters: T.Object({}),
             execute: async (toolCallId, params) => {
                 try {
@@ -740,12 +908,12 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
                     return wrapToolResult({
                         success: true,
                         count: repos.length,
-                        collections: repos.map(r => ({
+                        folders: repos.map(r => ({
                             name: r.name,
                             type: r.type,
                             description: r.description,
                             path: r.path,
-                            private: r.private || false,
+                            personal: r.personal || false,
                         })),
                     });
                 }
@@ -757,40 +925,35 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
                 }
             },
         },
-        // Create a new collection
+        // Create a new folder
         {
-            name: 'create_collection',
-            label: 'Create Collection',
-            description: 'Create a new collection in the workspace. A collection is a git-backed container for entries. Private collections are only visible to the creating user.',
+            name: 'create_folder',
+            label: 'Create Folder',
+            description: 'Create a new shared folder in the workspace. Folders are git-backed containers for entries. New folders are shared with teammates who have access; the creator is granted admin. Every user already has a personal "My Entries" folder auto-provisioned — do not use this tool to create another one.',
             parameters: T.Object({
-                name: T.String({ description: 'Collection name in kebab-case (e.g., "client-projects")' }),
-                description: T.Optional(T.String({ description: 'Short description of the collection' })),
-                private: T.Optional(T.Boolean({ description: 'If true, creates a private collection visible only to you' })),
+                name: T.String({ description: 'Folder name in kebab-case (e.g., "client-projects")' }),
+                description: T.Optional(T.String({ description: 'Short description of the folder' })),
             }),
             execute: async (toolCallId, params) => {
                 try {
                     const user = getUser();
-                    // Non-private collections require admin; private collections can be created by anyone
-                    if (!params.private && user && !isAdminOrOwner(user.role)) {
-                        return wrapToolResult({ success: false, error: 'Only admins can create collections' });
-                    }
                     if (!/^[a-z0-9][a-z0-9-]*$/.test(params.name)) {
-                        return wrapToolResult({ success: false, error: 'Collection name must be kebab-case (lowercase letters, numbers, hyphens)' });
+                        return wrapToolResult({ success: false, error: 'Folder name must be kebab-case (lowercase letters, numbers, hyphens)' });
                     }
                     const { Workspace } = await import('../../core/workspace.js');
                     const workspace = new Workspace(workspacePath);
                     const repo = await workspace.registerRepo({
                         name: params.name,
                         description: params.description,
-                        private: params.private,
-                        ...(params.private && user ? { owner_id: user.id } : {}),
+                        owner_id: user?.id,
                     });
-                    // Reload workspace manager to pick up the new collection
                     workspaceManager.reloadConfig();
-                    onMutation?.({ action: 'created', repo: repo.name, entityType: '_collection', entityId: repo.name });
+                    if (user && authSvc)
+                        authSvc.grantFolderAccess(user.id, repo.name, 'admin');
+                    onMutation?.({ action: 'created', repo: repo.name, entityType: '_folder', entityId: repo.name });
                     return wrapToolResult({
                         success: true,
-                        collection: { name: repo.name, path: repo.path, description: repo.description },
+                        folder: { name: repo.name, path: repo.path, description: repo.description },
                     });
                 }
                 catch (error) {
@@ -798,81 +961,6 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
                 }
             },
         },
-        // Query dataset rows
-        {
-            name: 'query_dataset',
-            label: 'Query Dataset',
-            description: 'Query rows from a dataset entity with optional filtering',
-            parameters: T.Object({
-                repo: T.String({ description: 'Collection name' }),
-                entityId: T.String({ description: 'Dataset entity ID' }),
-                filter: T.Optional(T.Object({}, { description: 'Filter conditions (column: value or { gte, lte, contains })', additionalProperties: true })),
-                limit: T.Optional(T.Number({ description: 'Max rows to return' })),
-            }),
-            execute: async (toolCallId, params) => {
-                try {
-                    if (!canAccessRepo(params.repo, workspaceManager, getUser, authSvc)) {
-                        return wrapToolResult({ success: false, error: `Collection "${params.repo}" not found` });
-                    }
-                    const graph = workspaceManager.getGraph(params.repo);
-                    const entity = graph.get('dataset', params.entityId);
-                    const schema = entity.data.schema;
-                    let rows = graph.getDatasetRows(params.entityId, params.filter);
-                    const total = rows.length;
-                    if (params.limit && params.limit > 0) {
-                        rows = rows.slice(0, params.limit);
-                    }
-                    return wrapToolResult({
-                        success: true,
-                        rows,
-                        total,
-                        schema,
-                    });
-                }
-                catch (error) {
-                    return wrapToolResult({
-                        success: false,
-                        error: error instanceof Error ? error.message : 'Unknown error',
-                    });
-                }
-            },
-        },
-        // Append rows to dataset
-        {
-            name: 'append_rows',
-            label: 'Append Rows',
-            description: 'Append rows to a dataset entity',
-            parameters: T.Object({
-                repo: T.String({ description: 'Collection name' }),
-                entityId: T.String({ description: 'Dataset entity ID' }),
-                rows: T.Array(T.Object({}, { additionalProperties: true }), { description: 'Rows to append' }),
-                commitMessage: T.Optional(T.String({ description: 'Custom commit message' })),
-            }),
-            execute: async (toolCallId, params) => {
-                try {
-                    if (!canAccessRepo(params.repo, workspaceManager, getUser, authSvc)) {
-                        return wrapToolResult({ success: false, error: `Collection "${params.repo}" not found` });
-                    }
-                    const graph = workspaceManager.getGraph(params.repo);
-                    // Get current row count before appending
-                    const beforeRows = graph.getDatasetRows(params.entityId);
-                    await graph.appendDatasetRows(params.entityId, params.rows, params.commitMessage);
-                    const afterRows = graph.getDatasetRows(params.entityId);
-                    return wrapToolResult({
-                        success: true,
-                        rowsAdded: afterRows.length - beforeRows.length,
-                        totalRows: afterRows.length,
-                        message: `Appended ${afterRows.length - beforeRows.length} row(s) to dataset: ${params.entityId}`,
-                    });
-                }
-                catch (error) {
-                    return wrapToolResult({
-                        success: false,
-                        error: error instanceof Error ? error.message : 'Unknown error',
-                    });
-                }
-            },
-        },
         // Get entity schema
         {
             name: 'get_entity_schema',
@@ -919,15 +1007,15 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
         {
             name: 'lint_entities',
             label: 'Lint Entries',
-            description: 'Check for missing recommended fields across entries. Returns incomplete entries with their missing fields. Use to discover entries that need enrichment. Optionally filter by collection or entry type.',
+            description: 'Check for missing recommended fields across entries. Returns incomplete entries with their missing fields. Use to discover entries that need enrichment. Optionally filter by folder or entry type.',
             parameters: T.Object({
-                repo: T.Optional(T.String({ description: 'Optional: limit to specific collection' })),
+                repo: T.Optional(T.String({ description: 'Optional: limit to specific folder' })),
                 entityType: T.Optional(T.String({ description: 'Optional: limit to specific entity type (e.g. "project", "deal")' })),
             }),
             execute: async (toolCallId, params) => {
                 try {
                     if (params.repo && !canAccessRepo(params.repo, workspaceManager, getUser, authSvc)) {
-                        return wrapToolResult({ success: false, error: `Collection "${params.repo}" not found` });
+                        return wrapToolResult({ success: false, error: `Folder "${params.repo}" not found` });
                     }
                     let issues = await lintWorkspace(workspaceManager, {
                         repo: params.repo,
@@ -977,11 +1065,11 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
             parameters: T.Object({
                 entityTypes: T.Optional(T.Array(T.String(), { description: 'Entity types to check (e.g. ["person", "client"])' })),
                 minAgeDays: T.Optional(T.Number({ description: 'Only flag entities older than N days' })),
-                repos: T.Optional(T.Array(T.String(), { description: 'Collection names to scan (default: all)' })),
+                repos: T.Optional(T.Array(T.String(), { description: 'Folder names to scan (default: all)' })),
             }),
             execute: async (toolCallId, params) => {
                 try {
-                    // Scope to accessible collections
+                    // Scope to accessible folders
                     const allowed = getAccessibleRepoNames(workspaceManager, getUser, authSvc);
                     let repos = params.repos;
                     if (allowed) {
@@ -1032,98 +1120,6 @@ export function createGraphTools(workspaceManager, gitUser, workspacePath, onHig
                 });
             },
         },
-        // ── View Management Tools ──
-        {
-            name: 'list_views',
-            label: 'List Views',
-            description: 'List the current user\'s saved views.',
-            parameters: T.Object({}),
-            execute: async () => {
-                if (!authSvc)
-                    return wrapToolResult({ success: false, error: 'Auth service not available' });
-                const userId = getUser()?.id ?? 0;
-                const views = authSvc.getUserViews(userId);
-                return wrapToolResult({ views });
-            },
-        },
-        {
-            name: 'create_view',
-            label: 'Create View',
-            description: 'Create a new saved view for the current user. Views appear as tabs in the toolbar.',
-            parameters: T.Object({
-                name: T.String({ description: 'View name (e.g. "My Tasks", "Open Projects")' }),
-                selectedType: T.Optional(T.String({ description: 'Entity type filter (e.g. "task", "project"). Omit for all types.' })),
-                groupBy: T.Optional(T.String({ description: 'Column key to group by (e.g. "status", "priority")' })),
-            }),
-            execute: async (_toolCallId, params) => {
-                if (!authSvc)
-                    return wrapToolResult({ success: false, error: 'Auth service not available' });
-                const userId = getUser()?.id ?? 0;
-                const config = {
-                    selectedType: params.selectedType ?? null,
-                    groupBy: params.groupBy ?? null,
-                    sortKey: 'name',
-                    sortAsc: true,
-                    filters: { text: {}, enum: {}, date: {} },
-                };
-                const view = authSvc.createUserView(userId, params.name, 'list', config);
-                return wrapToolResult({
-                    success: true,
-                    view: { id: view.id, name: view.name, viewType: view.viewType, config: view.config },
-                    message: `Created view "${params.name}". It will appear as a tab in the toolbar.`,
-                });
-            },
-        },
-        {
-            name: 'update_view',
-            label: 'Update View',
-            description: 'Update an existing saved view\'s name or configuration.',
-            parameters: T.Object({
-                id: T.Number({ description: 'View ID' }),
-                name: T.Optional(T.String({ description: 'New view name' })),
-                selectedType: T.Optional(T.String({ description: 'Entity type filter (use "all" to clear)' })),
-                groupBy: T.Optional(T.String({ description: 'Column key to group by (use "none" to clear)' })),
-            }),
-            execute: async (_toolCallId, params) => {
-                if (!authSvc)
-                    return wrapToolResult({ success: false, error: 'Auth service not available' });
-                const userId = getUser()?.id ?? 0;
-                const existing = authSvc.getUserView(params.id, userId);
-                if (!existing)
-                    return wrapToolResult({ success: false, error: `View ${params.id} not found` });
-                const fields = {};
-                if (params.name)
-                    fields.name = params.name;
-                if (params.selectedType !== undefined || params.groupBy !== undefined) {
-                    const config = { ...existing.config };
-                    if (params.selectedType !== undefined)
-                        config.selectedType = params.selectedType === 'all' ? null : params.selectedType;
-                    if (params.groupBy !== undefined)
-                        config.groupBy = params.groupBy === 'none' ? null : params.groupBy;
-                    fields.config = config;
-                }
-                authSvc.updateUserView(params.id, userId, fields);
-                return wrapToolResult({ success: true, message: `Updated view "${existing.name}".` });
-            },
-        },
-        {
-            name: 'delete_view',
-            label: 'Delete View',
-            description: 'Delete a saved view.',
-            parameters: T.Object({
-                id: T.Number({ description: 'View ID to delete' }),
-            }),
-            execute: async (_toolCallId, params) => {
-                if (!authSvc)
-                    return wrapToolResult({ success: false, error: 'Auth service not available' });
-                const userId = getUser()?.id ?? 0;
-                const existing = authSvc.getUserView(params.id, userId);
-                if (!existing)
-                    return wrapToolResult({ success: false, error: `View ${params.id} not found` });
-                authSvc.deleteUserView(params.id, userId);
-                return wrapToolResult({ success: true, message: `Deleted view "${existing.name}".` });
-            },
-        },
         // Mark onboarding complete
         {
             name: 'mark_onboarded',