@cursor/july 0.1.101 → 0.1.103

package/dist/internal/discovery/extension-overlay.js

@@ -0,0 +1,191 @@
+/**
+ * Directory-mount overlays: a same-named file replaces, disable() removes.
+ * Slot loaders do the walk; this file only applies replace/disable.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { join } from "node:path";
+import { getDefinitionKind } from "../brand.js";
+import { loadABs } from "./ab.js";
+import { loadChannels } from "./channels.js";
+import { displayPath, errorMessage } from "./context.js";
+import { findModuleFile, isDirectory, isFile, isModuleFile, moduleStem, sortedEntries, } from "./fs.js";
+import { loadHooks } from "./hooks.js";
+import { loadInstructions } from "./instructions.js";
+import { importDefault } from "./modules.js";
+import { loadSchedules } from "./schedules.js";
+import { loadSkills } from "./skills.js";
+import { loadSubagents } from "./subagent.js";
+export function overlaySlot(ctx, site, contributed, entries, slot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const { name, path } of entries) {
+            const definition = yield importDefault(ctx, path, [
+                slot.kind,
+                slot.disabledKind,
+                "disabled",
+            ]);
+            if (definition === undefined) {
+                continue;
+            }
+            const kind = getDefinitionKind(definition);
+            if (kind === slot.disabledKind || kind === "disabled") {
+                contributed.delete(name);
+                if (!slot.declared.has(name)) {
+                    unknownContribution(ctx, path, slot.disableHelper, name, site.ns);
+                }
+                continue;
+            }
+            const item = yield slot.compile(ctx, path, name, definition);
+            if (item !== undefined) {
+                contributed.set(name, item);
+            }
+        }
+    });
+}
+export function overlaySkills(ctx, site, contributed, dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield overlayNamed(ctx, site, contributed, dir, "disableSkill", (onDisable) => loadSkills(ctx, dir, onDisable));
+    });
+}
+export function overlayHooks(ctx, site, contributed, dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield overlayNamed(ctx, site, contributed, dir, "disableHook", (onDisable) => loadHooks(ctx, dir, onDisable));
+    });
+}
+export function overlaySchedules(ctx, site, contributed, dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield overlayNamed(ctx, site, contributed, dir, "disableSchedule", (onDisable) => loadSchedules(ctx, dir, onDisable));
+    });
+}
+export function overlayChannels(ctx, site, contributed, dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield isDirectory(dir))) {
+            return;
+        }
+        const declared = new Set(contributed.keys());
+        const { channels } = yield loadChannels(ctx, dir, "extension", (id, path) => {
+            contributed.delete(id);
+            if (!declared.has(id)) {
+                unknownContribution(ctx, path, "disableChannel", id, site.ns);
+            }
+        });
+        for (const channel of channels) {
+            contributed.set(channel.id, channel);
+        }
+    });
+}
+export function overlaySubagents(ctx, site, contributed, dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield isDirectory(dir))) {
+            return;
+        }
+        const declared = new Set(contributed.keys());
+        for (const child of yield loadSubagents(ctx, dir)) {
+            contributed.set(child.name, child);
+        }
+        for (const entry of yield sortedEntries(dir)) {
+            const path = join(dir, entry.name);
+            if (!entry.isFile() || !isModuleFile(entry.name)) {
+                continue;
+            }
+            const name = moduleStem(entry.name);
+            const definition = yield importDefault(ctx, path, ["disabled"]);
+            if (definition === undefined) {
+                continue;
+            }
+            contributed.delete(name);
+            if (!declared.has(name)) {
+                unknownContribution(ctx, path, "disableSubagent", name, site.ns);
+            }
+        }
+    });
+}
+export function overlayInstructionsFragment(ctx, overlayDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const markdownPath = join(overlayDir, "instructions.md");
+        const modulePath = yield findModuleFile(overlayDir, "instructions");
+        const instructionsDir = join(overlayDir, "instructions");
+        if (!(yield isFile(markdownPath)) &&
+            modulePath === undefined &&
+            !(yield isDirectory(instructionsDir))) {
+            return "keep";
+        }
+        if (modulePath !== undefined) {
+            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 "keep";
+            }
+            if (getDefinitionKind(mod.default) === "disabled") {
+                return undefined;
+            }
+        }
+        return loadInstructions(ctx, overlayDir, undefined, false);
+    });
+}
+export function overlayAbs(ctx, site, contributed, overlayDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const loaded = yield loadABs(ctx, overlayDir, (source, path) => {
+            if (!contributed.delete(source)) {
+                unknownContribution(ctx, path, "disableAB", source, site.ns);
+            }
+        });
+        for (const experiment of loaded) {
+            contributed.set((_a = experiment.source) !== null && _a !== void 0 ? _a : experiment.name, experiment);
+        }
+    });
+}
+export function overlayArtifacts(ctx, overlayDir, current) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const path = yield findModuleFile(overlayDir, "artifacts");
+        if (path === undefined) {
+            return current;
+        }
+        const definition = yield importDefault(ctx, path, ["artifacts", "disabled"]);
+        if (definition === undefined) {
+            return current;
+        }
+        if (getDefinitionKind(definition) === "disabled") {
+            return undefined;
+        }
+        return definition;
+    });
+}
+function overlayNamed(ctx, site, contributed, dir, helper, load) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield isDirectory(dir))) {
+            return;
+        }
+        const declared = new Set(contributed.keys());
+        for (const item of yield load((name, path) => {
+            contributed.delete(name);
+            if (!declared.has(name)) {
+                unknownContribution(ctx, path, helper, name, site.ns);
+            }
+        })) {
+            contributed.set(item.name, item);
+        }
+    });
+}
+function unknownContribution(ctx, path, helper, name, ns) {
+    ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, path),
+        message: `${helper}() targets "${name}", which extension "${ns}" does not contribute.`,
+    });
+}

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

@@ -0,0 +1,28 @@
+/**
+ * `agent/extensions/<ns>.ts` | `agent/extensions/<ns>/extension.ts`:
+ * agent-shaped trees and Cursor plugins mounted under a namespace.
+ */
+import type { ArtifactsDefinition, DiscoveredAB, DiscoveredChannel, DiscoveredConnection, DiscoveredExtension, DiscoveredHook, DiscoveredSchedule, DiscoveredSkill, DiscoveredTool, ResolvedAgent, SeedFile } from "../../types.js";
+import { type DiscoveryContext } from "./context.js";
+/** The agent's authored slot lists that mounted extensions append to. */
+export interface ExtensionContributions {
+    tools: DiscoveredTool[];
+    skills: DiscoveredSkill[];
+    connections: DiscoveredConnection[];
+    hostConnections: DiscoveredConnection[];
+    subagents: ResolvedAgent[];
+    hooks: DiscoveredHook[];
+    channels: DiscoveredChannel[];
+    schedules: DiscoveredSchedule[];
+    instructionParts: string[];
+    seedFiles: SeedFile[];
+    abs: DiscoveredAB[];
+    artifacts: ArtifactsDefinition | undefined;
+}
+/**
+ * Mount every extension under `agent/extensions/` and append what it
+ * contributes to the authored lists as `<ns>__<name>`, stamped with
+ * `extension`. The namespace is the mount's filename stem or directory name.
+ */
+export declare function appendExtensions(ctx: DiscoveryContext, extensionsDir: string, into: ExtensionContributions): Promise<DiscoveredExtension[]>;
+//# sourceMappingURL=extensions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../../../src/internal/discovery/extensions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EACV,mBAAmB,EAEnB,YAAY,EACZ,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,kBAAkB,EAClB,eAAe,EACf,cAAc,EAEd,aAAa,EACb,QAAQ,EAET,MAAM,gBAAgB,CAAC;AAUxB,OAAO,EAAE,KAAK,gBAAgB,EAAe,MAAM,cAAc,CAAC;AAgClE,yEAAyE;AACzE,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,WAAW,EAAE,oBAAoB,EAAE,CAAC;IACpC,eAAe,EAAE,oBAAoB,EAAE,CAAC;IACxC,SAAS,EAAE,aAAa,EAAE,CAAC;IAC3B,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAC9B,SAAS,EAAE,kBAAkB,EAAE,CAAC;IAChC,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,GAAG,EAAE,YAAY,EAAE,CAAC;IACpB,SAAS,EAAE,mBAAmB,GAAG,SAAS,CAAC;CAC5C;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,gBAAgB,EACrB,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,sBAAsB,GAC3B,OAAO,CAAC,mBAAmB,EAAE,CAAC,CA4BhC"}

