@cursor/july 0.1.1

package/dist/internal/discovery.js

@@ -0,0 +1,1427 @@
+/**
+ * Filesystem discovery: walks a project's `agent/` directory and compiles
+ * the authored files (markdown and TypeScript) into an {@link AgentProject}
+ * manifest. Identity comes from the path — a tool at `agent/tools/foo.ts`
+ * is named `foo`, a subagent at `agent/subagents/researcher/` is named
+ * `researcher` — so no definition carries a `name` field.
+ */
+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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename, extname, isAbsolute, join, relative, resolve, } from "node:path";
+import { pathToFileURL } from "node:url";
+import { resolveABMaxPlaygroundSessions } from "../ab.js";
+import { httpChannel } from "../channels.js";
+import { DEFAULT_MODEL, toPublicCloudInfo, } from "../types.js";
+import { registerAuthoredModuleLoaders } from "./authored-loaders.js";
+import { getDefinitionKind } from "./brand.js";
+import { isValidCron } from "./cron.js";
+import { parseFrontmatter } from "./frontmatter.js";
+import { toolInputJsonSchema } from "./json-schema.js";
+import { MCP_ENDPOINT_PATH, mcpEndpointToolNames } from "./mcp-endpoint.js";
+const MODULE_EXTENSIONS = new Set([".ts", ".mts", ".js", ".mjs"]);
+const NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+const SKILL_DESCRIPTION_FALLBACK = (name) => `Instructions for the ${name} skill.`;
+function defaultImportModule(absolutePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield import(pathToFileURL(absolutePath).href));
+    });
+}
+/**
+ * True when `dir` looks like an agent project root: it has a nested `agent/`
+ * directory, or flat-layout markers (`agent.ts` / `instructions.md`) directly
+ * inside it.
+ */
+export function isAgentProjectDir(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const resolved = resolve(dir);
+        if (!(yield isDirectory(resolved))) {
+            return false;
+        }
+        if (yield isDirectory(join(resolved, "agent"))) {
+            return true;
+        }
+        return hasFlatLayoutMarkers(resolved);
+    });
+}
+/**
+ * Discover the agent projects directly under `rootDir` (one level deep):
+ * each immediate child directory that is itself an agent project becomes a
+ * mounted agent, keyed by a slug derived from its directory name. Used for
+ * multi-agent serving, where one server hosts many agents under
+ * `/<slug>/...`. Throws when no child projects are found.
+ */
+export function loadAgentProjects(rootDir_1) {
+    return __awaiter(this, arguments, void 0, function* (rootDir, options = {}) {
+        const resolved = resolve(rootDir);
+        if (!(yield isDirectory(resolved))) {
+            throw new Error(`Agent projects directory does not exist: ${resolved}`);
+        }
+        const results = [];
+        const seenSlugs = new Set();
+        for (const entry of yield sortedEntries(resolved)) {
+            if (!entry.isDirectory() || entry.name.startsWith(".")) {
+                continue;
+            }
+            if (entry.name === "node_modules") {
+                continue;
+            }
+            const childDir = join(resolved, entry.name);
+            if (!(yield isAgentProjectDir(childDir))) {
+                continue;
+            }
+            const slug = assertSlug(entry.name, resolved);
+            if (seenSlugs.has(slug)) {
+                throw new Error(`Duplicate agent slug "${slug}" under ${resolved}.`);
+            }
+            seenSlugs.add(slug);
+            results.push({ slug, project: yield loadAgentProject(childDir, options) });
+        }
+        if (results.length === 0) {
+            throw new Error(`No agent projects found directly under ${resolved}. Each agent should be a subdirectory with its own agent/ directory (or flat-layout markers).`);
+        }
+        return results;
+    });
+}
+/**
+ * Resolve mounts for `serve` / CLI. Defaults to multi-agent layout:
+ * - `mode: "single"` — one agent at `/v1/*` (empty slug).
+ * - otherwise, if `rootDir` is itself an agent project — one agent under
+ *   `/<dirname>/...`.
+ * - otherwise, every immediate child agent project under `/<slug>/...`.
+ */
+export function resolveAgentMounts(rootDir_1) {
+    return __awaiter(this, arguments, void 0, function* (rootDir, options = {}) {
+        const { mode = "multi" } = options, discovery = __rest(options, ["mode"]);
+        if (mode === "single") {
+            return [{ slug: "", project: yield loadAgentProject(rootDir, discovery) }];
+        }
+        if (yield isAgentProjectDir(rootDir)) {
+            const resolved = resolve(rootDir);
+            const slug = assertSlug(basename(resolved), resolved);
+            return [
+                {
+                    slug,
+                    project: yield loadAgentProject(rootDir, discovery),
+                },
+            ];
+        }
+        return loadAgentProjects(rootDir, discovery);
+    });
+}
+function assertSlug(name, parentDir) {
+    if (!NAME_PATTERN.test(name) || RESERVED_SLUGS.has(name)) {
+        throw new Error(`Cannot mount agent directory "${name}" under ${parentDir}: its name must match ${NAME_PATTERN} and not be one of ${[...RESERVED_SLUGS].join(", ")}.`);
+    }
+    return name;
+}
+/** URL path segments reserved by the server; agents cannot use them as slugs. */
+export const RESERVED_SLUGS = new Set([
+    "v1",
+    "playground",
+    "docs",
+]);
+export function loadAgentProject(dir_1) {
+    return __awaiter(this, arguments, void 0, function* (dir, options = {}) {
+        var _a, _b;
+        // Public API: embedders can call discovery directly (without `serve()` or
+        // the CLI), and it dynamically imports authored TypeScript.
+        yield registerAuthoredModuleLoaders();
+        const rootDir = resolve(dir);
+        if (!(yield isDirectory(rootDir))) {
+            throw new Error(`Agent project directory does not exist: ${rootDir}`);
+        }
+        const nestedAgentDir = join(rootDir, "agent");
+        let agentDir;
+        if (yield isDirectory(nestedAgentDir)) {
+            agentDir = nestedAgentDir;
+        }
+        else if (yield hasFlatLayoutMarkers(rootDir)) {
+            agentDir = rootDir;
+        }
+        else {
+            throw new Error(`No agent found under ${rootDir}: expected an agent/ directory (or a flat layout with agent.ts / instructions.md at the root)`);
+        }
+        const diagnostics = [];
+        const ctx = {
+            rootDir,
+            diagnostics,
+            importModule: (_a = options.importModule) !== null && _a !== void 0 ? _a : defaultImportModule,
+        };
+        const name = (_b = (yield readPackageName(rootDir))) !== null && _b !== void 0 ? _b : basename(rootDir);
+        const agent = yield loadAgent(ctx, agentDir, {
+            name,
+            isRoot: true,
+        });
+        const { channels, httpChannelDefinition } = yield loadChannels(ctx, join(agentDir, "channels"));
+        const schedules = yield loadSchedules(ctx, join(agentDir, "schedules"));
+        const hooks = yield loadHooks(ctx, join(agentDir, "hooks"));
+        const abs = yield loadABs(ctx, agentDir);
+        const abConfig = yield loadABConfig(ctx, agentDir);
+        if (agentDir !== rootDir) {
+            yield warnUnknownSlots(ctx, agentDir);
+        }
+        return Object.assign(Object.assign({ rootDir,
+            agentDir, name: agent.name, agent, httpChannel: httpChannelDefinition !== null && httpChannelDefinition !== void 0 ? httpChannelDefinition : httpChannel(), channels,
+            schedules,
+            hooks,
+            abs }, (abConfig === undefined ? {} : { abConfig })), { diagnostics });
+    });
+}
+/** True when the project has diagnostics that must block serving. */
+export function hasErrorDiagnostics(project) {
+    return project.diagnostics.some((d) => d.severity === "error");
+}
+export function formatDiagnostics(diagnostics) {
+    return diagnostics
+        .map((d) => {
+        const location = d.path === undefined ? "" : ` (${d.path})`;
+        return `${d.severity}: ${d.message}${location}`;
+    })
+        .join("\n");
+}
+// ============================================================================
+// Agents (root + subagents)
+// ============================================================================
+function loadAgent(ctx, agentDir, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        var _b, _c;
+        const config = yield loadAgentConfig(ctx, agentDir, options.isRoot);
+        const instructions = yield loadInstructions(ctx, agentDir, config, options.isRoot);
+        // Subagents run as Cursor SDK custom subagents (prompt + description +
+        // model); their other slots are inert today, so don't load them — just
+        // warn that they exist.
+        if (!options.isRoot) {
+            yield warnUnsupportedSubagentSlots(ctx, agentDir);
+            return Object.assign(Object.assign(Object.assign(Object.assign({ name: (_b = config === null || config === void 0 ? void 0 : config.name) !== null && _b !== void 0 ? _b : options.name }, ((config === null || config === void 0 ? void 0 : config.description) === undefined
+                ? {}
+                : { description: config.description })), ((config === null || config === void 0 ? void 0 : config.model) === undefined ? {} : { model: config.model })), (instructions === undefined ? {} : { instructions })), { runtime: "local", tools: [], skills: [], connections: [], subagents: [], seedFiles: [] });
+        }
+        const tools = yield loadTools(ctx, join(agentDir, "tools"));
+        const skills = yield loadSkills(ctx, join(agentDir, "skills"));
+        const connections = yield loadConnections(ctx, yield resolveMcpConnectionsDir(ctx, agentDir));
+        const seedFiles = yield loadSeedFiles(ctx, agentDir);
+        const subagents = yield loadSubagents(ctx, join(agentDir, "subagents"));
+        const runtime = (config === null || config === void 0 ? void 0 : config.runtime) === "cloud" ? "cloud" : "local";
+        // 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 localCwd = resolveAgentCwd(ctx, (_a = config === null || config === void 0 ? void 0 : config.local) === null || _a === void 0 ? void 0 : _a.cwd);
+        const local = localCwd === undefined
+            ? undefined
+            : {
+                cwd: localCwd,
+            };
+        if (runtime === "cloud") {
+            warnCloudRuntimeLimitations(ctx, agentDir, {
+                serverTools: tools.filter((tool) => tool.execution === "server").length,
+                agentTools: tools.filter((tool) => tool.execution === "agent").length,
+                skills: skills.length,
+                seedFiles: seedFiles.length,
+                hasCloudOptions: cloud !== undefined,
+            });
+        }
+        return {
+            name: (_c = config === null || config === void 0 ? void 0 : config.name) !== null && _c !== void 0 ? _c : options.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,
+            instructions,
+            runtime,
+            cloud,
+            local,
+            tools,
+            skills,
+            connections,
+            subagents,
+            seedFiles,
+        };
+    });
+}
+/** Absolute harness cwd parent, or undefined when unset / blank. */
+function resolveAgentCwd(ctx, authored) {
+    if (authored === undefined) {
+        return undefined;
+    }
+    const trimmed = authored.trim();
+    if (trimmed === "") {
+        return undefined;
+    }
+    return isAbsolute(trimmed) ? trimmed : resolve(ctx.rootDir, trimmed);
+}
+function loadAgentConfig(ctx, agentDir, isRoot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const configPath = yield findModuleFile(agentDir, "agent");
+        if (configPath === undefined) {
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, join(agentDir, "agent.ts")),
+                message: isRoot
+                    ? "agent.ts is required on the root agent: default-export defineAgent({ ... })"
+                    : "agent.ts is required on a subagent: default-export defineAgent({ description: ... })",
+            });
+            return undefined;
+        }
+        const definition = yield importDefault(ctx, configPath, "agent");
+        if (definition === undefined) {
+            return undefined;
+        }
+        const config = definition;
+        if (!isRoot && isBlank(config.description)) {
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, configPath),
+                message: "Subagents require a description; the parent model reads it to decide when to delegate.",
+            });
+        }
+        return config;
+    });
+}
+function loadInstructions(ctx, agentDir, config, isRoot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const parts = [];
+        const markdownPath = join(agentDir, "instructions.md");
+        if (yield isFile(markdownPath)) {
+            parts.push((yield readFile(markdownPath, "utf8")).trim());
+        }
+        const modulePath = yield findModuleFile(agentDir, "instructions");
+        if (modulePath !== undefined) {
+            const loaded = yield loadInstructionsModule(ctx, modulePath);
+            if (loaded !== undefined) {
+                parts.push(loaded);
+            }
+        }
+        const instructionsDir = join(agentDir, "instructions");
+        if (yield isDirectory(instructionsDir)) {
+            for (const entry of yield sortedEntries(instructionsDir)) {
+                if (!entry.isFile()) {
+                    continue;
+                }
+                const entryPath = join(instructionsDir, entry.name);
+                if (entry.name.endsWith(".md")) {
+                    parts.push((yield readFile(entryPath, "utf8")).trim());
+                }
+                else if (isModuleFile(entry.name)) {
+                    const loaded = yield loadInstructionsModule(ctx, entryPath);
+                    if (loaded !== undefined) {
+                        parts.push(loaded);
+                    }
+                }
+            }
+        }
+        if ((config === null || config === void 0 ? void 0 : config.instructions) !== undefined && !isBlank(config.instructions)) {
+            parts.push(config.instructions.trim());
+        }
+        const combined = parts.filter((part) => part !== "").join("\n\n");
+        if (combined === "") {
+            if (isRoot) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, markdownPath),
+                    message: "instructions.md is required on the root agent (the always-on system prompt).",
+                });
+            }
+            return undefined;
+        }
+        return combined;
+    });
+}
+function loadInstructionsModule(ctx, modulePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let mod;
+        try {
+            mod = yield ctx.importModule(modulePath);
+        }
+        catch (error) {
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, modulePath),
+                message: `Failed to load module: ${errorMessage(error)}`,
+            });
+            return undefined;
+        }
+        const value = mod.default;
+        if (typeof value === "string") {
+            return value.trim();
+        }
+        if (getDefinitionKind(value) === "instructions") {
+            return value.markdown.trim();
+        }
+        ctx.diagnostics.push({
+            severity: "error",
+            path: displayPath(ctx, modulePath),
+            message: "Instructions modules must default-export a string or defineInstructions({ markdown }).",
+        });
+        return undefined;
+    });
+}
+// ============================================================================
+// Tools
+// ============================================================================
+function loadTools(ctx, toolsDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield isDirectory(toolsDir))) {
+            return [];
+        }
+        const tools = [];
+        for (const entry of yield sortedEntries(toolsDir)) {
+            const entryPath = join(toolsDir, entry.name);
+            if (entry.isDirectory()) {
+                ctx.diagnostics.push({
+                    severity: "warning",
+                    path: displayPath(ctx, entryPath),
+                    message: "Nested tool directories are not supported; ignoring.",
+                });
+                continue;
+            }
+            if (!entry.isFile() || !isModuleFile(entry.name)) {
+                continue;
+            }
+            const name = moduleStem(entry.name);
+            if (!NAME_PATTERN.test(name)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: `Tool name "${name}" must match ${NAME_PATTERN} (the filename becomes the tool name the model sees).`,
+                });
+                continue;
+            }
+            const definition = yield importDefault(ctx, entryPath, "tool");
+            if (definition === undefined) {
+                continue;
+            }
+            const tool = definition;
+            if (isBlank(tool.description)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: "Tools require a non-empty description.",
+                });
+                continue;
+            }
+            const execution = tool.execution === "agent" ? "agent" : "server";
+            const needsApprovalConfigured = tool.needsApproval === true || typeof tool.needsApproval === "function";
+            if (execution === "agent") {
+                if (isBlank(tool.script)) {
+                    ctx.diagnostics.push({
+                        severity: "error",
+                        path: displayPath(ctx, entryPath),
+                        message: 'Tools with execution: "agent" require a non-empty `script` (shell body; JSON on stdin, result on stdout).',
+                    });
+                    continue;
+                }
+                if (typeof tool.execute === "function") {
+                    ctx.diagnostics.push({
+                        severity: "warning",
+                        path: displayPath(ctx, entryPath),
+                        message: '`execute` is ignored when execution is "agent"; the Cursor agent runs `script` instead.',
+                    });
+                }
+                if (needsApprovalConfigured) {
+                    ctx.diagnostics.push({
+                        severity: "error",
+                        path: displayPath(ctx, entryPath),
+                        message: '`needsApproval` is only supported for execution: "server" tools (in-process).',
+                    });
+                    continue;
+                }
+            }
+            else if (typeof tool.execute !== "function") {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: 'Tools require an execute(input, ctx) function (or set execution: "agent" with a script).',
+                });
+                continue;
+            }
+            let inputSchema;
+            try {
+                inputSchema = toolInputJsonSchema(tool.inputSchema);
+            }
+            catch (error) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: `Failed to convert inputSchema to JSON Schema: ${errorMessage(error)}`,
+                });
+                continue;
+            }
+            tools.push(Object.assign(Object.assign({ name, description: tool.description, inputSchema,
+                execution, needsApproval: needsApprovalConfigured }, (execution === "agent" && tool.script !== undefined
+                ? { script: tool.script }
+                : {})), { definition: tool }));
+        }
+        return tools;
+    });
+}
+// ============================================================================
+// Skills
+// ============================================================================
+function loadSkills(ctx, skillsDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        if (!(yield isDirectory(skillsDir))) {
+            return [];
+        }
+        const skills = [];
+        for (const entry of yield sortedEntries(skillsDir)) {
+            const entryPath = join(skillsDir, entry.name);
+            if (entry.isDirectory()) {
+                const skill = yield loadPackagedSkill(ctx, entryPath, entry.name);
+                if (skill !== undefined) {
+                    skills.push(skill);
+                }
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            if (entry.name.endsWith(".md")) {
+                const name = entry.name.slice(0, -".md".length);
+                if (!validateSkillName(ctx, name, entryPath)) {
+                    continue;
+                }
+                const { data, body } = parseFrontmatter(yield readFile(entryPath, "utf8"));
+                skills.push({
+                    name,
+                    description: (_b = (_a = data.description) !== null && _a !== void 0 ? _a : deriveSkillDescription(body)) !== null && _b !== void 0 ? _b : SKILL_DESCRIPTION_FALLBACK(name),
+                    markdown: body.trim(),
+                    files: {},
+                });
+                continue;
+            }
+            if (isModuleFile(entry.name)) {
+                const name = moduleStem(entry.name);
+                if (!validateSkillName(ctx, name, entryPath)) {
+                    continue;
+                }
+                const definition = yield importDefault(ctx, entryPath, "skill");
+                if (definition === undefined) {
+                    continue;
+                }
+                const skill = definition;
+                const files = {};
+                for (const [rel, contents] of Object.entries((_c = skill.files) !== null && _c !== void 0 ? _c : {})) {
+                    files[rel] = { contents };
+                }
+                skills.push({
+                    name,
+                    description: (_e = (_d = skill.description) !== null && _d !== void 0 ? _d : deriveSkillDescription(skill.markdown)) !== null && _e !== void 0 ? _e : SKILL_DESCRIPTION_FALLBACK(name),
+                    markdown: skill.markdown.trim(),
+                    files,
+                });
+            }
+        }
+        return skills;
+    });
+}
+function loadPackagedSkill(ctx, skillDir, name) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const skillMdPath = join(skillDir, "SKILL.md");
+        if (!(yield isFile(skillMdPath))) {
+            ctx.diagnostics.push({
+                severity: "warning",
+                path: displayPath(ctx, skillDir),
+                message: "Skill directories must contain a SKILL.md; ignoring.",
+            });
+            return undefined;
+        }
+        if (!validateSkillName(ctx, name, skillDir)) {
+            return undefined;
+        }
+        const { data, body } = parseFrontmatter(yield readFile(skillMdPath, "utf8"));
+        if (data.description === undefined || isBlank(data.description)) {
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, skillMdPath),
+                message: "Packaged skills require `description` frontmatter in SKILL.md (there is no filename slug to fall back on).",
+            });
+            return undefined;
+        }
+        const files = {};
+        for (const filePath of yield walkFiles(skillDir)) {
+            const rel = toPosix(relative(skillDir, filePath));
+            if (rel === "SKILL.md") {
+                continue;
+            }
+            files[rel] = { sourcePath: filePath };
+        }
+        return {
+            name,
+            description: data.description,
+            markdown: body.trim(),
+            files,
+        };
+    });
+}
+/** One-line `/v1/info` label for a connection transport. */
+function connectionTransportLabel(transport) {
+    if ("cursorAccount" in transport) {
+        return transport.servers === undefined
+            ? "cursor-account"
+            : `cursor-account:${transport.servers.join(",")}`;
+    }
+    if ("agent" in transport) {
+        return `agent:${transport.agent}`;
+    }
+    if ("url" in transport) {
+        return transport.url;
+    }
+    return transport.command;
+}
+function connectionTransport(connection) {
+    if ("cursorAccount" in connection && connection.cursorAccount === true) {
+        return Object.assign({ cursorAccount: true }, (connection.servers === undefined
+            ? {}
+            : { servers: connection.servers }));
+    }
+    if ("agent" in connection && !isBlank(connection.agent)) {
+        return { agent: connection.agent };
+    }
+    if ("url" in connection && !isBlank(connection.url)) {
+        return Object.assign(Object.assign(Object.assign({}, (connection.type === undefined ? {} : { type: connection.type })), { url: connection.url }), (connection.headers === undefined
+            ? {}
+            : { headers: connection.headers }));
+    }
+    if ("command" in connection && !isBlank(connection.command)) {
+        return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (connection.type === undefined ? {} : { type: connection.type })), { command: connection.command }), (connection.args === undefined ? {} : { args: connection.args })), (connection.env === undefined ? {} : { env: connection.env })), (connection.cwd === undefined ? {} : { cwd: connection.cwd }));
+    }
+    return undefined;
+}
+function validateSkillName(ctx, name, entryPath) {
+    if (NAME_PATTERN.test(name)) {
+        return true;
+    }
+    ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, entryPath),
+        message: `Skill name "${name}" must match ${NAME_PATTERN}.`,
+    });
+    return false;
+}
+/**
+ * Advertise the first non-empty, non-code-fence line of the body, with any
+ * leading `#`, `>`, `*`, or `-` markers stripped.
+ */
+export function deriveSkillDescription(markdown) {
+    let inFence = false;
+    for (const rawLine of markdown.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (line.startsWith("```")) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence || line === "") {
+            continue;
+        }
+        const stripped = line.replace(/^[#>*\s-]+/, "").trim();
+        if (stripped !== "") {
+            return stripped.length > 200 ? `${stripped.slice(0, 197)}...` : stripped;
+        }
+    }
+    return undefined;
+}
+// ============================================================================
+// MCP connections
+// ============================================================================
+/**
+ * Prefer `agent/mcp-connections/`. Keep loading `agent/connections/` with a
+ * deprecation warning so existing agents keep working during the rename.
+ */
+function resolveMcpConnectionsDir(ctx, agentDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const preferred = join(agentDir, "mcp-connections");
+        const legacy = join(agentDir, "connections");
+        const hasPreferred = yield isDirectory(preferred);
+        const hasLegacy = yield isDirectory(legacy);
+        if (hasPreferred && hasLegacy) {
+            ctx.diagnostics.push({
+                severity: "warning",
+                path: displayPath(ctx, legacy),
+                message: "Both agent/mcp-connections/ and agent/connections/ exist; using mcp-connections/ and ignoring connections/. Rename or remove the legacy directory.",
+            });
+            return preferred;
+        }
+        if (hasLegacy) {
+            ctx.diagnostics.push({
+                severity: "warning",
+                path: displayPath(ctx, legacy),
+                message: "agent/connections/ is deprecated; rename it to agent/mcp-connections/. Loading from the legacy path for now.",
+            });
+            return legacy;
+        }
+        return preferred;
+    });
+}
+function loadConnections(ctx, connectionsDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield isDirectory(connectionsDir))) {
+            return [];
+        }
+        const connections = [];
+        for (const entry of yield sortedEntries(connectionsDir)) {
+            const entryPath = join(connectionsDir, entry.name);
+            if (!entry.isFile() || !isModuleFile(entry.name)) {
+                continue;
+            }
+            const name = moduleStem(entry.name);
+            if (!NAME_PATTERN.test(name)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: `MCP connection name "${name}" must match ${NAME_PATTERN}.`,
+                });
+                continue;
+            }
+            const definition = yield importDefault(ctx, entryPath, "connection");
+            if (definition === undefined) {
+                continue;
+            }
+            const connection = definition;
+            const transport = connectionTransport(connection);
+            if (transport === undefined) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: "MCP connections require a `url` (http/sse), a `command` (stdio), an `agent` (peer agent slug on the same serve host), or `cursorAccount: true` (the Cursor account's MCP connectors).",
+                });
+                continue;
+            }
+            if ("cursorAccount" in transport &&
+                transport.servers !== undefined &&
+                (transport.servers.length === 0 ||
+                    transport.servers.some((server) => isBlank(server)))) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: "Cursor account MCP connection `servers` must be a non-empty list of connector names (or omitted to expose every connected server).",
+                });
+                continue;
+            }
+            if ("agent" in transport && !NAME_PATTERN.test(transport.agent)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: `Peer MCP connection agent "${transport.agent}" must be a mount slug matching ${NAME_PATTERN}.`,
+                });
+                continue;
+            }
+            connections.push(Object.assign({ name,
+                transport }, (connection.description === undefined
+                ? {}
+                : { description: connection.description })));
+        }
+        return connections;
+    });
+}
+// ============================================================================
+// Subagents
+// ============================================================================
+function loadSubagents(ctx, subagentsDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield isDirectory(subagentsDir))) {
+            return [];
+        }
+        const subagents = [];
+        for (const entry of yield sortedEntries(subagentsDir)) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const subagentDir = join(subagentsDir, entry.name);
+            if (!NAME_PATTERN.test(entry.name)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, subagentDir),
+                    message: `Subagent name "${entry.name}" must match ${NAME_PATTERN}.`,
+                });
+                continue;
+            }
+            subagents.push(yield loadAgent(ctx, subagentDir, { name: entry.name, isRoot: false }));
+        }
+        return subagents;
+    });
+}
+function warnUnsupportedSubagentSlots(ctx, subagentDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const unsupported = [
+            ["tools", "tools"],
+            ["skills", "skills"],
+            ["mcp-connections", "MCP connections"],
+            ["connections", "MCP connections"],
+            ["subagents", "nested subagents"],
+            ["channels", "channels"],
+            ["schedules", "schedules"],
+            ["hooks", "hooks"],
+            ["sandbox", "sandbox files"],
+        ];
+        for (const [slot, label] of unsupported) {
+            if (yield isDirectory(join(subagentDir, slot))) {
+                ctx.diagnostics.push({
+                    severity: "warning",
+                    path: displayPath(ctx, join(subagentDir, slot)),
+                    message: `Subagent ${label} are not supported on the Cursor harness yet; the subagent runs with the parent's execution surface. Ignoring.`,
+                });
+            }
+        }
+    });
+}
+function warnCloudRuntimeLimitations(ctx, agentDir, counts) {
+    const agentPath = displayPath(ctx, join(agentDir, "agent.ts"));
+    if (!counts.hasCloudOptions) {
+        ctx.diagnostics.push({
+            severity: "warning",
+            path: agentPath,
+            message: 'runtime: "cloud" usually needs a `cloud` block (e.g. repos / env). Without it the Cursor cloud API may reject create.',
+        });
+    }
+    if (counts.serverTools > 0) {
+        ctx.diagnostics.push({
+            severity: "warning",
+            path: displayPath(ctx, join(agentDir, "tools")),
+            message: 'In-process tools (execution: "server", the default) are not available on cloud agents. Use execution: "agent", MCP connections, or tools that already live in the cloud workspace.',
+        });
+    }
+    if (counts.agentTools > 0) {
+        ctx.diagnostics.push({
+            severity: "warning",
+            path: displayPath(ctx, join(agentDir, "tools")),
+            message: 'Agent tools (execution: "agent") are described on the first cloud prompt (with script bodies); they are not written into the cloud VM filesystem automatically.',
+        });
+    }
+    if (counts.skills > 0) {
+        ctx.diagnostics.push({
+            severity: "warning",
+            path: displayPath(ctx, join(agentDir, "skills")),
+            message: "Authored skills are materialized into the local session workspace only; cloud agents see skills that already exist in the cloud repo.",
+        });
+    }
+    if (counts.seedFiles > 0) {
+        ctx.diagnostics.push({
+            severity: "warning",
+            path: displayPath(ctx, join(agentDir, "sandbox")),
+            message: "sandbox/workspace seed files apply to the local session workspace only; cloud agents use the configured cloud repos.",
+        });
+    }
+}
+// ============================================================================
+// Channels
+// ============================================================================
+function loadChannels(ctx, channelsDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const channels = [];
+        let httpChannelDefinition;
+        if (!(yield isDirectory(channelsDir))) {
+            return { channels, httpChannelDefinition };
+        }
+        for (const entry of yield sortedEntries(channelsDir)) {
+            const entryPath = join(channelsDir, entry.name);
+            if (!entry.isFile() || !isModuleFile(entry.name)) {
+                continue;
+            }
+            const id = moduleStem(entry.name);
+            if (!NAME_PATTERN.test(id)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: `Channel id "${id}" must match ${NAME_PATTERN}.`,
+                });
+                continue;
+            }
+            let mod;
+            try {
+                mod = yield ctx.importModule(entryPath);
+            }
+            catch (error) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: `Failed to load module: ${errorMessage(error)}`,
+                });
+                continue;
+            }
+            const kind = getDefinitionKind(mod.default);
+            if (kind === "http-channel") {
+                if (id !== "http") {
+                    ctx.diagnostics.push({
+                        severity: "error",
+                        path: displayPath(ctx, entryPath),
+                        message: "httpChannel() configures the built-in HTTP channel and must be authored at channels/http.ts.",
+                    });
+                    continue;
+                }
+                httpChannelDefinition = mod.default;
+                continue;
+            }
+            if (kind !== "channel") {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: id === "http"
+                        ? "channels/http.ts must default-export httpChannel({ ... })."
+                        : "Channel modules must default-export defineChannel({ ... }).",
+                });
+                continue;
+            }
+            if (id === "http") {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, entryPath),
+                    message: "The channel id `http` is reserved for the built-in HTTP channel; use httpChannel() to configure it.",
+                });
+                continue;
+            }
+            channels.push({ id, definition: mod.default });
+        }
+        return { channels, httpChannelDefinition };
+    });
+}
+// ============================================================================
+// Schedules
+// ============================================================================
+function loadSchedules(ctx, schedulesDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield isDirectory(schedulesDir))) {
+            return [];
+        }
+        const schedules = [];
+        for (const filePath of yield walkFiles(schedulesDir)) {
+            const rel = toPosix(relative(schedulesDir, filePath));
+            if (rel.endsWith(".md")) {
+                const name = rel.slice(0, -".md".length);
+                const { data, body } = parseFrontmatter(yield readFile(filePath, "utf8"));
+                const cron = data.cron;
+                if (cron === undefined || !isValidCron(cron)) {
+                    ctx.diagnostics.push({
+                        severity: "error",
+                        path: displayPath(ctx, filePath),
+                        message: cron === undefined
+                            ? "Markdown schedules require `cron` frontmatter."
+                            : `Invalid cron expression: "${cron}".`,
+                    });
+                    continue;
+                }
+                const markdown = body.trim();
+                if (markdown === "") {
+                    ctx.diagnostics.push({
+                        severity: "error",
+                        path: displayPath(ctx, filePath),
+                        message: "Markdown schedules require a non-empty prompt body.",
+                    });
+                    continue;
+                }
+                schedules.push({
+                    name,
+                    cron,
+                    kind: "markdown",
+                    definition: {
+                        __agentServe: "schedule",
+                        cron,
+                        markdown,
+                    },
+                });
+                continue;
+            }
+            if (!isModuleFile(basename(filePath))) {
+                continue;
+            }
+            const name = rel.slice(0, -extname(rel).length);
+            const definition = yield importDefault(ctx, filePath, "schedule");
+            if (definition === undefined) {
+                continue;
+            }
+            const schedule = definition;
+            if ((schedule.markdown === undefined) === (schedule.run === undefined)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, filePath),
+                    message: "Schedules require exactly one of `markdown` or `run`.",
+                });
+                continue;
+            }
+            if (!isValidCron(schedule.cron)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, filePath),
+                    message: `Invalid cron expression: "${schedule.cron}".`,
+                });
+                continue;
+            }
+            schedules.push({
+                name,
+                cron: schedule.cron,
+                kind: schedule.run === undefined ? "markdown" : "run",
+                definition: schedule,
+            });
+        }
+        return schedules;
+    });
+}
+// ============================================================================
+// Hooks
+// ============================================================================
+function loadHooks(ctx, hooksDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield isDirectory(hooksDir))) {
+            return [];
+        }
+        const hooks = [];
+        for (const filePath of yield walkFiles(hooksDir)) {
+            if (!isModuleFile(basename(filePath))) {
+                continue;
+            }
+            const rel = toPosix(relative(hooksDir, filePath));
+            const name = rel.slice(0, -extname(rel).length);
+            const definition = yield importDefault(ctx, filePath, "hook");
+            if (definition === undefined) {
+                continue;
+            }
+            const hook = definition;
+            if (typeof hook.events !== "object" ||
+                hook.events === null ||
+                Object.keys(hook.events).length === 0) {
+                ctx.diagnostics.push({
+                    severity: "warning",
+                    path: displayPath(ctx, filePath),
+                    message: "Hook declares no event handlers.",
+                });
+                continue;
+            }
+            hooks.push({ name, definition: hook });
+        }
+        return hooks;
+    });
+}
+// ============================================================================
+// A/B metrics (agent/ab.ts or agent/ab/*.ts) + agent/ab.config.ts
+// ============================================================================
+function loadABs(ctx, agentDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const abs = [];
+        const seen = new Set();
+        const single = yield findModuleFile(agentDir, "ab");
+        if (single !== undefined) {
+            const definition = yield importDefault(ctx, single, "ab");
+            if (definition !== undefined) {
+                const name = resolveABName(definition, "ab");
+                seen.add(name);
+                abs.push({
+                    name,
+                    definition: definition,
+                });
+            }
+        }
+        const absDir = join(agentDir, "ab");
+        if (yield isDirectory(absDir)) {
+            for (const filePath of yield walkFiles(absDir)) {
+                if (!isModuleFile(basename(filePath))) {
+                    continue;
+                }
+                const rel = toPosix(relative(absDir, filePath));
+                const stem = rel.slice(0, -extname(rel).length);
+                const definition = yield importDefault(ctx, filePath, "ab");
+                if (definition === undefined) {
+                    continue;
+                }
+                const name = resolveABName(definition, stem);
+                if (seen.has(name)) {
+                    ctx.diagnostics.push({
+                        severity: "error",
+                        path: displayPath(ctx, filePath),
+                        message: `Duplicate A/B experiment name ${JSON.stringify(name)}.`,
+                    });
+                    continue;
+                }
+                seen.add(name);
+                abs.push({
+                    name,
+                    definition: definition,
+                });
+            }
+        }
+        return abs;
+    });
+}
+function loadABConfig(ctx, agentDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const path = yield findModuleFile(agentDir, "ab.config");
+        if (path === undefined) {
+            return undefined;
+        }
+        try {
+            const mod = yield ctx.importModule(path);
+            if (mod.default === null || typeof mod.default !== "object") {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, path),
+                    message: "ab.config.ts must default-export defineABConfig({ ... }) from @anysphere/agent-serve/ab.",
+                });
+                return undefined;
+            }
+            return mod.default;
+        }
+        catch (error) {
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, path),
+                message: `Failed to load ab.config: ${error instanceof Error ? error.message : String(error)}`,
+            });
+            return undefined;
+        }
+    });
+}
+function resolveABName(definition, fallback) {
+    if (typeof definition === "object" &&
+        definition !== null &&
+        "name" in definition &&
+        typeof definition.name === "string" &&
+        definition.name.length > 0) {
+        return definition.name;
+    }
+    return fallback;
+}
+// ============================================================================
+// Sandbox seed files
+// ============================================================================
+function loadSeedFiles(ctx, agentDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sandboxDir = join(agentDir, "sandbox");
+        for (const candidate of ["sandbox.ts", join("sandbox", "sandbox.ts")]) {
+            if (yield isFile(join(agentDir, candidate))) {
+                ctx.diagnostics.push({
+                    severity: "warning",
+                    path: displayPath(ctx, join(agentDir, candidate)),
+                    message: "Custom sandbox backends are not supported; the agent runs in the session workspace directory. Ignoring.",
+                });
+            }
+        }
+        const workspaceDir = join(sandboxDir, "workspace");
+        if (!(yield isDirectory(workspaceDir))) {
+            return [];
+        }
+        const seedFiles = [];
+        for (const filePath of yield walkFiles(workspaceDir)) {
+            seedFiles.push({
+                relativePath: toPosix(relative(workspaceDir, filePath)),
+                sourcePath: filePath,
+            });
+        }
+        return seedFiles;
+    });
+}
+// ============================================================================
+// Info projection
+// ============================================================================
+export function projectInfo(project) {
+    var _a, _b, _c;
+    const agent = project.agent;
+    const httpRoutes = [
+        { method: "POST", path: "/v1/session", url: "/v1/session" },
+        {
+            method: "POST",
+            path: "/v1/session/:sessionId",
+            url: "/v1/session/:sessionId",
+        },
+        {
+            method: "POST",
+            path: "/v1/session/:sessionId/stop",
+            url: "/v1/session/:sessionId/stop",
+        },
+        {
+            method: "GET",
+            path: "/v1/session/:sessionId/stream",
+            url: "/v1/session/:sessionId/stream",
+        },
+        {
+            method: "GET",
+            path: "/v1/session/:sessionId/approvals",
+            url: "/v1/session/:sessionId/approvals",
+        },
+        {
+            method: "POST",
+            path: "/v1/session/:sessionId/approvals/:callId",
+            url: "/v1/session/:sessionId/approvals/:callId",
+        },
+    ];
+    return Object.assign(Object.assign({ name: project.name, model: agent.model, runtime: agent.runtime, cloud: agent.cloud === undefined ? undefined : toPublicCloudInfo(agent.cloud), local: agent.local, mcp: { path: MCP_ENDPOINT_PATH, tools: mcpEndpointToolNames(project) }, instructions: agent.instructions === undefined
+            ? undefined
+            : {
+                chars: agent.instructions.length,
+                preview: agent.instructions.length > 280
+                    ? `${agent.instructions.slice(0, 277)}...`
+                    : agent.instructions,
+            }, tools: agent.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            execution: tool.execution,
+            needsApproval: tool.needsApproval,
+            inputSchema: tool.inputSchema,
+        })), skills: agent.skills.map((skill) => ({
+            name: skill.name,
+            description: skill.description,
+        })), connections: agent.connections.map((connection) => ({
+            name: connection.name,
+            transport: connectionTransportLabel(connection.transport),
+        })), subagents: agent.subagents.map((subagent) => ({
+            name: subagent.name,
+            description: subagent.description,
+            model: subagent.model,
+        })), channels: [
+            { id: "http", routes: httpRoutes },
+            ...project.channels.map((channel) => {
+                var _a;
+                const info = {
+                    id: channel.id,
+                    routes: ((_a = channel.definition.routes) !== null && _a !== void 0 ? _a : []).map((r) => {
+                        const routeInfo = {
+                            method: r.method,
+                            path: r.path,
+                            url: `/v1/channels/${channel.id}${r.path}`,
+                        };
+                        if (r.description !== undefined) {
+                            routeInfo.description = r.description;
+                        }
+                        if (r.bodySchema !== undefined) {
+                            routeInfo.bodySchema = toolInputJsonSchema(r.bodySchema);
+                        }
+                        if (r.querySchema !== undefined) {
+                            routeInfo.querySchema = toolInputJsonSchema(r.querySchema);
+                        }
+                        return routeInfo;
+                    }),
+                };
+                const meta = channel.definition.meta;
+                if ((meta === null || meta === void 0 ? void 0 : meta.kind) !== undefined) {
+                    info.kind = meta.kind;
+                }
+                if ((meta === null || meta === void 0 ? void 0 : meta.githubWebhookEvents) !== undefined) {
+                    info.githubWebhookEvents = meta.githubWebhookEvents;
+                }
+                if ((meta === null || meta === void 0 ? void 0 : meta.slackChannelPosts) !== undefined) {
+                    info.slackChannelPosts = meta.slackChannelPosts;
+                }
+                return info;
+            }),
+        ], schedules: project.schedules.map((schedule) => ({
+            name: schedule.name,
+            cron: schedule.cron,
+            kind: schedule.kind,
+        })), hooks: project.hooks.map((hook) => hook.name), abs: project.abs.map((experiment) => experiment.name) }, (project.abConfig === undefined && project.abs.length === 0
+        ? {}
+        : {
+            abConfig: {
+                maxPlaygroundSessions: resolveABMaxPlaygroundSessions((_a = project.abConfig) === null || _a === void 0 ? void 0 : _a.maxPlaygroundSessions),
+                durableSamples: ((_b = project.abConfig) === null || _b === void 0 ? void 0 : _b.persistSamples) !== undefined,
+                durableSnapshots: ((_c = project.abConfig) === null || _c === void 0 ? void 0 : _c.persistSnapshots) !== undefined,
+            },
+        })), { diagnostics: project.diagnostics });
+}
+// ============================================================================
+// Shared helpers
+// ============================================================================
+function importDefault(ctx, modulePath, expectedKind) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        let mod;
+        try {
+            mod = yield ctx.importModule(modulePath);
+        }
+        catch (error) {
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, modulePath),
+                message: `Failed to load module: ${errorMessage(error)}`,
+            });
+            return undefined;
+        }
+        const kind = getDefinitionKind(mod.default);
+        if (kind !== expectedKind) {
+            const helper = expectedKind === "ab"
+                ? "defineAB"
+                : `define${(_a = expectedKind[0]) === null || _a === void 0 ? void 0 : _a.toUpperCase()}${expectedKind.slice(1)}`;
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, modulePath),
+                message: kind === undefined
+                    ? `Module must default-export ${helper}({ ... }).`
+                    : `Expected a ${expectedKind} definition but found "${kind}" (wrong authored slot?).`,
+            });
+            return undefined;
+        }
+        return mod.default;
+    });
+}
+function warnUnknownSlots(ctx, agentDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const known = new Set([
+            "agent",
+            "instructions",
+            "tools",
+            "skills",
+            "mcp-connections",
+            // Legacy slot name; resolveMcpConnectionsDir warns and still loads it.
+            "connections",
+            "subagents",
+            "channels",
+            "schedules",
+            "hooks",
+            "ab",
+            "sandbox",
+            "lib",
+            // Vite playground custom tool chips (examples/*/agent/playground/tools).
+            "playground",
+        ]);
+        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 `agent/`.
+            if (entry.name === "evals") {
+                ctx.diagnostics.push({
+                    severity: "warning",
+                    path: displayPath(ctx, join(agentDir, entry.name)),
+                    message: 'Directory "evals" under agent/ 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 agent/ (not an authored slot; use lib/ for shared code).`,
+            });
+        }
+    });
+}
+function hasFlatLayoutMarkers(rootDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (yield isFile(join(rootDir, "instructions.md"))) {
+            return true;
+        }
+        return (yield findModuleFile(rootDir, "agent")) !== undefined;
+    });
+}
+function readPackageName(rootDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const packageJsonPath = join(rootDir, "package.json");
+        if (!(yield isFile(packageJsonPath))) {
+            return undefined;
+        }
+        try {
+            const parsed = JSON.parse(yield readFile(packageJsonPath, "utf8"));
+            if (typeof parsed.name === "string" && parsed.name !== "") {
+                return parsed.name;
+            }
+        }
+        catch (_a) {
+            // Malformed package.json falls back to the directory name.
+        }
+        return undefined;
+    });
+}
+function findModuleFile(dir, stem) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const extension of [".ts", ".mts", ".js", ".mjs"]) {
+            const candidate = join(dir, `${stem}${extension}`);
+            if (yield isFile(candidate)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    });
+}
+function isModuleFile(fileName) {
+    if (fileName.endsWith(".d.ts") || fileName.startsWith(".")) {
+        return false;
+    }
+    return MODULE_EXTENSIONS.has(extname(fileName));
+}
+function moduleStem(fileName) {
+    return fileName.slice(0, -extname(fileName).length);
+}
+function sortedEntries(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const entries = yield readdir(dir, { withFileTypes: true });
+        return entries.sort((a, b) => a.name.localeCompare(b.name));
+    });
+}
+function walkFiles(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const files = [];
+        for (const entry of yield sortedEntries(dir)) {
+            if (entry.name.startsWith(".")) {
+                continue;
+            }
+            const entryPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                files.push(...(yield walkFiles(entryPath)));
+            }
+            else if (entry.isFile()) {
+                files.push(entryPath);
+            }
+        }
+        return files;
+    });
+}
+function isDirectory(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return (yield stat(path)).isDirectory();
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+function isFile(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return (yield stat(path)).isFile();
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
+function isValidModelSetting(model) {
+    if (typeof model === "string") {
+        return model.trim() !== "";
+    }
+    return (typeof model === "object" &&
+        model !== null &&
+        typeof model.id === "string" &&
+        model.id.trim() !== "");
+}
+function isBlank(value) {
+    return typeof value !== "string" || value.trim() === "";
+}
+function toPosix(path) {
+    return path.split("\\").join("/");
+}
+function displayPath(ctx, absolutePath) {
+    const rel = relative(ctx.rootDir, absolutePath);
+    return rel.startsWith("..") ? absolutePath : toPosix(rel);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}