@cursor/july 0.1.99 → 0.1.101

package/src/internal/discovery.ts

@@ -41,10 +41,12 @@ import {
   type DiscoveredAB,
   type DiscoveredChannel,
   type DiscoveredConnection,
+  type DiscoveredExtension,
   type DiscoveredHook,
   type DiscoveredSchedule,
   type DiscoveredSkill,
   type DiscoveredTool,
+  type ExtensionMount,
   type HookDefinition,
   type HttpChannelDefinition,
   type InlineStdioConnectionConfig,
@@ -54,10 +56,12 @@ import {
   MAX_RUNNING_TURNS_LIMIT,
   type ModelSetting,
   normalizeConnectionEffects,
+  normalizeConnectionTools,
   normalizeCursorAccountServers,
   type ResolvedAgent,
   type ScheduleDefinition,
   type SeedFile,
+  type SkillConfig,
   type SkillDefinition,
   type SkillFileSource,
   type ToolDefinition,
@@ -433,6 +437,12 @@ async function loadAgent(
 
   const tools = await loadTools(ctx, join(agentDir, "tools"));
   const skills = await loadSkills(ctx, join(agentDir, "skills"));
+  const extensions = await appendExtensions(
+    ctx,
+    join(agentDir, "extensions"),
+    tools,
+    skills
+  );
   const connections = await loadConnections(
     ctx,
     await resolveMcpConnectionsDir(ctx, agentDir)
@@ -579,6 +589,7 @@ async function loadAgent(
     ...(architecture === undefined ? {} : { architecture }),
     tools,
     skills,
+    extensions,
     connections,
     hostConnections,
     subagents,
@@ -868,16 +879,35 @@ async function loadTools(
   ctx: DiscoveryContext,
   toolsDir: string
 ): Promise<DiscoveredTool[]> {
+  const tools: DiscoveredTool[] = [];
+  for (const { name, path } of await toolModuleEntries(ctx, toolsDir)) {
+    const definition = await importDefault(ctx, path, "tool");
+    if (definition === undefined) {
+      continue;
+    }
+    const tool = compileTool(ctx, path, name, definition as ToolDefinition);
+    if (tool !== undefined) {
+      tools.push(tool);
+    }
+  }
+  return tools;
+}
+
+/** The module files of a `tools/` directory whose filenames are valid tool names. */
+async function toolModuleEntries(
+  ctx: DiscoveryContext,
+  toolsDir: string
+): Promise<Array<{ name: string; path: string }>> {
   if (!(await isDirectory(toolsDir))) {
     return [];
   }
-  const tools: DiscoveredTool[] = [];
+  const entries: Array<{ name: string; path: string }> = [];
   for (const entry of await sortedEntries(toolsDir)) {
-    const entryPath = join(toolsDir, entry.name);
+    const path = join(toolsDir, entry.name);
     if (entry.isDirectory()) {
       ctx.diagnostics.push({
         severity: "warning",
-        path: displayPath(ctx, entryPath),
+        path: displayPath(ctx, path),
         message: "Nested tool directories are not supported; ignoring.",
       });
       continue;
@@ -886,104 +916,105 @@ async function loadTools(
       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;
+    if (validateName(ctx, "tool", name, path)) {
+      entries.push({ name, path });
     }
-    const definition = await importDefault(ctx, entryPath, "tool");
-    if (definition === undefined) {
-      continue;
-    }
-    const tool = definition as ToolDefinition;
-    if (isBlank(tool.description)) {
+  }
+  return entries;
+}
+
+/**
+ * Validate one tool definition against the tool contract and convert its
+ * schemas. Diagnostics point at `entryPath` (the authored file, or the
+ * extension mount that contributed the tool).
+ */
+function compileTool(
+  ctx: DiscoveryContext,
+  entryPath: string,
+  name: string,
+  tool: ToolDefinition
+): DiscoveredTool | undefined {
+  if (isBlank(tool.description)) {
+    ctx.diagnostics.push({
+      severity: "error",
+      path: displayPath(ctx, entryPath),
+      message: "Tools require a non-empty description.",
+    });
+    return undefined;
+  }
+  const execution = tool.execution === "agent" ? "agent" : "server";
+  const needsApprovalConfigured =
+    tool.needsApproval === true || typeof tool.needsApproval === "function";
+  const effect = declaredEffect(tool);
+  if (execution === "agent") {
+    if (isBlank(tool.script)) {
       ctx.diagnostics.push({
         severity: "error",
         path: displayPath(ctx, entryPath),
-        message: "Tools require a non-empty description.",
+        message:
+          'Tools with execution: "agent" require a non-empty `script` (shell body; JSON on stdin, result on stdout).',
       });
-      continue;
+      return undefined;
     }
-    const execution = tool.execution === "agent" ? "agent" : "server";
-    const needsApprovalConfigured =
-      tool.needsApproval === true || typeof tool.needsApproval === "function";
-    const effect = declaredEffect(tool);
-    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") {
+    if (typeof tool.execute === "function") {
       ctx.diagnostics.push({
-        severity: "error",
+        severity: "warning",
         path: displayPath(ctx, entryPath),
         message:
-          'Tools require an execute(input, ctx) function (or set execution: "agent" with a script).',
+          '`execute` is ignored when execution is "agent"; the Cursor agent runs `script` instead.',
       });
-      continue;
     }
-    let inputSchema: DiscoveredTool["inputSchema"];
-    try {
-      inputSchema = toolInputJsonSchema(tool.inputSchema);
-    } catch (error) {
+    if (needsApprovalConfigured) {
       ctx.diagnostics.push({
         severity: "error",
         path: displayPath(ctx, entryPath),
-        message: `Failed to convert inputSchema to JSON Schema: ${errorMessage(error)}`,
-      });
-      continue;
-    }
-    let outputSchema: DiscoveredTool["outputSchema"];
-    try {
-      outputSchema = toolOutputJsonSchema(tool.outputSchema);
-    } catch (error) {
-      ctx.diagnostics.push({
-        severity: "error",
-        path: displayPath(ctx, entryPath),
-        message: `Failed to convert outputSchema to JSON Schema: ${errorMessage(error)}`,
+        message:
+          '`needsApproval` is only supported for execution: "server" tools (in-process).',
       });
-      continue;
+      return undefined;
     }
-    tools.push({
-      name,
-      description: tool.description,
-      inputSchema,
-      ...(outputSchema === undefined ? {} : { outputSchema }),
-      execution,
-      needsApproval: needsApprovalConfigured,
-      ...(effect === undefined ? {} : { effect }),
-      ...(execution === "agent" && tool.script !== undefined
-        ? { script: tool.script }
-        : {}),
-      definition: tool,
+  } 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).',
     });
+    return undefined;
   }
-  return tools;
+  let inputSchema: DiscoveredTool["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)}`,
+    });
+    return undefined;
+  }
+  let outputSchema: DiscoveredTool["outputSchema"];
+  try {
+    outputSchema = toolOutputJsonSchema(tool.outputSchema);
+  } catch (error) {
+    ctx.diagnostics.push({
+      severity: "error",
+      path: displayPath(ctx, entryPath),
+      message: `Failed to convert outputSchema to JSON Schema: ${errorMessage(error)}`,
+    });
+    return undefined;
+  }
+  return {
+    name,
+    description: tool.description,
+    inputSchema,
+    outputSchema,
+    execution,
+    needsApproval: needsApprovalConfigured,
+    effect,
+    script: execution === "agent" ? tool.script : undefined,
+    definition: tool,
+  };
 }
 
 /**
@@ -1029,7 +1060,7 @@ async function loadSkills(
     }
     if (entry.name.endsWith(".md")) {
       const name = entry.name.slice(0, -".md".length);
-      if (!validateSkillName(ctx, name, entryPath)) {
+      if (!validateName(ctx, "skill", name, entryPath)) {
         continue;
       }
       const { data, body } = parseFrontmatter(
@@ -1048,30 +1079,258 @@ async function loadSkills(
     }
     if (isModuleFile(entry.name)) {
       const name = moduleStem(entry.name);
-      if (!validateSkillName(ctx, name, entryPath)) {
+      if (!validateName(ctx, "skill", name, entryPath)) {
         continue;
       }
       const definition = await importDefault(ctx, entryPath, "skill");
       if (definition === undefined) {
         continue;
       }
-      const skill = definition as SkillDefinition;
-      const files: Record<string, SkillFileSource> = {};
-      for (const [rel, contents] of Object.entries(skill.files ?? {})) {
-        files[rel] = { contents };
+      skills.push(compileSkill(name, definition as SkillDefinition));
+    }
+  }
+  return skills;
+}
+
+/** A skill whose body and sibling files are in memory (`defineSkill`, extensions). */
+function compileSkill(name: string, skill: SkillConfig): DiscoveredSkill {
+  const files: Record<string, SkillFileSource> = {};
+  for (const [rel, contents] of Object.entries(skill.files ?? {})) {
+    files[rel] = { contents };
+  }
+  return {
+    name,
+    description:
+      skill.description ??
+      deriveSkillDescription(skill.markdown) ??
+      SKILL_DESCRIPTION_FALLBACK(name),
+    markdown: skill.markdown.trim(),
+    files,
+  };
+}
+
+// ============================================================================
+// Extensions (agent/extensions/<ns>.ts | agent/extensions/<ns>/extension.ts)
+// ============================================================================
+
+/**
+ * Mount every extension under `agent/extensions/` and append its tools and
+ * skills to the authored lists as `<ns>__<name>`, stamped with `extension`.
+ * The namespace is the mount's filename stem or directory name.
+ */
+async function appendExtensions(
+  ctx: DiscoveryContext,
+  extensionsDir: string,
+  tools: DiscoveredTool[],
+  skills: DiscoveredSkill[]
+): Promise<DiscoveredExtension[]> {
+  if (!(await isDirectory(extensionsDir))) {
+    return [];
+  }
+  const extensions: DiscoveredExtension[] = [];
+  for (const entry of await sortedEntries(extensionsDir)) {
+    const path = join(extensionsDir, entry.name);
+    const site = await 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 = await importDefault(ctx, site.mountPath, "extension");
+    if (mount === undefined) {
+      continue;
+    }
+    extensions.push(
+      await mountExtension(ctx, site, mount as ExtensionMount, tools, skills)
+    );
+  }
+  return extensions;
+}
+
+interface MountSite {
+  ns: string;
+  /** The module default-exporting the {@link ExtensionMount}. */
+  mountPath: string;
+  /** A directory mount; its `tools/` and `skills/` overlay the extension's. */
+  overlayDir?: string;
+}
+
+async function resolveMountSite(
+  ctx: DiscoveryContext,
+  path: string,
+  entry: Dirent
+): Promise<MountSite | undefined> {
+  if (entry.isDirectory()) {
+    if (!validateName(ctx, "extension", entry.name, path)) {
+      return undefined;
+    }
+    const mountPath = await 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 crm({ ... })`).",
+      });
+      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;
+}
+
+/**
+ * Read the extension's tree with the agent loaders, lay the mount's overlay
+ * on top (a same-named file replaces, `disableTool()` removes), then
+ * namespace what is left.
+ */
+async function mountExtension(
+  ctx: DiscoveryContext,
+  site: MountSite,
+  mount: ExtensionMount,
+  tools: DiscoveredTool[],
+  skills: DiscoveredSkill[]
+): Promise<DiscoveredExtension> {
+  const mounted: DiscoveredExtension = {
+    name: site.ns,
+    description: mount.extension.description,
+    tools: [],
+    skills: [],
+  };
+  const root = mount.extension.root;
+  if (!(await isDirectory(root))) {
+    ctx.diagnostics.push({
+      severity: "error",
+      path: displayPath(ctx, site.mountPath),
+      message: `Extension "${site.ns}" declares root ${root}, which is not a directory. Pass \`import.meta.dirname\` from extension.ts.`,
+    });
+    return mounted;
+  }
+  await warnUnsupportedExtensionSlots(ctx, root);
+  const contributedTools = new Map(
+    (await loadTools(ctx, join(root, "tools"))).map((tool) => [tool.name, tool])
+  );
+  const contributedSkills = new Map(
+    (await loadSkills(ctx, join(root, "skills"))).map((skill) => [
+      skill.name,
+      skill,
+    ])
+  );
+  if (site.overlayDir !== undefined) {
+    const overlay = await loadOverlayTools(ctx, join(site.overlayDir, "tools"));
+    for (const tool of overlay.tools) {
+      contributedTools.set(tool.name, tool);
+    }
+    for (const disabled of overlay.disabled) {
+      if (!contributedTools.delete(disabled.name)) {
+        ctx.diagnostics.push({
+          severity: "error",
+          path: displayPath(ctx, disabled.path),
+          message: `disableTool() targets "${disabled.name}", which extension "${site.ns}" does not contribute.`,
+        });
       }
-      skills.push({
-        name,
-        description:
-          skill.description ??
-          deriveSkillDescription(skill.markdown) ??
-          SKILL_DESCRIPTION_FALLBACK(name),
-        markdown: skill.markdown.trim(),
-        files,
+    }
+    for (const skill of await loadSkills(
+      ctx,
+      join(site.overlayDir, "skills")
+    )) {
+      contributedSkills.set(skill.name, skill);
+    }
+  }
+  for (const [name, tool] of contributedTools) {
+    const composed = `${site.ns}__${name}`;
+    tools.push({ ...tool, name: composed, extension: site.ns });
+    mounted.tools.push(composed);
+  }
+  for (const [name, skill] of contributedSkills) {
+    const composed = `${site.ns}__${name}`;
+    skills.push({ ...skill, name: composed, extension: site.ns });
+    mounted.skills.push(composed);
+  }
+  return mounted;
+}
+
+/** A directory mount's `tools/`: replacements plus `disableTool()` markers. */
+async function loadOverlayTools(
+  ctx: DiscoveryContext,
+  toolsDir: string
+): Promise<{
+  tools: DiscoveredTool[];
+  disabled: Array<{ name: string; path: string }>;
+}> {
+  const tools: DiscoveredTool[] = [];
+  const disabled: Array<{ name: string; path: string }> = [];
+  for (const { name, path } of await toolModuleEntries(ctx, toolsDir)) {
+    let mod: Record<string, unknown>;
+    try {
+      mod = await ctx.importModule(path);
+    } catch (error) {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, path),
+        message: `Failed to load module: ${errorMessage(error)}`,
+      });
+      continue;
+    }
+    const kind = getDefinitionKind(mod.default);
+    if (kind === "disabled-tool") {
+      disabled.push({ name, path });
+      continue;
+    }
+    if (kind !== "tool") {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, path),
+        message:
+          "An override must default-export defineTool({ ... }) or disableTool().",
+      });
+      continue;
+    }
+    const tool = compileTool(ctx, path, name, mod.default as ToolDefinition);
+    if (tool !== undefined) {
+      tools.push(tool);
+    }
+  }
+  return { tools, disabled };
+}
+
+/** Slots an agent has that an extension tree may not contribute (yet). */
+async function warnUnsupportedExtensionSlots(
+  ctx: DiscoveryContext,
+  root: string
+): Promise<void> {
+  const unsupported = [
+    ["instructions.md", "instructions"],
+    ["connections", "connections"],
+    ["mcp-connections", "MCP connections"],
+    ["hooks", "hooks"],
+    ["subagents", "subagents"],
+    ["channels", "channels"],
+    ["schedules", "schedules"],
+    ["extensions", "nested extensions"],
+  ] as const;
+  for (const [slot, label] of unsupported) {
+    const path = join(root, slot);
+    if ((await isDirectory(path)) || (await isFile(path))) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        path: displayPath(ctx, path),
+        message: `Extension ${label} are not supported yet; only tools/ and skills/ are mounted. Ignoring.`,
       });
     }
   }
