@cursor/july 0.1.101 → 0.1.103

package/dist/internal/discovery/project.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Project roots and mounts: find agents under a directory and load them into {@link AgentProject} manifests.
+ */
+import type { AgentProject, Diagnostic } from "../../types.js";
+import { type LoadAgentProjectOptions } from "./context.js";
+/**
+ * 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 declare function isAgentProjectDir(dir: string): Promise<boolean>;
+/** One immediate child agent directory under a multi-agent parent. */
+export interface ChildAgentDir {
+    slug: string;
+    dir: string;
+}
+/**
+ * List agent projects directly under `rootDir` (one level deep) without
+ * loading them. Empty when the path is missing or has no child agents.
+ * Slug rules match {@link loadAgentProjects} / multi-agent serve.
+ */
+export declare function listChildAgentDirs(rootDir: string): Promise<ChildAgentDir[]>;
+/**
+ * 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 declare function loadAgentProjects(rootDir: string, options?: LoadAgentProjectOptions): Promise<Array<{
+    slug: string;
+    project: AgentProject;
+}>>;
+/**
+ * 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 declare function resolveAgentMounts(rootDir: string, options?: LoadAgentProjectOptions & {
+    mode?: "single" | "multi";
+}): Promise<Array<{
+    slug: string;
+    project: AgentProject;
+}>>;
+export declare function loadAgentProject(dir: string, options?: LoadAgentProjectOptions): Promise<AgentProject>;
+/** True when the project has diagnostics that must block serving. */
+export declare function hasErrorDiagnostics(project: AgentProject): boolean;
+export declare function formatDiagnostics(diagnostics: Diagnostic[]): string;
+//# sourceMappingURL=project.d.ts.map

package/dist/internal/discovery/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../../src/internal/discovery/project.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EACV,YAAY,EAEZ,UAAU,EACX,MAAM,gBAAgB,CAAC;AASxB,OAAO,EAIL,KAAK,uBAAuB,EAC7B,MAAM,cAAc,CAAC;AAmBtB;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CASrE;AAED,sEAAsE;AACtE,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,aAAa,EAAE,CAAC,CA2B1B;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC,CA6BzD;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,uBAAuB,GAAG;IACjC,IAAI,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;CACtB,GACL,OAAO,CAAC,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC,CAgBzD;AAcD,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,YAAY,CAAC,CAmHvB;AA0BD,qEAAqE;AACrE,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAElE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,MAAM,CAOnE"}

package/dist/internal/discovery/project.js