package/dist/internal/discovery/extensions.js

@@ -0,0 +1,375 @@
+/**
+ * `agent/extensions/<ns>.ts` | `agent/extensions/<ns>/extension.ts`:
+ * agent-shaped trees and Cursor plugins mounted under a namespace.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { join, resolve } from "node:path";
+import { buildIdentityPreamble, withIdentityPreamble } from "../workspace.js";
+import { loadABs } from "./ab.js";
+import { loadChannels } from "./channels.js";
+import { compileConnection, compileHostConnection, loadConnections, loadHostConnections, } from "./connections.js";
+import { displayPath } from "./context.js";
+import { readCursorPlugin } from "./cursor-plugin.js";
+import { overlayAbs, overlayArtifacts, overlayChannels, overlayHooks, overlayInstructionsFragment, overlaySchedules, overlaySkills, overlaySlot, overlaySubagents, } from "./extension-overlay.js";
+import { findModuleFile, isDirectory, isFile, isModuleFile, moduleStem, sortedEntries, } from "./fs.js";
+import { loadHooks } from "./hooks.js";
+import { loadInstructions } from "./instructions.js";
+import { importDefault, moduleEntries } from "./modules.js";
+import { validateName } from "./names.js";
+import { loadSchedules } from "./schedules.js";
+import { loadSeedFiles } from "./seed-files.js";
+import { loadArtifacts, mergeArtifacts } from "./services.js";
+import { loadSkills } from "./skills.js";
+import { loadSubagents, subagent } from "./subagent.js";
+import { compileTool, loadTools } from "./tools.js";
+/**
+ * Mount every extension under `agent/extensions/` and append what it
+ * contributes to the authored lists as `<ns>__<name>`, stamped with
+ * `extension`. The namespace is the mount's filename stem or directory name.
+ */
+export function appendExtensions(ctx, extensionsDir, into) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield isDirectory(extensionsDir))) {
+            return [];
+        }
+        const extensions = [];
+        for (const entry of yield sortedEntries(extensionsDir)) {
+            const path = join(extensionsDir, entry.name);
+            const site = yield resolveMountSite(ctx, path, entry);
+            if (site === undefined) {
+                continue;
+            }
+            if (extensions.some((extension) => extension.name === site.ns)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, path),
+                    message: `Extension "${site.ns}" is mounted twice (as a file and as a directory).`,
+                });
+                continue;
+            }
+            const mount = yield importDefault(ctx, site.mountPath, "extension");
+            if (mount === undefined) {
+                continue;
+            }
+            extensions.push(yield mountExtension(ctx, site, mount, into));
+        }
+        return extensions;
+    });
+}
+function resolveMountSite(ctx, path, entry) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (entry.isDirectory()) {
+            if (!validateName(ctx, "extension", entry.name, path)) {
+                return undefined;
+            }
+            const mountPath = yield findModuleFile(path, "extension");
+            if (mountPath === undefined) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, path),
+                    message: "A directory mount needs an extension.ts default-exporting the mount (`export default ci({ ... })`).",
+                });
+                return undefined;
+            }
+            return { ns: entry.name, mountPath, overlayDir: path };
+        }
+        if (!entry.isFile() || !isModuleFile(entry.name)) {
+            return undefined;
+        }
+        const ns = moduleStem(entry.name);
+        return validateName(ctx, "extension", ns, path)
+            ? { ns, mountPath: path }
+            : undefined;
+    });
+}
+function emptyDiscovered(ns, description) {
+    return {
+        name: ns,
+        description,
+        tools: [],
+        skills: [],
+        connections: [],
+        hostConnections: [],
+        subagents: [],
+        hooks: [],
+        channels: [],
+        schedules: [],
+        instructions: false,
+        seedFiles: [],
+        abs: [],
+        artifactKinds: [],
+    };
+}
+/**
+ * Read the extension's tree, lay the mount's overlay on top (a same-named
+ * file replaces, `disable()` / `disableTool()` removes), then namespace
+ * what is left.
+ */
+function mountExtension(ctx, site, mount, into) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const mounted = emptyDiscovered(site.ns, mount.extension.description);
+        const root = resolve(ctx.rootDir, mount.extension.root);
+        if (!(yield isDirectory(root))) {
+            const hint = "layout" in mount.extension
+                ? "Point `path` at the plugin directory."
+                : "Pass `import.meta.dirname` from extension.ts.";
+            ctx.diagnostics.push({
+                severity: "error",
+                path: displayPath(ctx, site.mountPath),
+                message: `Extension "${site.ns}" declares root ${root}, which is not a directory. ${hint}`,
+            });
+            return mounted;
+        }
+        const tree = yield readExtensionTree(ctx, site, mount, root);
+        if (tree === undefined) {
+            return mounted;
+        }
+        mounted.description = (_a = mount.extension.description) !== null && _a !== void 0 ? _a : tree.description;
+        const tools = byName(tree.tools);
+        const skills = byName(tree.skills);
+        const connections = byName(tree.connections);
+        const hostConnections = byName(tree.hostConnections);
+        const hooks = byName(tree.hooks);
+        const channels = byId(tree.channels);
+        const schedules = byName(tree.schedules);
+        const subagents = byName(tree.subagents);
+        for (const agent of tree.agents) {
+            subagents.set(agent.name, subagent(agent.name, agent));
+        }
+        const seedFiles = new Map(tree.seedFiles.map((seed) => [seed.relativePath, seed]));
+        const abs = byAbSource(tree.abs);
+        let artifacts = tree.artifacts;
+        let instructions = tree.instructions;
+        if (site.overlayDir !== undefined) {
+            const connectionOverlay = yield moduleEntries(ctx, join(site.overlayDir, "mcp-connections"), "connection");
+            yield overlaySlot(ctx, site, tools, yield moduleEntries(ctx, join(site.overlayDir, "tools"), "tool"), {
+                kind: "tool",
+                disabledKind: "disabled-tool",
+                disableHelper: "disableTool",
+                declared: new Set(tools.keys()),
+                compile: (ctx, path, name, definition) => compileTool(ctx, path, name, definition),
+            });
+            yield overlaySlot(ctx, site, connections, connectionOverlay, {
+                kind: "connection",
+                disabledKind: "disabled-connection",
+                disableHelper: "disableConnection",
+                declared: new Set([...connections.keys(), ...tree.overlaidServers]),
+                compile: (ctx, path, name, definition) => compileConnection(ctx, path, name, definition, "model"),
+            });
+            yield overlaySlot(ctx, site, hostConnections, yield moduleEntries(ctx, join(site.overlayDir, "host-connections"), "connection"), {
+                kind: "connection",
+                disabledKind: "disabled-connection",
+                disableHelper: "disableConnection",
+                declared: new Set(hostConnections.keys()),
+                compile: (ctx, path, name, definition) => compileHostConnection(ctx, path, name, definition),
+            });
+            yield overlaySkills(ctx, site, skills, join(site.overlayDir, "skills"));
+            yield overlayHooks(ctx, site, hooks, join(site.overlayDir, "hooks"));
+            yield overlayChannels(ctx, site, channels, join(site.overlayDir, "channels"));
+            yield overlaySchedules(ctx, site, schedules, join(site.overlayDir, "schedules"));
+            yield overlaySubagents(ctx, site, subagents, join(site.overlayDir, "subagents"));
+            const overlayInstructions = yield overlayInstructionsFragment(ctx, site.overlayDir);
+            if (overlayInstructions !== "keep") {
+                instructions = overlayInstructions;
+            }
+            for (const seed of yield loadSeedFiles(ctx, site.overlayDir)) {
+                seedFiles.set(seed.relativePath, seed);
+            }
+            yield overlayAbs(ctx, site, abs, site.overlayDir);
+            artifacts = yield overlayArtifacts(ctx, site.overlayDir, artifacts);
+        }
+        for (const [name, tool] of tools) {
+            const composed = `${site.ns}__${name}`;
+            into.tools.push(Object.assign(Object.assign({}, tool), { name: composed, extension: site.ns }));
+            mounted.tools.push(composed);
+        }
+        for (const [name, skill] of skills) {
+            const composed = `${site.ns}__${name}`;
+            into.skills.push(Object.assign(Object.assign({}, skill), { name: composed, extension: site.ns }));
+            mounted.skills.push(composed);
+        }
+        const modelNames = new Set();
+        for (const [name, connection] of connections) {
+            const composed = `${site.ns}__${name}`;
+            modelNames.add(composed);
+            into.connections.push(Object.assign(Object.assign({}, connection), { name: composed }));
+            mounted.connections.push(composed);
+        }
+        for (const [name, connection] of hostConnections) {
+            const composed = `${site.ns}__${name}`;
+            if (modelNames.has(composed)) {
+                ctx.diagnostics.push({
+                    severity: "error",
+                    path: displayPath(ctx, join(root, "host-connections", `${name}.ts`)),
+                    message: `Host connection "${composed}" collides with MCP connection "${composed}". Rename one of them.`,
+                });
+                continue;
+            }
+            into.hostConnections.push(Object.assign(Object.assign({}, connection), { name: composed }));
+            mounted.hostConnections.push(composed);
+        }
+        for (const [name, child] of subagents) {
+            const composed = `${site.ns}__${name}`;
+            into.subagents.push(namespaceSubagent(composed, child));
+            mounted.subagents.push(composed);
+        }
+        for (const [name, hook] of hooks) {
+            const composed = `${site.ns}__${name}`;
+            into.hooks.push(Object.assign(Object.assign({}, hook), { name: composed }));
+            mounted.hooks.push(composed);
+        }
+        for (const [id, channel] of channels) {
+            const composed = `${site.ns}__${id}`;
+            into.channels.push(Object.assign(Object.assign({}, channel), { id: composed }));
+            mounted.channels.push(composed);
+        }
+        for (const [name, schedule] of schedules) {
+            const composed = `${site.ns}__${name}`;
+            into.schedules.push(Object.assign(Object.assign({}, schedule), { name: composed }));
+            mounted.schedules.push(composed);
+        }
+        if (instructions !== undefined && instructions !== "") {
+            into.instructionParts.push(instructions);
+            mounted.instructions = true;
+        }
+        for (const seed of seedFiles.values()) {
+            if (into.seedFiles.some((existing) => existing.relativePath === seed.relativePath)) {
+                ctx.diagnostics.push({
+                    severity: "warning",
+                    path: displayPath(ctx, seed.sourcePath),
+                    message: `Extension seed "${seed.relativePath}" collides with an existing workspace seed; keeping the first.`,
+                });
+                continue;
+            }
+            into.seedFiles.push(seed);
+            mounted.seedFiles.push(seed.relativePath);
+        }
+        for (const experiment of abs.values()) {
+            const composed = `${site.ns}__${experiment.name}`;
+            into.abs.push({
+                name: composed,
+                definition: experiment.definition,
+            });
+            mounted.abs.push(composed);
+        }
+        if (artifacts !== undefined) {
+            const kinds = {};
+            for (const [kind, config] of Object.entries((_b = artifacts.kinds) !== null && _b !== void 0 ? _b : {})) {
+                const composed = `${site.ns}__${kind}`;
+                kinds[composed] = config;
+                mounted.artifactKinds.push(composed);
+            }
+            into.artifacts = mergeArtifacts(into.artifacts, Object.assign(Object.assign({}, artifacts), { kinds }));
+        }
+        return mounted;
+    });
+}
+function readExtensionTree(ctx, site, mount, root) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if ("layout" in mount.extension) {
+            const connectionOverlay = site.overlayDir === undefined
+                ? []
+                : yield moduleEntries(ctx, join(site.overlayDir, "mcp-connections"), "connection");
+            const plugin = yield readCursorPlugin(ctx, root, site.mountPath, mount.extension.variables, new Set(connectionOverlay.map((entry) => entry.name)));
+            if (plugin === undefined) {
+                return undefined;
+            }
+            return Object.assign(Object.assign({}, plugin), { tools: [], hostConnections: [], subagents: [], hooks: [], channels: [], schedules: [], seedFiles: [], abs: [] });
+        }
+        return readNativeTree(ctx, root);
+    });
+}
+function readNativeTree(ctx, root) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield warnAgentRootOnlySlots(ctx, root);
+        const connections = yield loadConnections(ctx, join(root, "mcp-connections"));
+        return {
+            tools: yield loadTools(ctx, join(root, "tools")),
+            skills: yield loadSkills(ctx, join(root, "skills")),
+            connections,
+            hostConnections: yield loadHostConnections(ctx, root, connections),
+            overlaidServers: [],
+            agents: [],
+            subagents: yield loadSubagents(ctx, join(root, "subagents")),
+            hooks: yield loadHooks(ctx, join(root, "hooks")),
+            channels: (yield loadChannels(ctx, join(root, "channels"), "extension"))
+                .channels,
+            schedules: yield loadSchedules(ctx, join(root, "schedules")),
+            instructions: yield loadInstructions(ctx, root, undefined, false),
+            seedFiles: yield loadSeedFiles(ctx, root),
+            abs: yield loadABs(ctx, root),
+            artifacts: yield loadArtifacts(ctx, root),
+        };
+    });
+}
+function namespaceSubagent(composed, child) {
+    const oldPreamble = buildIdentityPreamble(child.name);
+    let body = child.instructions;
+    if (body !== undefined &&
+        oldPreamble !== "" &&
+        body.startsWith(oldPreamble)) {
+        body = body.slice(oldPreamble.length).replace(/^\n+/, "");
+    }
+    return Object.assign(Object.assign({}, child), { name: composed, instructions: withIdentityPreamble(composed, body) });
+}
+function byName(items) {
+    return new Map(items.map((item) => [item.name, item]));
+}
+function byAbSource(items) {
+    return new Map(items.map((item) => { var _a; return [(_a = item.source) !== null && _a !== void 0 ? _a : item.name, item]; }));
+}
+function byId(items) {
+    return new Map(items.map((item) => [item.id, item]));
+}
+/**
+ * Agent-singleton slots: one runtime (`agent.ts`), one storage backend,
+ * one OTLP exporter, one A/B platform config. Playground chips are a
+ * Vite glob of the agent tree, not a discovery walk. Nested
+ * `extensions/` are not mounted.
+ */
+function warnAgentRootOnlySlots(ctx, root) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const files = [
+            ["agent.ts", "agent.ts"],
+            ["storage.ts", "storage"],
+            ["otel.ts", "otel"],
+            ["ab.config.ts", "A/B config"],
+        ];
+        for (const [file, label] of files) {
+            const path = join(root, file);
+            if (yield isFile(path)) {
+                ctx.diagnostics.push({
+                    severity: "warning",
+                    path: displayPath(ctx, path),
+                    message: `The agent that mounts this extension owns ${label}; ignoring.`,
+                });
+            }
+        }
+        const dirs = [
+            [
+                "playground",
+                "Playground chips are a Vite glob of the agent tree, not an extension slot; ignoring.",
+            ],
+            ["extensions", "Nested extensions are not mounted; ignoring."],
+        ];
+        for (const [slot, message] of dirs) {
+            const path = join(root, slot);
+            if (yield isDirectory(path)) {
+                ctx.diagnostics.push({
+                    severity: "warning",
+                    path: displayPath(ctx, path),
+                    message,
+                });
+            }
+        }
+    });
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Filesystem primitives discovery walks with: module-file detection, directory listing, and project-root markers.
+ */
+import type { Dirent } from "node:fs";
+export declare function findModuleFile(dir: string, stem: string): Promise<string | undefined>;
+export declare function isModuleFile(fileName: string): boolean;
+export declare function moduleStem(fileName: string): string;
+export declare function sortedEntries(dir: string): Promise<Dirent[]>;
+export declare function walkFiles(dir: string): Promise<string[]>;
+export declare function isDirectory(path: string): Promise<boolean>;
+export declare function isFile(path: string): Promise<boolean>;
+export declare function toPosix(path: string): string;
+export declare function hasFlatLayoutMarkers(rootDir: string): Promise<boolean>;
+export declare function readPackageName(rootDir: string): Promise<string | undefined>;
+//# sourceMappingURL=fs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../../src/internal/discovery/fs.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAMtC,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAQ7B;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAYtD;AAED,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAGlE;AAED,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAc9D;AAED,wBAAsB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAMhE;AAED,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAM3D;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAK5E;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAgB7B"}