-  return skills;
 }
 
 async function loadPackagedSkill(
@@ -1088,7 +1347,7 @@ async function loadPackagedSkill(
     });
     return undefined;
   }
-  if (!validateSkillName(ctx, name, skillDir)) {
+  if (!validateName(ctx, "skill", name, skillDir)) {
     return undefined;
   }
   const { data, body } = parseFrontmatter(await readFile(skillMdPath, "utf8"));
@@ -1168,6 +1427,25 @@ function parseConnectionEffects(
   return { ok: true, value: normalizeConnectionEffects(parsed) };
 }
 
+function parseConnectionTools(
+  tools: unknown
+): { ok: true; value: string[] | undefined } | { ok: false } {
+  if (tools === undefined) {
+    return { ok: true, value: undefined };
+  }
+  if (!Array.isArray(tools) || tools.length === 0) {
+    return { ok: false };
+  }
+  if (tools.some((name) => typeof name !== "string")) {
+    return { ok: false };
+  }
+  const normalized = normalizeConnectionTools(tools);
+  if (normalized.length === 0) {
+    return { ok: false };
+  }
+  return { ok: true, value: normalized };
+}
+
 function connectionHasSpawnOrRemote(connection: ConnectionDefinition): boolean {
   if ("cursorAccount" in connection && connection.cursorAccount === true) {
     return true;
@@ -1214,20 +1492,34 @@ function connectionTransport(
   return undefined;
 }
 
-function validateSkillName(
+/**
+ * Filenames become the names the model sees. `__` is reserved: it joins an
+ * extension's namespace to its contribution (`crm__search`).
+ */
+function validateName(
   ctx: DiscoveryContext,
+  kind: "skill" | "tool" | "extension",
   name: string,
   entryPath: string
 ): boolean {
-  if (NAME_PATTERN.test(name)) {
-    return true;
+  const label = { skill: "Skill", tool: "Tool", extension: "Extension" }[kind];
+  if (!NAME_PATTERN.test(name)) {
+    ctx.diagnostics.push({
+      severity: "error",
+      path: displayPath(ctx, entryPath),
+      message: `${label} name "${name}" must match ${NAME_PATTERN}.`,
+    });
+    return false;
   }
-  ctx.diagnostics.push({
-    severity: "error",
-    path: displayPath(ctx, entryPath),
-    message: `Skill name "${name}" must match ${NAME_PATTERN}.`,
-  });
-  return false;
+  if (name.includes("__")) {
+    ctx.diagnostics.push({
+      severity: "error",
+      path: displayPath(ctx, entryPath),
+      message: `${label} name "${name}" may not contain "__"; it is reserved for extension contributions (\`<ns>__<name>\`).`,
+    });
+    return false;
+  }
+  return true;
 }
 
 /**
@@ -1296,7 +1588,7 @@ async function loadHostConnections(
   modelConnections: readonly DiscoveredConnection[]
 ): Promise<DiscoveredConnection[]> {
   const hostDir = join(agentDir, "host-connections");
-  const loaded = await loadConnections(ctx, hostDir);
+  const loaded = await loadConnections(ctx, hostDir, "host");
   const modelNames = new Set(
     modelConnections.map((connection) => connection.name)
   );
@@ -1335,7 +1627,8 @@ async function loadHostConnections(
 
 async function loadConnections(
   ctx: DiscoveryContext,
-  connectionsDir: string
+  connectionsDir: string,
+  role: "model" | "host" = "model"
 ): Promise<DiscoveredConnection[]> {
   if (!(await isDirectory(connectionsDir))) {
     return [];
@@ -1435,6 +1728,56 @@ async function loadConnections(
       });
       continue;
     }
+    const parsedTools = isInlineStdioConnection(connection)
+      ? { ok: true as const, value: undefined }
+      : parseConnectionTools(connection.tools);
+    if (!parsedTools.ok) {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, entryPath),
+        message:
+          "MCP connection `tools` allowlist must be a non-empty array of tool names.",
+      });
+      continue;
+    }
+    if (
+      isInlineStdioConnection(connection) &&
+      connection.disallowedTools !== undefined
+    ) {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, entryPath),
+        message:
+          "MCP connection `disallowedTools` is not supported on inline `tools` connections — author only the tools you want.",
+      });
+      continue;
+    }
+    const parsedDisallowed = isInlineStdioConnection(connection)
+      ? { ok: true as const, value: undefined }
+      : parseConnectionTools(connection.disallowedTools);
+    if (!parsedDisallowed.ok) {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, entryPath),
+        message:
+          "MCP connection `disallowedTools` must be a non-empty array of tool names.",
+      });
+      continue;
+    }
+    if (
+      (parsedTools.value !== undefined ||
+        parsedDisallowed.value !== undefined) &&
+      role === "model" &&
+      connection.advertiseTools !== true
+    ) {
+      ctx.diagnostics.push({
+        severity: "error",
+        path: displayPath(ctx, entryPath),
+        message:
+          "MCP connection `tools` / `disallowedTools` filter advertised tools; set `advertiseTools: true` or drop the name list. Put the connection in `agent/host-connections/` to restrict `host.mcp` only.",
+      });
+      continue;
+    }
     if (
       connection.advertiseTools === true &&
       isInlineStdioConnection(connection)
@@ -1538,6 +1881,8 @@ async function loadConnections(
       auth: connection.auth,
       advertiseTools: connection.advertiseTools,
       effects: parsedEffects.value,
+      tools: parsedTools.value,
+      disallowedTools: parsedDisallowed.value,
     });
   }
   return connections;
@@ -1649,6 +1994,7 @@ async function warnUnsupportedSubagentSlots(
   const unsupported = [
     ["tools", "tools"],
     ["skills", "skills"],
+    ["extensions", "extensions"],
     ["mcp-connections", "MCP connections"],
     ["host-connections", "host MCP connections"],
     ["connections", "MCP connections"],
@@ -1684,13 +2030,17 @@ function appendBuiltinTools(
     return;
   }
   const agentPath = displayPath(ctx, join(agentDir, "agent.ts"));
-  const authored = new Set(tools.map((tool) => tool.name));
   for (const tool of builtin) {
-    if (authored.has(tool.name)) {
+    const existing = tools.find((t) => t.name === tool.name);
+    if (existing !== undefined) {
+      const owner =
+        existing.extension === undefined
+          ? "Authored"
+          : `Extension "${existing.extension}"`;
       ctx.diagnostics.push({
         severity: "warning",
         path: agentPath,
-        message: `Authored tool "${tool.name}" shadows the built-in tool of the same name; the authored tool wins.`,
+        message: `${owner} tool "${tool.name}" shadows the built-in tool of the same name; the built-in is skipped.`,
       });
       continue;
     }
@@ -1928,7 +2278,15 @@ async function loadChannels(
       });
       continue;
     }
-    channels.push({ id, definition: mod.default as ChannelDefinition });
+    const definition = mod.default as ChannelDefinition;
+    for (const notice of definition.meta?.deprecations ?? []) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        path: displayPath(ctx, entryPath),
+        message: notice,
+      });
+    }
+    channels.push({ id, definition });
   }
   return { channels, httpChannelDefinition };
 }
@@ -2375,11 +2733,14 @@ export function projectInfo(project: AgentProject): AgentProjectInfo {
       name: skill.name,
       description: skill.description,
     })),
+    extensions: agent.extensions ?? [],
     connections: agent.connections.map((connection) => ({
       name: connection.name,
       transport: connectionTransportLabel(connection.transport),
       advertiseTools: connection.advertiseTools,
       effects: connection.effects,
+      tools: connection.tools,
+      disallowedTools: connection.disallowedTools,
       cursorAccountServers:
         "cursorAccount" in connection.transport
           ? (connection.transport.servers ?? "*")
@@ -2485,6 +2846,7 @@ async function importDefault(
     | "agent"
     | "tool"
     | "skill"
+    | "extension"
     | "connection"
     | "schedule"
     | "hook"
@@ -2525,6 +2887,7 @@ const DEFINE_HELPER_NAME: Record<
   | "instructions"
   | "tool"
   | "skill"
+  | "extension"
   | "connection"
   | "channel"
   | "http-channel"
@@ -2540,6 +2903,7 @@ const DEFINE_HELPER_NAME: Record<
   instructions: "defineInstructions",
   tool: "defineTool",
   skill: "defineSkill",
+  extension: "defineExtension",
   connection: "defineConnection",
   channel: "defineChannel",
   "http-channel": "httpChannel",
@@ -2560,6 +2924,7 @@ async function warnUnknownSlots(
     "instructions",
     "tools",
     "skills",
+    "extensions",
     "mcp-connections",
     "host-connections",
     // Legacy slot name; resolveMcpConnectionsDir warns and still loads it.