@@ -0,0 +1,293 @@
+/**
+ * Project roots and mounts: find agents under a directory and load them into {@link AgentProject} manifests.
+ */
+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 { basename, join, resolve } from "node:path";
+import { httpChannel } from "../../channels.js";
+import { registerAuthoredModuleLoaders } from "../authored-loaders.js";
+import { applyAgentContinuationDefaults, warnOmittedContinuationDowngrades, } from "../continuation-channel.js";
+import { loadABConfig, loadABs } from "./ab.js";
+import { loadAgent, warnUnknownSlots } from "./agent.js";
+import { loadChannels } from "./channels.js";
+import { defaultImportModule, displayPath, } from "./context.js";
+import { hasFlatLayoutMarkers, isDirectory, readPackageName, sortedEntries, } from "./fs.js";
+import { loadHooks } from "./hooks.js";
+import { NAME_PATTERN } from "./names.js";
+import { loadSchedules } from "./schedules.js";
+import { appendArtifactTool, loadArtifacts, loadOtel, loadResult, loadStorage, mergeArtifacts, } from "./services.js";
+/**
+ * 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);
+    });
+}
+/**
+ * List agent projects directly under `rootDir` (one level deep) without
+ * loading them. Empty when the path is missing or has no child agents.
+ * Slug rules match {@link loadAgentProjects} / multi-agent serve.
+ */
+export function listChildAgentDirs(rootDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const resolved = resolve(rootDir);
+        if (!(yield isDirectory(resolved))) {
+            return [];
+        }
+        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, dir: childDir });
+        }
+        return results;
+    });
+}
+/**
+ * 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 children = yield listChildAgentDirs(resolved);
+        if (children.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).`);
+        }
+        const results = [];
+        // Storage namespaces (session mirror, host kv) key on the project
+        // NAME, not the mount slug — two co-hosted agents sharing a name would
+        // silently share sessions and KV state.
+        const slugByName = new Map();
+        for (const child of children) {
+            const project = yield loadAgentProject(child.dir, options);
+            const priorSlug = slugByName.get(project.name);
+            if (priorSlug !== undefined) {
+                throw new Error(`Duplicate agent name "${project.name}" under ${resolved}: agents "${priorSlug}" and "${child.slug}" both resolve to it (package.json "name", or the directory name when unset). Co-hosted agents must have distinct names — their storage and session namespaces key on the name.`);
+            }
+            slugByName.set(project.name, child.slug);
+            results.push({ slug: child.slug, project });
+        }
+        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. */
+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, projectSlots } = yield loadAgent(ctx, agentDir, {
+            name,
+            isRoot: true,
+        });
+        const { channels, httpChannelDefinition } = yield loadChannels(ctx, join(agentDir, "channels"));
+        for (const channel of projectSlots.channels) {
+            if (channel.id === "http" || channels.some((c) => c.id === channel.id)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, join(agentDir, "extensions")),
+                    message: `Extension channel "${channel.id}" collides with an agent channel.`,
+                });
+                continue;
+            }
+            channels.push(channel);
+        }
+        const schedules = yield loadSchedules(ctx, join(agentDir, "schedules"));
+        schedules.push(...projectSlots.schedules);
+        const hooks = yield loadHooks(ctx, join(agentDir, "hooks"));
+        hooks.push(...projectSlots.hooks);
+        const abs = yield loadABs(ctx, agentDir);
+        for (const experiment of projectSlots.abs) {
+            if (abs.some((existing) => existing.name === experiment.name)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, join(agentDir, "extensions")),
+                    message: `Extension A/B experiment "${experiment.name}" collides with an agent experiment.`,
+                });
+                continue;
+            }
+            abs.push(experiment);
+        }
+        const abConfig = yield loadABConfig(ctx, agentDir);
+        const storage = yield loadStorage(ctx, agentDir, agent.architecture);
+        const artifacts = yield mergeProjectArtifacts(ctx, agentDir, projectSlots.artifacts);
+        const otel = yield loadOtel(ctx, agentDir);
+        const result = yield loadResult(ctx, agentDir);
+        yield appendArtifactTool(ctx, agentDir, agent, artifacts);
+        if (agentDir !== rootDir) {
+            yield warnUnknownSlots(ctx, agentDir);
+        }
+        const resolvedHttpChannel = httpChannelDefinition !== null && httpChannelDefinition !== void 0 ? httpChannelDefinition : httpChannel();
+        warnOmittedContinuationDowngrades({
+            architecture: agent.architecture,
+            channels,
+            warn: (id, message) => {
+                ctx.diagnostics.push({
+                    severity: "warning",
+                    path: displayPath(ctx, join(agentDir, "channels", `${id}.ts`)),
+                    message,
+                });
+            },
+        });
+        applyAgentContinuationDefaults({
+            agent,
+            channels,
+            httpChannel: resolvedHttpChannel,
+        });
+        return {
+            rootDir,
+            agentDir,
+            name: agent.name,
+            agent,
+            httpChannel: resolvedHttpChannel,
+            channels,
+            schedules,
+            hooks,
+            abs,
+            abConfig,
+            storage,
+            artifacts,
+            result,
+            otel,
+            diagnostics,
+        };
+    });
+}
+function mergeProjectArtifacts(ctx, agentDir, extra) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const agent = yield loadArtifacts(ctx, agentDir);
+        if (extra === undefined) {
+            return agent;
+        }
+        const kinds = Object.assign({}, extra.kinds);
+        const agentKinds = agent === null || agent === void 0 ? void 0 : agent.kinds;
+        for (const kind of Object.keys(kinds)) {
+            if (agentKinds !== undefined && kind in agentKinds) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, join(agentDir, "extensions")),
+                    message: `Extension artifact kind "${kind}" collides with an agent kind.`,
+                });
+                delete kinds[kind];
+            }
+        }
+        return mergeArtifacts(agent, Object.assign(Object.assign({}, extra), { kinds }));
+    });
+}
+/** 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");
+}

package/dist/internal/discovery/runtime.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Runtime resolution and the limitations each runtime imposes on the authored surface.
+ */
+import type { AgentRuntime } from "../../types.js";
+import { type DiscoveryContext } from "./context.js";
+/**
+ * Validate the authored runtime. An unrecognized value is an error
+ * diagnostic and falls back to local — a typo must not silently pick a
+ * different harness for every turn.
+ */
+export declare function resolveRuntime(ctx: DiscoveryContext, agentDir: string, runtime: AgentRuntime | undefined): AgentRuntime;
+/**
+ * Grok Bot turns run on the Sand harness with its own toolset: authored
+ * server tools, MCP connections, and subagents have no path onto that
+ * toolset yet, so an agent declaring them must fail at serve start rather
+ * than run with capabilities silently missing.
+ */
+export declare function checkGrokBotRuntimeLimitations(ctx: DiscoveryContext, agentDir: string, counts: {
+    serverTools: number;
+    agentTools: number;
+    skills: number;
+    seedFiles: number;
+    connections: number;
+    subagents: number;
+    hasCloudOptions: boolean;
+    hasLocalSandbox: boolean;
+}): void;
+export declare function warnCloudRuntimeLimitations(ctx: DiscoveryContext, agentDir: string, counts: {
+    agentTools: number;
+    skills: number;
+    seedFiles: number;
+    hasCloudOptions: boolean;
+}): void;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/internal/discovery/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/internal/discovery/runtime.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,cAAc,CAAC;AAElE;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,gBAAgB,EACrB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,YAAY,GAAG,SAAS,GAChC,YAAY,CAed;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,gBAAgB,EACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE;IACN,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;CAC1B,GACA,IAAI,CA2DN;AAED,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,gBAAgB,EACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE;IACN,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,OAAO,CAAC;CAC1B,GACA,IAAI,CAkCN"}

