@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/discovery/agent.js

@@ -1,15 +1,6 @@
 /**
  * Compile one `agent/` directory (and its subagents) into a {@link ResolvedAgent}.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { join } from "node:path";
 import { canonicalizeFileSystemToolName, FileSystemConfigError, resolveFileSystemTools, resolveRootHarnessAllowlist, } from "../../filesystem.js";
 import { DEFAULT_MODEL, } from "../../types.js";
@@ -26,305 +17,310 @@ import { loadSeedFiles } from "./seed-files.js";
 import { loadSkills } from "./skills.js";
 import { loadSubagent, loadSubagents } from "./subagent.js";
 import { appendBuiltinTools, loadTools } from "./tools.js";
-export function loadAgent(ctx, agentDir, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g;
-        var _h;
-        if (!options.isRoot) {
-            return {
-                agent: yield loadSubagent(ctx, agentDir, options.name),
-                projectSlots: {
-                    hooks: [],
-                    channels: [],
-                    schedules: [],
-                    reminders: [],
-                    artifacts: undefined,
-                },
-            };
-        }
-        const config = yield loadAgentConfig(ctx, agentDir, options.isRoot);
-        const name = (_h = config === null || config === void 0 ? void 0 : config.name) !== null && _h !== void 0 ? _h : options.name;
-        const authoredInstructions = yield loadInstructions(ctx, agentDir, config, options.isRoot);
-        const tools = yield loadTools(ctx, join(agentDir, "tools"));
-        const skills = yield loadSkills(ctx, join(agentDir, "skills"));
-        const connections = yield loadConnections(ctx, join(agentDir, "mcp-connections"));
-        const subagents = yield loadSubagents(ctx, join(agentDir, "subagents"));
-        const hostConnections = yield loadHostConnections(ctx, agentDir, connections);
-        const seedFiles = yield loadSeedFiles(ctx, agentDir);
-        const hooks = [];
-        const channels = [];
-        const schedules = [];
-        const reminders = [];
-        const instructionParts = [];
-        const contributions = {
-            tools,
-            skills,
-            connections,
-            hostConnections,
-            subagents,
-            hooks,
-            channels,
-            schedules,
-            reminders,
-            instructionParts,
-            seedFiles,
-            artifacts: undefined,
+export async function loadAgent(ctx, agentDir, options) {
+    if (!options.isRoot) {
+        return {
+            agent: await loadSubagent(ctx, agentDir, options.name),
+            projectSlots: {
+                hooks: [],
+                channels: [],
+                schedules: [],
+                reminders: [],
+                artifacts: undefined,
+            },
         };
-        const extensions = yield appendExtensions(ctx, join(agentDir, "extensions"), contributions);
-        const promptParts = [...instructionParts];
-        if (authoredInstructions !== undefined && authoredInstructions !== "") {
-            promptParts.unshift(authoredInstructions);
-        }
-        const prompt = promptParts.join("\n\n");
-        // Root agents without authored instructions stay undefined (diagnostic
-        // already recorded) unless an extension contributed a fragment.
-        const instructions = prompt === "" ? undefined : withIdentityPreamble(name, prompt);
-        const runtime = resolveRuntime(ctx, agentDir, config === null || config === void 0 ? void 0 : config.runtime);
-        // Keep authored `cloud` even when default runtime is local — per-session
-        // `send({ cloud })` merges it under cloudOverride for handoff sessions.
-        const cloud = config === null || config === void 0 ? void 0 : config.cloud;
-        const localWorkspaceDir = resolveAgentCwd(ctx, (_a = config === null || config === void 0 ? void 0 : config.local) === null || _a === void 0 ? void 0 : _a.workspaceDir);
-        const localCwd = yield resolveLocalCwd(ctx, (_b = config === null || config === void 0 ? void 0 : config.local) === null || _b === void 0 ? void 0 : _b.cwd, (_c = config === null || config === void 0 ? void 0 : config.local) === null || _c === void 0 ? void 0 : _c.workspaceDir);
-        const localSandbox = ((_d = config === null || config === void 0 ? void 0 : config.local) === null || _d === void 0 ? void 0 : _d.sandbox) === true;
-        // Built-in tool allowlist (top-level `tools`). `[]` is meaningful (no
-        // native built-in tools), so presence is keyed on the field, not on
-        // emptiness. "mcp" is always granted alongside a configured allowlist:
-        // it is transport, not capability — this kit's own server tools ride the
-        // SDK custom-tool MCP path, so omitting it silently breaks
-        // `agent/tools/`, and what MCP actually exposes stays controlled by the
-        // second layer (authored tools, mcp-connections, the harness cwd's
-        // ambient config).
-        const authoredAllowlist = config === null || config === void 0 ? void 0 : config.tools;
-        const root = config === null || config === void 0 ? void 0 : config.root;
-        const hasRoot = root !== undefined;
-        if (hasRoot) {
-            if (((_e = config === null || config === void 0 ? void 0 : config.local) === null || _e === void 0 ? void 0 : _e.cwd) !== undefined ||
-                ((_f = config === null || config === void 0 ? void 0 : config.local) === null || _f === void 0 ? void 0 : _f.workspaceDir) !== undefined ||
-                ((_g = config === null || config === void 0 ? void 0 : config.local) === null || _g === void 0 ? void 0 : _g.sandbox) === true) {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, join(agentDir, "agent.ts")),
-                    message: "`root` cannot be combined with `local.cwd`, `local.workspaceDir`, or `local.sandbox`. Those fields configure the host tree the override replaced.",
-                });
-            }
-            if (runtime === "cloud" || runtime === "grokbot") {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, join(agentDir, "agent.ts")),
-                    message: `\`root\` cannot be combined with runtime: "${runtime}".`,
-                });
-            }
-            if ((authoredAllowlist === null || authoredAllowlist === void 0 ? void 0 : authoredAllowlist.includes("shell")) === true ||
-                (authoredAllowlist === null || authoredAllowlist === void 0 ? void 0 : authoredAllowlist.includes("Shell")) === true) {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, join(agentDir, "agent.ts")),
-                    message: '`root` cannot be combined with `tools` containing `"shell"`. Shell is not a FileSystem method and must not bind the host shell onto a virtual tree.',
-                });
-            }
-        }
-        const reservedNames = new Set(synthesizedFileSystemToolNames({
-            hasRoot,
-            tools: authoredAllowlist,
-        }));
-        const clash = tools.find(tool => {
-            if (reservedNames.has(tool.name)) {
-                return true;
-            }
-            const canonical = canonicalizeFileSystemToolName(tool.name);
-            return canonical !== undefined && reservedNames.has(canonical);
-        });
-        if (clash !== undefined) {
-            ctx.diagnostics.push({
-                severity: "error",
-                path: displayPath(ctx, join(agentDir, "tools", `${clash.name}.ts`)),
-                message: `Tool name "${clash.name}" is reserved for the synthesized FileSystem tool.`,
-            });
-        }
-        let allowedTools = authoredAllowlist === undefined || authoredAllowlist.includes("mcp")
-            ? authoredAllowlist
-            : [...authoredAllowlist, "mcp"];
-        if (hasRoot) {
-            try {
-                if (typeof root !== "function") {
-                    resolveFileSystemTools({
-                        root,
-                        tools: authoredAllowlist,
-                    });
-                }
-                else {
-                    resolveRootHarnessAllowlist(authoredAllowlist);
-                }
-                allowedTools = authoredAllowlist;
-            }
-            catch (error) {
-                ctx.diagnostics.push({
-                    severity: "error",
-                    path: displayPath(ctx, join(agentDir, "agent.ts")),
-                    message: error instanceof FileSystemConfigError
-                        ? error.message
-                        : error instanceof Error
-                            ? error.message
-                            : String(error),
-                });
-            }
-        }
-        // The allowlist states runtime-agnostic intent, but only the local
-        // harness can enforce it (the Cursor SDK rejects tool restrictions on
-        // cloud agents, and the Grok Bot harness has its own fixed toolset) — a
-        // non-local agent that declares one must fail at serve start, never run
-        // unrestricted. (Hybrid per-send cloud sessions fail closed in the
-        // session engine.)
-        if (allowedTools !== undefined && runtime !== "local") {
+    }
+    const config = await loadAgentConfig(ctx, agentDir, options.isRoot);
+    const name = config?.name ?? options.name;
+    const authoredInstructions = await loadInstructions(ctx, agentDir, config, options.isRoot);
+    const tools = await loadTools(ctx, join(agentDir, "tools"));
+    const skills = await loadSkills(ctx, join(agentDir, "skills"));
+    const connections = await loadConnections(ctx, join(agentDir, "mcp-connections"));
+    const subagents = await loadSubagents(ctx, join(agentDir, "subagents"));
+    const hostConnections = await loadHostConnections(ctx, agentDir, connections);
+    const seedFiles = await loadSeedFiles(ctx, agentDir);
+    const hooks = [];
+    const channels = [];
+    const schedules = [];
+    const reminders = [];
+    const instructionParts = [];
+    const contributions = {
+        tools,
+        skills,
+        connections,
+        hostConnections,
+        subagents,
+        hooks,
+        channels,
+        schedules,
+        reminders,
+        instructionParts,
+        seedFiles,
+        artifacts: undefined,
+    };
+    const extensions = await appendExtensions(ctx, join(agentDir, "extensions"), contributions);
+    const promptParts = [...instructionParts];
+    if (authoredInstructions !== undefined && authoredInstructions !== "") {
+        promptParts.unshift(authoredInstructions);
+    }
+    const prompt = promptParts.join("\n\n");
+    // Root agents without authored instructions stay undefined (diagnostic
+    // already recorded) unless an extension contributed a fragment.
+    const instructions = prompt === "" ? undefined : withIdentityPreamble(name, prompt);
+    const runtime = resolveRuntime(ctx, agentDir, config?.runtime);
+    // Keep authored `cloud` even when default runtime is local — per-session
+    // `send({ cloud })` merges it under cloudOverride for handoff sessions.
+    const cloud = config?.cloud;
+    const localWorkspaceDir = resolveAgentCwd(ctx, config?.local?.workspaceDir);
+    const localCwd = await resolveLocalCwd(ctx, config?.local?.cwd, config?.local?.workspaceDir);
+    const localSandbox = config?.local?.sandbox === true;
+    // Built-in tool allowlist (top-level `tools`). `[]` is meaningful (no
+    // native built-in tools), so presence is keyed on the field, not on
+    // emptiness. "mcp" is always granted alongside a configured allowlist:
+    // it is transport, not capability — this kit's own server tools ride the
+    // SDK custom-tool MCP path, so omitting it silently breaks
+    // `agent/tools/`, and what MCP actually exposes stays controlled by the
+    // second layer (authored tools, mcp-connections, the harness cwd's
+    // ambient config).
+    const authoredAllowlist = config?.tools;
+    const root = config?.root;
+    const hasRoot = root !== undefined;
+    if (hasRoot) {
+        if (config?.local?.cwd !== undefined ||
+            config?.local?.workspaceDir !== undefined ||
+            config?.local?.sandbox === true) {
             ctx.diagnostics.push({
                 severity: "error",
                 path: displayPath(ctx, join(agentDir, "agent.ts")),
-                message: `tools cannot be enforced on runtime: "${runtime}". Remove \`tools\` or run the agent on the local runtime.`,
+                message: "`root` cannot be combined with `local.cwd`, `local.workspaceDir`, or `local.sandbox`. Those fields configure the host tree the override replaced.",
             });
         }
-        // Per-session connection features (defineConnection auth/advertiseTools)
-        // only run on local turns: advertised tools are in-process server tools,
-        // and per-session headers cannot reach a cloud VM's MCP config. A
-        // non-local agent that declares them must fail at serve start — never
-        // run without the connection's tools or identity. (Hybrid per-send
-        // cloud sessions fail closed in the session engine.)
-        const perSessionConnection = connections.find(connection => connection.advertiseTools === true || connection.auth !== undefined);
-        if (perSessionConnection !== undefined && runtime !== "local") {
+        if (runtime === "cloud" || runtime === "grokbot") {
             ctx.diagnostics.push({
                 severity: "error",
                 path: displayPath(ctx, join(agentDir, "agent.ts")),
-                message: `MCP connection "${perSessionConnection.name}" uses advertiseTools/auth, which only run on runtime: "local". Remove them or run the agent on the local runtime.`,
+                message: `\`root\` cannot be combined with runtime: "${runtime}".`,
             });
         }
-        // `execution: "agent"` tool scripts run through the shell tool. Shell is
-        // a real capability, so it is never injected — but an allowlist that
-        // strands authored scripts deserves a loud diagnostic, not silence.
-        if (allowedTools !== undefined &&
-            !allowedTools.includes("shell") &&
-            tools.some(tool => tool.execution === "agent")) {
+        if (authoredAllowlist?.includes("shell") === true ||
+            authoredAllowlist?.includes("Shell") === true) {
             ctx.diagnostics.push({
-                severity: "warning",
+                severity: "error",
                 path: displayPath(ctx, join(agentDir, "agent.ts")),
-                message: '`tools` omits "shell" but this agent has execution: "agent" tools, which run as shell scripts; the model will not be able to run them.',
+                message: '`root` cannot be combined with `tools` containing `"shell"`. Shell is not a FileSystem method and must not bind the host shell onto a virtual tree.',
             });
         }
-        if (localCwd !== undefined && localWorkspaceDir !== undefined) {
-            ctx.diagnostics.push({
-                severity: "warning",
-                path: displayPath(ctx, join(agentDir, "agent.ts")),
-                message: "local.workspaceDir pins every session to one directory, so local.cwd is unused. Drop one of them.",
-            });
+    }
+    const reservedNames = new Set(synthesizedFileSystemToolNames({
+        hasRoot,
+        tools: authoredAllowlist,
+    }));
+    const clash = tools.find(tool => {
+        if (reservedNames.has(tool.name)) {
+            return true;
         }
-        const local = localCwd === undefined && localWorkspaceDir === undefined && !localSandbox
-            ? undefined
-            : {
-                cwd: localCwd,
-                workspaceDir: localWorkspaceDir,
-                sandbox: localSandbox,
-            };
-        const hosting = resolveHosting(ctx, agentDir, config === null || config === void 0 ? void 0 : config.hosting, extensions);
-        const concurrency = resolveConcurrency(ctx, agentDir, config === null || config === void 0 ? void 0 : config.concurrency);
-        const architecture = resolveArchitecture(ctx, agentDir, config === null || config === void 0 ? void 0 : config.architecture);
-        const persistent = resolvePersistent(ctx, agentDir, config === null || config === void 0 ? void 0 : config.persistent, architecture);
-        const runtimeArchitectureError = runtimeArchitectureCompatibilityError({
-            runtime,
-            architecture,
+        const canonical = canonicalizeFileSystemToolName(tool.name);
+        return canonical !== undefined && reservedNames.has(canonical);
+    });
+    if (clash !== undefined) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, join(agentDir, "tools", `${clash.name}.ts`)),
+            message: `Tool name "${clash.name}" is reserved for the synthesized FileSystem tool.`,
         });
-        if (runtimeArchitectureError !== undefined) {
+    }
+    let allowedTools = authoredAllowlist === undefined || authoredAllowlist.includes("mcp")
+        ? authoredAllowlist
+        : [...authoredAllowlist, "mcp"];
+    if (hasRoot) {
+        try {
+            if (typeof root !== "function") {
+                resolveFileSystemTools({
+                    root,
+                    tools: authoredAllowlist,
+                });
+            }
+            else {
+                resolveRootHarnessAllowlist(authoredAllowlist);
+            }
+            allowedTools = authoredAllowlist;
+        }
+        catch (error) {
             ctx.diagnostics.push({
                 severity: "error",
                 path: displayPath(ctx, join(agentDir, "agent.ts")),
-                message: runtimeArchitectureError,
-            });
-        }
-        if (runtime === "cloud") {
-            warnCloudRuntimeLimitations(ctx, agentDir, {
-                agentTools: tools.filter(tool => tool.execution === "agent").length,
-                skills: skills.length,
-                seedFiles: seedFiles.length,
-                hasCloudOptions: cloud !== undefined,
-            });
-        }
-        appendBuiltinTools(ctx, agentDir, tools, config === null || config === void 0 ? void 0 : config.builtinTools);
-        // After appendBuiltinTools so opted-in built-ins (server-executed) count.
-        if (runtime === "grokbot") {
-            checkGrokBotRuntimeLimitations(ctx, agentDir, {
-                serverTools: tools.filter(tool => tool.execution === "server").length,
-                agentTools: tools.filter(tool => tool.execution === "agent").length,
-                skills: skills.length,
-                seedFiles: seedFiles.length,
-                connections: connections.length + hostConnections.length,
-                subagents: subagents.length,
-                hasCloudOptions: cloud !== undefined,
-                hasLocalSandbox: localSandbox,
+                message: error instanceof FileSystemConfigError
+                    ? error.message
+                    : error instanceof Error
+                        ? error.message
+                        : String(error),
             });
         }
-        return {
-            agent: Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ name, description: config === null || config === void 0 ? void 0 : config.description, 
-                // Root agents always get a concrete model: authored value or DEFAULT_MODEL.
-                model: isValidModelSetting(config === null || config === void 0 ? void 0 : config.model) ? config.model : DEFAULT_MODEL, modelFallbacks: resolveModelFallbacks(ctx, join(agentDir, "agent.ts"), config === null || config === void 0 ? void 0 : config.fallbacks), instructions,
-                runtime }, (root === undefined ? {} : { root })), { cloud,
-                local }), (allowedTools === undefined ? {} : { allowedTools })), { hosting,
-                concurrency }), (architecture === undefined ? {} : { architecture })), { persistent,
-                tools,
-                skills,
-                extensions,
-                connections,
-                hostConnections,
-                subagents,
-                seedFiles }),
-            projectSlots: {
-                hooks,
-                channels,
-                schedules,
-                reminders,
-                artifacts: contributions.artifacts,
-            },
+    }
+    // The allowlist states runtime-agnostic intent, but only the local
+    // harness can enforce it (the Cursor SDK rejects tool restrictions on
+    // cloud agents, and the Grok Bot harness has its own fixed toolset) — a
+    // non-local agent that declares one must fail at serve start, never run
+    // unrestricted. (Hybrid per-send cloud sessions fail closed in the
+    // session engine.)
+    if (allowedTools !== undefined && runtime !== "local") {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, join(agentDir, "agent.ts")),
+            message: `tools cannot be enforced on runtime: "${runtime}". Remove \`tools\` or run the agent on the local runtime.`,
+        });
+    }
+    // Per-session connection features (defineConnection auth/advertiseTools)
+    // only run on local turns: advertised tools are in-process server tools,
+    // and per-session headers cannot reach a cloud VM's MCP config. A
+    // non-local agent that declares them must fail at serve start — never
+    // run without the connection's tools or identity. (Hybrid per-send
+    // cloud sessions fail closed in the session engine.)
+    const perSessionConnection = connections.find(connection => connection.advertiseTools === true || connection.auth !== undefined);
+    if (perSessionConnection !== undefined && runtime !== "local") {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, join(agentDir, "agent.ts")),
+            message: `MCP connection "${perSessionConnection.name}" uses advertiseTools/auth, which only run on runtime: "local". Remove them or run the agent on the local runtime.`,
+        });
+    }
+    // `execution: "agent"` tool scripts run through the shell tool. Shell is
+    // a real capability, so it is never injected — but an allowlist that
+    // strands authored scripts deserves a loud diagnostic, not silence.
+    if (allowedTools !== undefined &&
+        !allowedTools.includes("shell") &&
+        tools.some(tool => tool.execution === "agent")) {
+        ctx.diagnostics.push({
+            severity: "warning",
+            path: displayPath(ctx, join(agentDir, "agent.ts")),
+            message: '`tools` omits "shell" but this agent has execution: "agent" tools, which run as shell scripts; the model will not be able to run them.',
+        });
+    }
+    if (localCwd !== undefined && localWorkspaceDir !== undefined) {
+        ctx.diagnostics.push({
+            severity: "warning",
+            path: displayPath(ctx, join(agentDir, "agent.ts")),
+            message: "local.workspaceDir pins every session to one directory, so local.cwd is unused. Drop one of them.",
+        });
+    }
+    const local = localCwd === undefined && localWorkspaceDir === undefined && !localSandbox
+        ? undefined
+        : {
+            cwd: localCwd,
+            workspaceDir: localWorkspaceDir,
+            sandbox: localSandbox,
         };
+    const hosting = resolveHosting(ctx, agentDir, config?.hosting, extensions);
+    const concurrency = resolveConcurrency(ctx, agentDir, config?.concurrency);
+    const architecture = resolveArchitecture(ctx, agentDir, config?.architecture);
+    const persistent = resolvePersistent(ctx, agentDir, config?.persistent, architecture);
+    const runtimeArchitectureError = runtimeArchitectureCompatibilityError({
+        runtime,
+        architecture,
     });
+    if (runtimeArchitectureError !== undefined) {
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, join(agentDir, "agent.ts")),
+            message: runtimeArchitectureError,
+        });
+    }
+    if (runtime === "cloud") {
+        warnCloudRuntimeLimitations(ctx, agentDir, {
+            agentTools: tools.filter(tool => tool.execution === "agent").length,
+            skills: skills.length,
+            seedFiles: seedFiles.length,
+            hasCloudOptions: cloud !== undefined,
+        });
+    }
+    appendBuiltinTools(ctx, agentDir, tools, config?.builtinTools);
+    // After appendBuiltinTools so opted-in built-ins (server-executed) count.
+    if (runtime === "grokbot") {
+        checkGrokBotRuntimeLimitations(ctx, agentDir, {
+            serverTools: tools.filter(tool => tool.execution === "server").length,
+            agentTools: tools.filter(tool => tool.execution === "agent").length,
+            skills: skills.length,
+            seedFiles: seedFiles.length,
+            connections: connections.length + hostConnections.length,
+            subagents: subagents.length,
+            hasCloudOptions: cloud !== undefined,
+            hasLocalSandbox: localSandbox,
+        });
+    }
+    return {
+        agent: {
+            name,
+            description: config?.description,
+            // Root agents always get a concrete model: authored value or DEFAULT_MODEL.
+            model: isValidModelSetting(config?.model) ? config.model : DEFAULT_MODEL,
+            modelFallbacks: resolveModelFallbacks(ctx, join(agentDir, "agent.ts"), config?.fallbacks),
+            instructions,
+            runtime,
+            ...(root === undefined ? {} : { root }),
+            cloud,
+            local,
+            ...(allowedTools === undefined ? {} : { allowedTools }),
+            hosting,
+            concurrency,
+            ...(architecture === undefined ? {} : { architecture }),
+            persistent,
+            tools,
+            skills,
+            extensions,
+            connections,
+            hostConnections,
+            subagents,
+            seedFiles,
+        },
+        projectSlots: {
+            hooks,
+            channels,
+            schedules,
+            reminders,
+            artifacts: contributions.artifacts,
+        },
+    };
 }
-export function warnUnknownSlots(ctx, agentDir) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const known = new Set([
-            "agent",
-            "instructions",
-            "tools",
-            "skills",
-            "extensions",
-            "mcp-connections",
-            "host-connections",
-            "subagents",
-            "channels",
-            "schedules",
-            "reminders",
-            "hooks",
-            "sandbox",
-            "lib",
-            // Vite playground custom tool chips (agent/playground/tools).
-            "playground",
-        ]);
-        const projectRoot = displayPath(ctx, agentDir);
-        for (const entry of yield sortedEntries(agentDir)) {
-            if (!entry.isDirectory() || entry.name.startsWith(".")) {
-                continue;
-            }
-            if (entry.name === "node_modules" || known.has(entry.name)) {
-                continue;
-            }
-            // Footgun: evals live at project-root `evals/`, not under the authored root.
-            if (entry.name === "evals") {
-                ctx.diagnostics.push({
-                    severity: "warning",
-                    path: displayPath(ctx, join(agentDir, entry.name)),
-                    message: `Directory "evals" under ${projectRoot}/ is ignored — put defineEval files at project-root evals/ instead.`,
-                });
-                continue;
-            }
+export async function warnUnknownSlots(ctx, agentDir) {
+    const known = new Set([
+        "agent",
+        "instructions",
+        "tools",
+        "skills",
+        "extensions",
+        "mcp-connections",
+        "host-connections",
+        "subagents",
+        "channels",
+        "schedules",
+        "reminders",
+        "hooks",
+        "sandbox",
+        "lib",
+        // Vite playground custom tool chips (agent/playground/tools).
+        "playground",
+    ]);
+    const projectRoot = displayPath(ctx, agentDir);
+    for (const entry of await sortedEntries(agentDir)) {
+        if (!entry.isDirectory() || entry.name.startsWith(".")) {
+            continue;
+        }
+        if (entry.name === "node_modules" || known.has(entry.name)) {
+            continue;
+        }
+        // Footgun: evals live at project-root `evals/`, not under the authored root.
+        if (entry.name === "evals") {
             ctx.diagnostics.push({
                 severity: "warning",
                 path: displayPath(ctx, join(agentDir, entry.name)),
-                message: `Unrecognized directory "${entry.name}" under ${projectRoot}/ (not an authored slot; use lib/ for shared code).`,
+                message: `Directory "evals" under ${projectRoot}/ is ignored — put defineEval files at project-root evals/ instead.`,
             });
+            continue;
         }
-    });
+        ctx.diagnostics.push({
+            severity: "warning",
+            path: displayPath(ctx, join(agentDir, entry.name)),
+            message: `Unrecognized directory "${entry.name}" under ${projectRoot}/ (not an authored slot; use lib/ for shared code).`,
+        });
+    }
 }