studiograph 1.3.48-next.248 → 1.3.48-next.249

package/dist/mcp/tools.js

@@ -16,7 +16,10 @@
  */
 import { z } from 'zod';
 import { ENTITY_SCHEMAS } from '../core/validation.js';
-import { getAccessibleRepos, hasRepoAccess, canWriteRepo, getAccessibleEntityIds, filterWikilinks, } from '../services/access-control.js';
+import { isWorkspaceOwner } from '../services/auth-service.js';
+import { getAccessibleRepos, hasRepoAccess, canWriteRepo, isFolderAdminOrOwner, getAccessibleEntityIds, filterWikilinks, } from '../services/access-control.js';
+import { assetDeleteDenial } from '../services/asset-delete-authz.js';
+import { isArchivedRepo } from '../core/types.js';
 import { createSharedFolder, FolderCreationError } from '../services/folder-creation.js';
 import { validateFolderPath } from '../core/folder-paths.js';
 import { existsSync } from 'fs';
@@ -25,8 +28,8 @@ import { isCuratedEntityType } from '../core/entity-types-catalog.js';
 import { describeZodObject } from '../core/schema-registry.js';
 import { getAgentAllowedEntityTypes } from '../agent/prompts/entity-types-section.js';
 import * as commentVirtualEntity from '../services/comment-virtual-entity.js';
-import { buildActor, prepareCreatePayload, prepareUpdatePayload, diagnosedUpdate, DroppedAssetError, assertEntityRefs, applyPatchEntity, bodyRevisionHash, } from '../services/entity-mutations.js';
-import { StaleBaseRevisionError } from '../core/graph.js';
+import { buildActor, prepareCreatePayload, prepareUpdatePayload, diagnosedUpdate, DroppedAssetError, assertEntityRefs, applyPatchEntity, } from '../services/entity-mutations.js';
+import { ArtifactStore, ArtifactWriteError } from '../services/artifact-store.js';
 import { hashArtifactBody } from '../agent/tools/artifact-tools.js';
 import { BridgeError, validateUserHandleInPayload, assertCanChangeUserHandle } from '../services/user-person-bridge.js';
 import { extractAssetEmbeds, stripFrontmatter, assetEmbed } from '../core/embeds.js';