package/dist/internal/discovery/runtime.js

@@ -0,0 +1,97 @@
+/**
+ * Runtime resolution and the limitations each runtime imposes on the authored surface.
+ */
+import { join } from "node:path";
+import { displayPath } from "./context.js";
+/**
+ * Validate the authored runtime. An unrecognized value is an error
+ * diagnostic and falls back to local — a typo must not silently pick a
+ * different harness for every turn.
+ */
+export function resolveRuntime(ctx, agentDir, runtime) {
+    if (runtime === undefined ||
+        runtime === "local" ||
+        runtime === "cloud" ||
+        runtime === "grokbot") {
+        return runtime !== null && runtime !== void 0 ? runtime : "local";
+    }
+    ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, join(agentDir, "agent.ts")),
+        message: `runtime must be "local", "cloud", or "grokbot"; got ${JSON.stringify(runtime)}.`,
+    });
+    return "local";
+}
+/**
+ * Grok Bot turns run on the Sand harness with its own toolset: authored
+ * server tools, MCP connections, and subagents have no path onto that
+ * toolset yet, so an agent declaring them must fail at serve start rather
+ * than run with capabilities silently missing.
+ */
+export function checkGrokBotRuntimeLimitations(ctx, agentDir, counts) {
+    const agentPath = displayPath(ctx, join(agentDir, "agent.ts"));
+    const error = (path, message) => {
+        ctx.diagnostics.push({ severity: "error", path, message });
+    };
+    const warn = (path, message) => {
+        ctx.diagnostics.push({ severity: "warning", path, message });
+    };
+    if (counts.serverTools > 0) {
+        error(displayPath(ctx, join(agentDir, "tools")), 'Server tools (execution: "server", including opted-in builtinTools) are not reachable from grokbot turns yet. Remove them or run the agent on the local runtime.');
+    }
+    if (counts.connections > 0) {
+        error(displayPath(ctx, agentDir), "MCP connections (agent/mcp-connections/ or agent/host-connections/) are not wired into grokbot turns yet. Remove them or run the agent on the local runtime.");
+    }
+    if (counts.subagents > 0) {
+        error(displayPath(ctx, join(agentDir, "subagents")), "Authored subagents are not available on grokbot turns (the Grok Bot harness runs its own subagent set). Remove them or run the agent on the local runtime.");
+    }
+    // The remaining declarations mirror the cloud runtime's warnings: the
+    // turn runs on a hosted machine (the account's box), so local-workspace
+    // materialization never reaches it.
+    if (counts.agentTools > 0) {
+        warn(displayPath(ctx, join(agentDir, "tools")), 'Agent tools (execution: "agent") are described in the hosted session\'s instructions (with script bodies); they are not written onto the box filesystem automatically.');
+    }
+    if (counts.skills > 0) {
+        warn(displayPath(ctx, join(agentDir, "skills")), "Authored skills are materialized into the local session workspace only; the hosted Grok Bot box does not see them.");
+    }
+    if (counts.seedFiles > 0) {
+        warn(displayPath(ctx, join(agentDir, "sandbox")), "sandbox/workspace seed files apply to the local session workspace only; grokbot turns run on the account's hosted box.");
+    }
+    if (counts.hasCloudOptions) {
+        warn(agentPath, 'The `cloud` block is unused on runtime: "grokbot", and grokbot sessions refuse per-session cloud attach.');
+    }
+    if (counts.hasLocalSandbox) {
+        warn(agentPath, 'local.sandbox does not apply to runtime: "grokbot"; the box is the account\'s Cursor-hosted computer.');
+    }
+}
+export 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.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 reach cloud agents through native store discovery: hosted deployments write the deployment store's skills/ directory; local serve/run with a personal API key writes agent-serve/<agent>/skills/ on the USER store. Without a reachable store, only skills already in the cloud repo are visible.",
+        });
+    }
+    if (counts.seedFiles > 0) {
+        ctx.diagnostics.push({
+            severity: "warning",
+            path: displayPath(ctx, join(agentDir, "sandbox")),
+            message: "sandbox/workspace seed files reach cloud agents through the Agent Store, not the checkout: hosted deployments write the deployment store's workspace/ directory; local serve/run with a personal API key writes agent-serve/<agent>/workspace/ on the USER store. The first cloud prompt names the mounted directory. Without a reachable store, cloud turns do not see them.",
+        });
+    }
+}

package/dist/internal/discovery/schedules.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `agent/schedules/*.ts`: cron-driven runs.
+ */
+import type { DiscoveredSchedule } from "../../types.js";
+import { type DiscoveryContext } from "./context.js";
+export declare function loadSchedules(ctx: DiscoveryContext, schedulesDir: string, onDisable?: (name: string, path: string) => void): Promise<DiscoveredSchedule[]>;
+//# sourceMappingURL=schedules.d.ts.map

package/dist/internal/discovery/schedules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedules.d.ts","sourceRoot":"","sources":["../../../src/internal/discovery/schedules.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,kBAAkB,EAAsB,MAAM,gBAAgB,CAAC;AAI7E,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,cAAc,CAAC;AAIlE,wBAAsB,aAAa,CACjC,GAAG,EAAE,gBAAgB,EACrB,YAAY,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,GAC/C,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAqG/B"}

package/dist/internal/discovery/schedules.js

@@ -0,0 +1,118 @@
+/**
+ * `agent/schedules/*.ts`: cron-driven runs.
+ */
+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 { readFile } from "node:fs/promises";
+import { basename, extname, relative } from "node:path";
+import { getDefinitionKind } from "../brand.js";
+import { isValidCron } from "../cron.js";
+import { parseFrontmatter } from "../frontmatter.js";
+import { displayPath } from "./context.js";
+import { isDirectory, isModuleFile, toPosix, walkFiles } from "./fs.js";
+import { importDefault } from "./modules.js";
+export function loadSchedules(ctx, schedulesDir, onDisable) {
+    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);
+                if (name.includes("__")) {
+                    ctx.diagnostics.push({
+                        severity: "error",
+                        path: displayPath(ctx, filePath),
+                        message: `Schedule name "${name}" may not contain "__"; it is reserved for extension contributions (\`<ns>__<name>\`).`,
+                    });
+                    continue;
+                }
+                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);
+            if (name.includes("__")) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, filePath),
+                    message: `Schedule name "${name}" may not contain "__"; it is reserved for extension contributions (\`<ns>__<name>\`).`,
+                });
+                continue;
+            }
+            const definition = yield importDefault(ctx, filePath, onDisable === undefined ? "schedule" : ["schedule", "disabled"]);
+            if (definition === undefined) {
+                continue;
+            }
+            if (getDefinitionKind(definition) === "disabled") {
+                onDisable === null || onDisable === void 0 ? void 0 : onDisable(name, filePath);
+                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;
+    });
+}

package/dist/internal/discovery/seed-files.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `agent/sandbox/workspace/**`: files seeded into each local session workspace.
+ */
+import type { SeedFile } from "../../types.js";
+import { type DiscoveryContext } from "./context.js";
+export declare function loadSeedFiles(ctx: DiscoveryContext, agentDir: string): Promise<SeedFile[]>;
+//# sourceMappingURL=seed-files.d.ts.map

package/dist/internal/discovery/seed-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed-files.d.ts","sourceRoot":"","sources":["../../../src/internal/discovery/seed-files.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,cAAc,CAAC;AAGlE,wBAAsB,aAAa,CACjC,GAAG,EAAE,gBAAgB,EACrB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,QAAQ,EAAE,CAAC,CAwBrB"}