@@ -153,48 +156,26 @@ const DEFAULT_FOLDER_BY_TYPE = {
 function relPathOf(absPath, repoRoot) {
     return absPath.startsWith(repoRoot + '/') ? absPath.slice(repoRoot.length + 1) : absPath;
 }
-function slugifyArtifactId(source) {
-    const slug = (source || 'artifact')
-        .normalize('NFKD')
-        .replace(/[\u0300-\u036f]/g, '')
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 80);
-    return slug || 'artifact';
-}
-/** Whether a bundle's entrypoint document is empty/whitespace (a blank canvas
- *  stub, or a truncated tool-input stream). Mirrors the in-app rule in
- *  chat.ts's persistArtifactFromChat — Phase 4's ArtifactStore unifies both. */
-function bundleEntrypointBlank(bundle) {
-    const entry = bundle.files[bundle.entrypoint];
-    return typeof entry !== 'string' || entry.trim().length === 0;
-}
-/** Whether a stored artifact body is a blank stub (valid bundle whose
- *  entrypoint has no content). Parse failures count as NON-blank — never treat
- *  unknown content as safely overwritable. */
-function artifactBodyIsBlank(body) {
-    try {
-        const validation = validateArtifactBundle(JSON.parse(body));
-        if (!validation.ok || !validation.bundle)
-            return false;
-        return bundleEntrypointBlank(validation.bundle);
-    }
-    catch {
-        return false;
+/**
+ * Robustly resolve an entity from a search/list result so any hit re-opens
+ * without the caller guessing the physical type: explicit `path` wins; else try
+ * the supplied `entity_type`; on a miss (wrong/legacy type — e.g. an `event`
+ * whose `type` field is "meeting") fall back to id-only resolution. Shared by
+ * get_entity and delete_entity so the resolution can't drift between read and
+ * delete. Throws when nothing resolves (caller wraps via fail()).
+ */
+function resolveEntityRef(graph, ref) {
+    if (ref.path)
+        return graph.getByPath(ref.path);
+    if (ref.entity_type) {
+        try {
+            return graph.get(ref.entity_type, ref.entity_id);
+        }
+        catch {
+            return graph.getById(ref.entity_id);
+        }
     }
-}
-function artifactFrontmatter(bundle, options = {}) {
-    const data = {
-        name: bundle.title,
-        kind: bundle.kind,
-        viewport_width: bundle.viewport.width,
-        viewport_height: bundle.viewport.height,
-        viewport_mode: bundle.viewport.mode,
-    };
-    if (options.includeStatus)
-        data.status = 'draft';
-    return data;
+    return graph.getById(ref.entity_id);
 }
 function parseArtifactBundleFromBody(content, label) {
     let rawBundle;
@@ -305,7 +286,10 @@ export function registerTools(server, wm, authService, ctx) {
     const mcpAllowedCreateTypes = getAgentAllowedEntityTypes(customWorkspaceTypes);
     const mcpAllowedSet = new Set(mcpAllowedCreateTypes);
     // ── list_repos ────────────────────────────────────────────────────────────
-    reg('list_repos', { description: 'List folders in the Studiograph workspace that you have access to' }, async () => ok(getAccessibleRepos(user, wm, authService)));
+    reg('list_repos', { description: 'List folders in the Studiograph workspace that you have access to' }, 
+    // Archived folders are hidden from the inventory (parity with the sidebar +
+    // agent folder list); they stay reachable by name for unarchive.
+    async () => ok(getAccessibleRepos(user, wm, authService).filter(r => !isArchivedRepo(r))));
     // ── create_repo ───────────────────────────────────────────────────────────
     //
     // Creates a new shared folder in the workspace and grants the
@@ -419,24 +403,8 @@ export function registerTools(server, wm, authService, ctx) {
             }
             const graph = wm.getGraph(repo);
             // Resolve robustly so any search/list result re-opens without the
-            // caller guessing the physical type: explicit path wins; else try the
-            // supplied type; on a miss (wrong/legacy type — e.g. an `event` whose
-            // `type` field is "meeting") fall back to id-only resolution.
-            let entity;
-            if (path) {
-                entity = graph.getByPath(path);
-            }
-            else if (entity_type) {
-                try {
-                    entity = graph.get(entity_type, entity_id);
-                }
-                catch {
-                    entity = graph.getById(entity_id);
-                }
-            }
-            else {
-                entity = graph.getById(entity_id);
-            }
+            // caller guessing the physical type (shared with delete_entity).
+            const entity = resolveEntityRef(graph, { entity_type, entity_id, path });
             // Prefer the live editor body when a seeded Y.Doc is open: graph reads
             // disk, which lags the editor by the autosave debounce, so a user's
             // freshly-placed image/asset embed may not be on disk yet. Use the
@@ -828,117 +796,61 @@ export function registerTools(server, wm, authService, ctx) {
         if (base_hash && !entity_id) {
             return fail(new Error('base_hash implies updating an existing artifact, but entity_id is missing — pass the entity_id you read with get_entity, or omit base_hash to create a new artifact.'));
         }
-        const validation = validateArtifactBundle(rawBundle);
-        if (!validation.ok || !validation.bundle) {
-            return fail(new Error(`Invalid artifact bundle: ${validation.errors.join('; ')}`));
-        }
-        const bundle = validation.bundle;
         const graph = wm.getGraph(repo);
         const actor = buildActor(user);
-        const body = `${JSON.stringify(bundle, null, 2)}\n`;
-        const createData = artifactFrontmatter(bundle, { includeStatus: true });
-        const updateData = artifactFrontmatter(bundle);
         return withAgentActivity(repo, entity_id ? 'editing' : 'creating', async () => {
             try {
-                const preferredId = entity_id || slugifyArtifactId(bundle.artifactId || bundle.title);
-                let resolvedId = preferredId;
-                let existing = null;
-                if (entity_id) {
-                    try {
-                        existing = graph.get('artifact', preferredId);
-                    }
-                    catch {
-                        existing = null;
-                    }
-                }
-                else {
-                    let suffix = 2;
-                    while (suffix < 1000) {
-                        try {
-                            graph.get('artifact', resolvedId);
-                            resolvedId = `${preferredId}-${suffix++}`;
-                        }
-                        catch {
-                            break;
-                        }
-                    }
-                }
-                // The caller asserted "this is an edit of the version I read"
-                // (base_hash) but the target no longer resolves — deleted, moved, or
-                // renamed since the read. Recreating it from a possibly stale copy
-                // would silently resurrect deleted content; fail loudly instead.
-                if (!existing && entity_id && base_hash) {
-                    return fail(new Error(`Artifact "${entity_id}" no longer exists in "${repo}" (deleted or moved since you read it). Re-check with get_entity or search_entities before retrying — refusing to recreate it from a possibly stale copy.`));
-                }
-                if (existing) {
-                    const liveBody = graph.getLiveBody('artifact', resolvedId) ?? existing.document.content;
-                    const targetIsBlank = artifactBodyIsBlank(liveBody);
-                    // Agent-protocol staleness rules (mirror the in-app create_artifact
-                    // baseHash rules; Phase 4's ArtifactStore unifies both surfaces):
-                    // 1. Updating an artifact that already has content REQUIRES the
-                    //    artifact_hash from get_entity — an edit not derived from a
-                    //    read would silently drop someone else's changes.
-                    if (!targetIsBlank && !base_hash) {
-                        return fail(new Error('This artifact already has content — call get_entity first and pass its artifact_hash as base_hash, so a concurrent change is detected instead of silently overwritten. (Intentionally clearing it requires base_hash plus replace: true.)'));
-                    }
-                    // 2. The hash must match the LIVE body (the same source get_entity
-                    //    hashed) — otherwise the edit was derived from an outdated read.
-                    if (base_hash && base_hash !== hashArtifactBody(liveBody)) {
-                        return fail(new Error('Artifact changed since you read it (base_hash mismatch). Call get_entity again, re-apply your change to the current source, then retry with the new artifact_hash.'));
-                    }
-                    // 3. A blank bundle over a populated artifact is almost always a
-                    //    truncated/failed generation, not an intentional clear.
-                    if (!targetIsBlank && bundleEntrypointBlank(bundle) && !replace) {
-                        return fail(new Error('The new bundle is blank but this artifact has content. Pass replace: true only if you intend to clear it.'));
-                    }
-                    // Write-time optimistic concurrency (mirrors the in-app rule): the
-                    // coordinator verifies the DISK body still matches what we read
-                    // here, so two racing whole-bundle writes can't both land — the
-                    // loser gets a conflict instead of silently clobbering.
-                    const options = prepareUpdatePayload({
-                        entityType: 'artifact',
-                        entityId: resolvedId,
-                        data: updateData,
-                        content: body,
-                        baseRevision: bodyRevisionHash(existing.document.content),
-                    }, actor);
-                    const { entity, frontmatter_changed, content_changed, noop, broadcast } = await diagnosedUpdate(graph, options, { data: updateData, content: body });
-                    emitEntityChange('updated', repo, entity.entityType, entity.id);
-                    return ok({
-                        success: true,
-                        action: 'updated',
-                        id: entity.id,
-                        type: entity.entityType,
-                        repo,
-                        path: relPathOf(entity.path, graph.getRepoPath()),
-                        commit: graph.getGitService()?.getHeadCommit() ?? null,
-                        frontmatter_changed,
-                        content_changed,
-                        noop,
-                        broadcast,
-                    });
-                }
-                const entity = await graph.create(prepareCreatePayload({
-                    entityType: 'artifact',
-                    entityId: resolvedId,
-                    data: createData,
-                    content: body,
+                // The ArtifactStore owns the whole write lifecycle (validate, identity,
+                // blank-stub adoption, content-equality idempotency, the OCC rules, the
+                // diagnosed write). The MCP surface stays thin: access (above), the
+                // response envelope, and the change broadcast.
+                const result = await new ArtifactStore(graph).write({
+                    bundle: rawBundle,
+                    actor,
+                    // MCP entity_id is create-or-update-AT-id: a caller picks the id and
+                    // expects it created if absent (unless base_hash asserts an edit).
+                    target: entity_id ? { entityId: entity_id, createIfMissing: true } : null,
+                    baseHash: base_hash,
+                    replace,
                     folderPath: folder_path || undefined,
-                }, actor));
-                emitEntityChange('created', repo, entity.entityType, entity.id);
+                });
+                const entity = result.entity;
+                // Broadcast only when something actually changed. `noop` covers BOTH the
+                // content-equality short-circuit (no write) AND a diagnosedUpdate that
+                // ran but changed nothing — neither should emit a phantom change. Matches
+                // the chat surface's `!location.noop` gate.
+                if (!result.noop)
+                    emitEntityChange(result.action, repo, entity.entityType, entity.id);
                 return ok({
                     success: true,
-                    action: 'created',
-                    id: entity.id,
+                    action: result.action,
+                    id: result.entityId,
                     type: entity.entityType,
                     repo,
                     path: relPathOf(entity.path, graph.getRepoPath()),
                     commit: graph.getGitService()?.getHeadCommit() ?? null,
+                    noop: result.noop,
+                    ...(result.diagnostics ? {
+                        frontmatter_changed: result.diagnostics.frontmatterChanged,
+                        content_changed: result.diagnostics.contentChanged,
+                        broadcast: result.diagnostics.broadcast,
+                    } : {}),
                 });
             }
             catch (err) {
-                if (err instanceof StaleBaseRevisionError) {
-                    return fail(new Error('Another write landed on this artifact while yours was in flight. Call get_entity to re-read the current source, re-apply your change, then retry passing its artifact_hash as base_hash.'));
+                if (err instanceof ArtifactWriteError) {
+                    switch (err.code) {
+                        case 'needs-base-hash':
+                            return fail(new Error('This artifact already has content — call get_entity first and pass its artifact_hash as base_hash, so a concurrent change is detected instead of silently overwritten. (Intentionally clearing it requires base_hash plus replace: true.)'));
+                        case 'stale':
+                            return fail(new Error('Artifact changed since you read it (base_hash mismatch). Call get_entity again, re-apply your change to the current source, then retry with the new artifact_hash.'));
+                        case 'blank-overwrite':
+                            return fail(new Error('The new bundle is blank but this artifact has content. Pass replace: true only if you intend to clear it.'));
+                        case 'deleted':
+                            return fail(new Error(`Artifact "${entity_id}" no longer exists in "${repo}" (deleted or moved since you read it). Re-check with get_entity or search_entities before retrying — refusing to recreate it from a possibly stale copy.`));
+                        default:
+                            return fail(new Error(err.message));
+                    }
                 }
                 return fail(err);
             }
@@ -1681,6 +1593,200 @@ export function registerTools(server, wm, authService, ctx) {
             }
         });
     });
+    // ── delete_entity ─────────────────────────────────────────────────────────
+    //
+    // Delete an entry. Git-committed and recoverable from history
+    // (list_recent_deletions / restore_file). Embedded assets are KEPT — assets
+    // are folder-owned library citizens that entries only reference
+    // (assets-referenced-not-owned P1), so deleting an entry never destroys
+    // binaries. In the workspace_wide Assets store the per-asset uploader/owner
+    // delete gate still applies (D2). Robust resolution mirrors get_entity.
+    const deleteEntitySchema = z.object({
+        repo: z.string().describe('Folder name'),
+        entity_type: z.string().optional().describe('Canonical entity type (as returned by search/list `type`). Optional: when omitted or wrong, the entry is resolved by id.'),
+        entity_id: z.string().optional().describe('Entity ID (kebab-case slug). Provide entity_id or path.'),
+        path: z.string().optional().describe('Repo-relative file path from a search/list result. When given, resolves directly and ignores entity_type.'),
+    });
+    reg('delete_entity', {
+        description: 'Delete an entry. Git-committed and recoverable from history via list_recent_deletions / restore_file. ' +
+            'Embedded assets are NOT deleted — assets are folder-owned and only referenced by entries. ' +
+            'Robust resolution: pass type+id or path exactly as returned by search_entities/list_entities; a wrong or omitted type still resolves by id. ' +
+            'Destructive — only call on explicit user request.',
+        inputSchema: deleteEntitySchema,
+    }, async (args) => {
+        const { repo, entity_type, entity_id, path } = deleteEntitySchema.parse(args);
+        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}"`));
+        }
+        if (!entity_id && !path)
+            return fail(new Error('delete_entity requires entity_id or path'));
+        const actor = buildActor(user);
+        return withAgentActivity(repo, 'deleting', async () => {
+            try {
+                const graph = wm.getGraph(repo);
+                // Resolve robustly (shared with get_entity): explicit path wins; else
+                // try the supplied type; on a miss fall back to id-only resolution.
+                const entity = resolveEntityRef(graph, { entity_type, entity_id, path });
+                const resolvedType = entity.entityType;
+                const resolvedId = entity.id;
+                // Workspace-Assets store gate (D2): in a workspace_wide folder only the
+                // uploader or a workspace owner may delete — folder-write is not enough.
+                const denial = assetDeleteDenial(wm.getAssetIndex(), wm.getRepoConfig(repo), user, repo, resolvedType, resolvedId);
+                if (denial)
+                    return fail(new Error(denial));
+                // Soft bridge-awareness: deleting a person linked to an auth account
+                // orphans that user. Don't block — surface a warning so the agent can
+                // tell the user (the Profile panel catches the orphan after).
+                let bridgeWarning;
+                if (resolvedType === 'person') {
+                    const handle = entity.data?.user_handle;
+                    if (typeof handle === 'string' && handle.length > 0) {
+                        bridgeWarning = `This record was linked to the "${handle}" account. Deleting it unlinks that user — their "My Tasks", @mentions, and assignments stop resolving until they link a new record.`;
+                    }
+                }
+                await graph.delete(resolvedType, resolvedId, undefined, actor);
+                emitEntityChange('deleted', repo, resolvedType, resolvedId);
+                return ok({
+                    success: true,
+                    repo,
+                    type: resolvedType,
+                    id: resolvedId,
+                    ...(bridgeWarning ? { warning: bridgeWarning } : {}),
+                });
+            }
+            catch (err) {
+                return fail(err);
+            }
+        });
+    });
+    // ── delete_subfolder ──────────────────────────────────────────────────────
+    //
+    // Delete a subfolder inside a folder/collection. Empty → delete; non-empty +
+    // recursive:false → refuse with a blast-radius payload; recursive:true →
+    // delete the folder + its entries. Deleted entries are git-recoverable; their
+    // referenced assets are kept (folder-owned). Distinct from archive_repo, which
+    // reversibly hides an entire top-level folder.
+    const deleteSubfolderSchema = z.object({
+        repo: z.string().describe('Folder name (collection) containing the subfolder'),
+        path: z.string().describe('Repo-relative POSIX path of the subfolder to delete (e.g. "Clients/Acme")'),
+        recursive: z.boolean().optional().describe('Delete the folder AND every entry/subfolder inside it. Defaults to false: a non-empty folder is REFUSED with a blast-radius payload (entriesDeleted, subfoldersDeleted) so you can confirm with the user first. NEVER pass true on the first attempt.'),
+    });
+    reg('delete_subfolder', {
+        description: 'Delete a subfolder inside a folder. Empty subfolders delete immediately. A non-empty subfolder is REFUSED unless recursive:true — the refusal returns the blast radius (entries + subfolders that would be removed) so you can confirm with the user before re-invoking. Deleted ENTRIES are git-recoverable; their referenced assets are kept. To remove a whole top-level folder, prefer archive_repo (reversible) — permanent folder deletion is web/human-only.',
+        inputSchema: deleteSubfolderSchema,
+    }, async (args) => {
+        const { repo, path, recursive } = deleteSubfolderSchema.parse(args);
+        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}"`));
+        }
+        // Workspace-Assets store gate (mirror the web route): a recursive delete in
+        // a workspace_wide store destroys every asset under the folder, bypassing
+        // the per-asset uploader/owner rule — restrict it to a workspace owner.
+        if (recursive === true && wm.getRepoConfig(repo)?.workspace_wide && !isWorkspaceOwner(user.role)) {
+            return fail(new Error('Only a workspace owner can recursively delete folders in the shared Assets store.'));
+        }
+        const actor = buildActor(user);
+        return withAgentActivity(repo, 'deleting', async () => {
+            try {
+                // Validate + normalize the path BEFORE the destructive call (don't
+                // rely on deleteFolder's internal check as the only guard against
+                // traversal/root/malformed paths). validateFolderPath throws
+                // InvalidFolderPathError for traversal and returns '' for the repo
+                // root, which deleteFolder also rejects. The throw lands in the catch
+                // below and surfaces as a fail() result. Pass the normalized path.
+                const normPath = validateFolderPath(path);
+                const graph = wm.getGraph(repo);
+                const result = await graph.deleteFolder(normPath, { recursive: recursive === true, user: actor });
+                emitEntityChange('deleted', repo, '_folder', normPath);
+                return ok({
+                    success: true,
+                    repo,
+                    path: normPath,
+                    entriesDeleted: result.entriesDeleted,
+                    subfoldersDeleted: result.subfoldersDeleted,
+                });
+            }
+            catch (err) {
+                // Surface the blast radius so the caller can confirm before retrying
+                // recursively (structured, like the web route's 409 body).
+                if (err?.code === 'FOLDER_NOT_EMPTY' && err.blastRadius) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    error: err.message,
+                                    code: 'FOLDER_NOT_EMPTY',
+                                    blast_radius: err.blastRadius,
+                                }, null, 2),
+                            }],
+                        isError: true,
+                    };
+                }
+                return fail(err);
+            }
+        });
+    });
+    // ── archive_repo / unarchive_repo ─────────────────────────────────────────
+    //
+    // Archive is a reversible, lossless, identity-preserving repo-level hide (a
+    // flag on the config, NOT a rename). An archived folder drops out of the
+    // sidebar, search, graph, and the agent inventory but keeps its entries,
+    // wikilinks, and assets. Agents/MCP may archive but may NEVER permanently
+    // delete a repo — permanent deletion stays a deliberate human action in the
+    // web UI. Folder admin or workspace owner only.
+    const archiveRepoSchema = z.object({
+        repo: z.string().describe('Folder name to archive'),
+    });
+    reg('archive_repo', {
+        description: 'Archive a folder — a reversible, lossless hide. The folder drops out of the sidebar, search, graph, and the agent folder inventory, but nothing is deleted (entries, wikilinks, and assets are preserved) and it can be restored with unarchive_repo. Use this instead of deleting a folder: permanent folder deletion is a human-only action in the web UI and is never available to agents. Requires folder admin or workspace owner.',
+        inputSchema: archiveRepoSchema,
+    }, async (args) => {
+        const { repo } = archiveRepoSchema.parse(args);
+        if (!hasRepoAccess(user, repo, wm, authService))
+            return notFound(repo);
+        if (!isFolderAdminOrOwner(user, repo, wm, authService)) {
+            return fail(new Error(`Archiving folder "${repo}" requires folder admin or workspace owner.`));
+        }
+        try {
+            const updated = await wm.setRepoArchived(repo, true, user.handle);
+            return ok({
+                success: true,
+                repo,
+                archived_at: updated.archived_at ?? null,
+                message: `Archived folder "${repo}". It's hidden from the workspace but fully recoverable — call unarchive_repo to restore it.`,
+            });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    reg('unarchive_repo', {
+        description: 'Restore a previously archived folder so it reappears in the sidebar, search, graph, and the agent folder inventory. Requires folder admin or workspace owner.',
+        inputSchema: archiveRepoSchema,
+    }, async (args) => {
+        const { repo } = archiveRepoSchema.parse(args);
+        if (!hasRepoAccess(user, repo, wm, authService))
+            return notFound(repo);
+        if (!isFolderAdminOrOwner(user, repo, wm, authService)) {
+            return fail(new Error(`Unarchiving folder "${repo}" requires folder admin or workspace owner.`));
+        }
+        try {
+            const updated = await wm.setRepoArchived(repo, false, user.handle);
+            return ok({
+                success: true,
+                repo,
+                archived: isArchivedRepo(updated),
+                message: `Restored folder "${repo}".`,
+            });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
     // ── validate_wikilinks ────────────────────────────────────────────────────
     const validateWikilinksSchema = z.object({
         repo: z.string().describe('Folder name'),