diff --git a/.changeset/framework-mode-agent-bundle.md b/.changeset/framework-mode-agent-bundle.md
new file mode 100644
index 000000000..f22117fb3
--- /dev/null
+++ b/.changeset/framework-mode-agent-bundle.md
@@ -0,0 +1,19 @@
+---
+"agent-bundle": minor
+---
+
+Framework mode (RFC #63), compiler side. The `skills/<name>/` directory
+convention gains a power tier and two migration nudges. Rendered skills: a
+skill directory may hold `SKILL.tsx` (or `SKILL.ts`) instead of `SKILL.md` —
+the module default-exports a component (sync or async) and exports a
+`frontmatter` record, and the build renders the element tree to Markdown
+through a dependency-free renderer covering a documented subset (`h1`–`h6`,
+`p`, lists, `strong`/`em`/`code`, `pre`, `blockquote`, `a`, `hr`, `br`,
+fragments; anything else is a named error, never a silent approximation). The
+compiled `SKILL.md` is emitted as a generated write entry into every target
+artifact. New nudges: `AB4734` when explicit `skills` configuration leaves a
+conventional `skills/<name>/SKILL.md` uncovered (config wins, the shadowed
+state is flagged), and `AB4735` when a hand-authored `SKILL.md` shadows a
+rendered `SKILL.tsx`/`SKILL.ts` in the same directory (the authored file
+wins). The `create-agent-bundle` minimal template now teaches the directory
+convention: no `skills` field in its config at all.
diff --git a/.changeset/framework-mode-rsc-runtime.md b/.changeset/framework-mode-rsc-runtime.md
new file mode 100644
index 000000000..b5487cc3a
--- /dev/null
+++ b/.changeset/framework-mode-rsc-runtime.md
@@ -0,0 +1,19 @@
+---
+"@agent-bundle/rsc-runtime": minor
+---
+
+Framework mode (RFC #63), runtime side — **breaking removals**. The
+structural JSX layer is gone: the `AgentBundle`, `Skill`, `Script`,
+`McpServer`, `McpApp`, and `Operation` elements, `defineRscAgentBundle`, and
+the `RscAgentBundleApplication` type are removed outright. Structure —
+targets, skills, scripts, servers, apps — is declared in
+`agent-bundle.config.ts` and file conventions; JSX remains only where
+something is rendered (`Mcp.*`/`Hook.*` results, rendered skill bodies).
+Their replacement is `defineRscApplication({ name, version, description?,
+operations })`: a flat, JSX-free declaration of the runtime identity and the
+typed operation catalog, rejecting duplicate operation ids, CLI commands, and
+MCP tools. `runRscCli` and `createRscMcpServer` now consume this flattened
+application — `createRscMcpServer(application, serverName)` selects the
+operations whose `mcp.server` matches and throws for a name no operation
+references. The `agent-bundle` peer dependency is dropped; the package no
+longer imports config types at all.
diff --git a/README.md b/README.md
index f57889115..83a841121 100644
--- a/README.md
+++ b/README.md
@@ -51,7 +51,7 @@ npx agent-bundle dev --root .                   # local workbench with live rebu
 
 `targets: ['plugin']` emits one multi-host bundle at `dist/plugin/`: `.claude-plugin/`, `.codex-plugin/`, and `.cursor-plugin/` manifests over shared `skills/`, `hooks/`, `mcp/`, and `scripts/` directories. The bundle's generated `AGENTS.md` explains how to install it into each host. Per-host layouts are available as the `claude`, `codex`, `cursor`, and `portable` targets.
 
-The same config also owns the npm package build — no second bundler config, bin shims, or hand-rolled stdio lifecycles. `bin` and `lib` entries (or the conventions `src/cli.ts`, `src/index.ts`, and `src/mcp/<server-id>.ts`) emit executable `dist/bin/<name>.js` bundles and a library output alongside the host artifacts; an MCP entry that default-exports a server factory runs under a framework-owned stdio lifecycle; `tools.rsbuild` / `tools.rspack` is the one bundler escape hatch. [Entry conventions](docs/entry-conventions.md) is the full contract.
+The same config also owns the npm package build — no second bundler config, bin shims, or hand-rolled stdio lifecycles. `bin` and `lib` entries (or the conventions `src/cli.ts`, `src/index.ts`, and `src/mcp/<server-id>.ts`) emit executable `dist/bin/<name>.js` bundles and a library output alongside the host artifacts; an MCP entry that default-exports a server factory runs under a framework-owned stdio lifecycle; `tools.rsbuild` / `tools.rspack` is the one bundler escape hatch. [Entry conventions](docs/entry-conventions.md) is the full contract, and [Framework mode](docs/framework-mode.md) is the whole authoring model on one screen: structure in config and conventions (`skills/<name>/SKILL.md` ships with no declaration at all), JSX only where something is rendered.
 
 ## Commands
 
diff --git a/docs/diagnostics.md b/docs/diagnostics.md
index 36789e357..932ff0bdd 100644
--- a/docs/diagnostics.md
+++ b/docs/diagnostics.md
@@ -10,7 +10,7 @@ gate a build, a validation, or a dev rebuild.
 
 | Family | Area |
 | --- | --- |
-| `AB30xx` | Skill Markdown parsing (missing or malformed frontmatter). |
+| `AB30xx` | Skill documents: Markdown parsing (`AB3000`–`AB3002`: unreadable, missing or malformed frontmatter) and rendered-skill compilation (`AB3003`: module failed to load, `AB3004`: missing/invalid default component or `frontmatter` export, `AB3005`: content outside the supported Markdown element subset). |
 | `AB40xx` | Plugin metadata and Skill source validation. |
 | `AB41xx` | Normalized model invariants (unknown targets, duplicate IDs and outputs). |
 | `AB42xx` | Hook configuration and native hook sources. |
@@ -27,7 +27,7 @@ gate a build, a validation, or a dev rebuild.
 | `AB8xxx` | Development server configuration. |
 | `AB9xxx` | Eval selection, harnesses, and persisted runs. |
 
-## Migration nudges (`AB4730`–`AB4733`)
+## Migration nudges (`AB4730`–`AB4735`)
 
 The entry conventions and the framework-owned stdio lifecycle shell (RFC #50)
 replaced patterns consumers previously wrote by hand. When `validate`,
@@ -75,6 +75,25 @@ to it — a confusable state where the file on disk is not what runs.
 Adopt: drop the explicit `entry`/`command`/`url` so the convention applies.
 Silence: remove the shadowed file.
 
+### `AB4734` — conventional skill shadowed by explicit `skills` config
+
+A `skills/<name>/SKILL.md` (or rendered `SKILL.tsx`/`SKILL.ts`) directory
+exists, but the explicit `skills` configuration does not cover it — the
+conventional skill is silently shadowed. When config is silent, every
+`skills/<name>/` directory ships by convention and this nudge never fires.
+
+Adopt: remove the explicit `skills` configuration so the convention applies,
+or add the directory to `skills`. Silence: remove the directory.
+
+### `AB4735` — rendered skill source shadowed by hand-authored `SKILL.md`
+
+A skill directory contains both a hand-authored `SKILL.md` and a rendered
+skill source (`SKILL.tsx`/`SKILL.ts`). The authored file wins — an authored
+document beats a generated one — so the component module never compiles.
+
+Adopt: remove `SKILL.md` so the rendered skill compiles at build. Silence:
+remove the component module.
+
 ## Development package build (`AB7103`)
 
 `agent-bundle dev` rebuilds the framework-owned package build (`dist/` bin
diff --git a/docs/entry-conventions.md b/docs/entry-conventions.md
index 00988e970..5fe60507f 100644
--- a/docs/entry-conventions.md
+++ b/docs/entry-conventions.md
@@ -5,6 +5,9 @@ libraries: one `agent-bundle.config.ts`, one CLI, framework-owned entry
 lifecycles, and a single blessed escape hatch into the bundler. This document
 is the contract for the package build (`bin` / `lib`), the entry-file
 conventions, the generated entry shells, and the `tools` escape hatch.
+[Framework mode](framework-mode.md) is the one-screen authoring model these
+conventions serve: structure in config and conventions, JSX only for
+rendering.
 
 ## The package build
 
diff --git a/docs/framework-mode.md b/docs/framework-mode.md
new file mode 100644
index 000000000..0b5f13bf2
--- /dev/null
+++ b/docs/framework-mode.md
@@ -0,0 +1,93 @@
+# Framework mode
+
+Structure lives in `agent-bundle.config.ts` and file conventions. JSX renders.
+That is the whole model (RFC #63); RFC #50's entry conventions are the sibling
+contract for `bin`/`lib`/MCP entries.
+
+## What a newcomer must learn
+
+Three things:
+
+1. **One directory convention.** Every `skills/<name>/SKILL.md` ships as a
+   Skill. Add a folder and it ships — no declaration anywhere.
+2. **One flat config file.** `agent-bundle.config.ts` declares the plugin
+   identity, targets, and anything a file cannot say for itself:
+
+```ts
+import { defineConfig } from 'agent-bundle';
+
+export default defineConfig({
+  plugin: { description: '…', name: 'my-plugin', version: '0.1.0' },
+  targets: ['portable', 'codex', 'claude'],
+});
+```
+
+3. **JSX = rendering.** React elements appear only where something is
+   rendered: MCP/hook results at runtime (`Mcp.Result`, `Hook.Text`), and
+   skill documents at build time (below). There are no structural JSX
+   elements — no `<AgentBundle>`, `<Skill>`, or `<McpServer>`.
+
+Entry files follow the same convention-with-fallback trick: `src/cli.ts` is
+the package bin, `src/index.ts` the library, `src/mcp/<server-id>.ts` a
+declared server's stdio entry — each applies when the file exists, and
+explicit config always wins over a convention (`AB473x` nudges flag the
+confusable shadowed states). See `docs/entry-conventions.md`.
+
+## Applications with operations (when you have a CLI or MCP server)
+
+`defineRscApplication` declares the runtime identity plus one typed operation
+catalog; the conventional entries consume it:
+
+```ts
+// src/application.ts
+export const application = defineRscApplication({
+  name: 'my-plugin',
+  operations: [status],
+  version: '0.1.0',
+});
+
+// src/cli.ts
+export const main = (argv: readonly string[]) => runRscCli(application, argv);
+
+// src/mcp/runtime.ts
+export default () => createRscMcpServer(application, 'runtime');
+```
+
+The server's structural declaration (`mcp.servers.runtime: {}`) lives in the
+config; the name passed to `createRscMcpServer` only selects which operations
+to serve.
+
+## Rendered skills (power tier, never required)
+
+A skill whose document is generated: put `SKILL.tsx` (or `SKILL.ts`) in the
+skill directory instead of `SKILL.md`. The module default-exports a component
+and exports a `frontmatter` record; the build renders the tree to Markdown
+and emits the `SKILL.md` every host consumes.
+
+```tsx
+// skills/deploy-checklist/SKILL.tsx
+export const frontmatter = {
+  description: 'Deployment checklist.',
+  name: 'deploy-checklist',
+};
+
+export default () => (
+  <>
+    <h1>Deploy checklist</h1>
+    <p>Verify each step <strong>in order</strong>.</p>
+  </>
+);
+```
+
+The renderer supports a documented element subset (`h1`–`h6`, `p`,
+`ul`/`ol`/`li`, `strong`, `em`, `code`, `pre`, `blockquote`, `a`, `hr`,
+`br`, fragments) and rejects anything outside it by name — never a silent
+approximation. Components may be async, and may import project code, so the
+document can be computed from the same sources the plugin ships. A
+hand-authored `SKILL.md` in the same directory always wins (`AB4735`).
+
+## Precedence, said once
+
+Config wins, conventions fill. Declaring `skills:` in config replaces the
+directory convention entirely (`AB4734` flags any directory left uncovered);
+the same rule governs `bin`, `lib`, and MCP server entries.
diff --git a/examples/audiobook-curator/README.md b/examples/audiobook-curator/README.md
index 1aac54d78..6475f709a 100644
--- a/examples/audiobook-curator/README.md
+++ b/examples/audiobook-curator/README.md
@@ -6,11 +6,12 @@ From the repository root, launch this example with:
 pnpm example:audiobook
 ```
 
-A complete TypeScript recreation of the original `audiobook-curator`, authored
-as one React Server Component plugin application. The same typed operation tree
-produces a globally installable CLI, one stdio MCP server, one Skill, and native
-Claude Code and Codex plugin artifacts. It has no hooks and does not call the old
-Python curator.
+A complete TypeScript recreation of the original `audiobook-curator`, built in
+framework mode: `agent-bundle.config.ts` plus file conventions declare the
+structure, and one typed operation catalog produces a globally installable
+CLI, one stdio MCP server, one Skill, and native Claude Code and Codex plugin
+artifacts. JSX appears only where something is rendered — the MCP result
+receipts. It has no hooks and does not call the old Python curator.
 
 The package requires Node 22.19+, `ffprobe`, and `ffmpeg`. Optional features call
 the foreign tools that actually provide the evidence: Audiobook Forge,
@@ -49,9 +50,12 @@ dependencies.
 
 ## Source layout
 
-- `src/application.tsx` — composition only: merges the feature modules'
-  defaults and declares the `<AgentBundle>` tree (Skill, CLI Script, MCP
-  server, operations).
+- `agent-bundle.config.ts` — the structure: plugin identity, targets, the CLI
+  script, and the MCP server (whose entry is the `src/mcp/curator.ts`
+  convention). The Skill needs no declaration at all:
+  `skills/curate-audiobooks/SKILL.md` ships by convention.
+- `src/application.ts` — composition only: merges the feature modules'
+  defaults into one `defineRscApplication` operation catalog.
 - `src/operations/` — the operation catalog, grouped by workflow stage:
   `discovery` (inspect/inventory/library-audit/select), `audible`
   (search/select/cache), `evidence` (acoustic/whisper), `media-mutation`
@@ -62,8 +66,8 @@ dependencies.
   `curator-core.ts`) over the shared `foundation.ts` and `media-process.ts`
   primitives; `result.tsx` renders every receipt for MCP.
 - `src/cli.ts` exports `main`; the framework's generated process envelope
-  turns it into both the bundled `<Script>` artifact entry and the npm bin.
-  `src/mcp-server.ts` default-exports a server factory served under the
+  turns it into both the bundled script artifact entry and the npm bin.
+  `src/mcp/curator.ts` default-exports a server factory served under the
   framework's stdio lifecycle shell. No hand-written entry shims remain.
 
 ## Complete workflow
@@ -125,8 +129,8 @@ The completion contract and real-volume checklist are in
 ## Maintainer notes
 
 This example is the reference consumer of the framework-owned package build
-("one config, agent-bundle owns the build"): `agent-bundle.config.ts` is a
-pure pass-through of the RSC application's config, and the `src/cli.ts` /
-`src/index.ts` conventions provide the npm bin and library outputs under
-`dist/`. See [`docs/entry-conventions.md`](../../docs/entry-conventions.md)
+("one config, agent-bundle owns the build"): `agent-bundle.config.ts` declares
+the structure directly, and the `src/cli.ts` / `src/index.ts` conventions
+provide the npm bin and library outputs under `dist/`. See
+[`docs/entry-conventions.md`](../../docs/entry-conventions.md)
 for the contract.
diff --git a/examples/audiobook-curator/agent-bundle.config.ts b/examples/audiobook-curator/agent-bundle.config.ts
index 0563e08aa..3824d62bc 100644
--- a/examples/audiobook-curator/agent-bundle.config.ts
+++ b/examples/audiobook-curator/agent-bundle.config.ts
@@ -1,3 +1,28 @@
-import { audiobookCuratorApplication } from './src/application.tsx';
+import { defineConfig } from 'agent-bundle';
 
-export default audiobookCuratorApplication.config;
+export default defineConfig({
+  marketplace: true,
+  mcp: {
+    servers: {
+      // No `entry` needed: the conventional stdio entry `src/mcp/curator.ts`
+      // supplies it, and its default-exported factory runs under the
+      // framework lifecycle shell.
+      curator: {},
+    },
+  },
+  plugin: {
+    description:
+      'Complete plan-first audiobook inventory, matching, conversion, repair, and integrity audit.',
+    name: 'audiobook-curator',
+    version: '1.0.0',
+  },
+  runtime: { node: '22.19.0' },
+  // `src/cli.ts` is the package bin by convention; declaring it as a script
+  // also ships it inside every host artifact.
+  scripts: {
+    'audiobook-curator': './src/cli.ts',
+  },
+  // No `skills` field needed: `skills/curate-audiobooks/SKILL.md` is
+  // discovered by convention.
+  targets: ['claude', 'codex'],
+});
diff --git a/examples/audiobook-curator/docs/parity-ledger.md b/examples/audiobook-curator/docs/parity-ledger.md
index 79807a8be..0da19ff1f 100644
--- a/examples/audiobook-curator/docs/parity-ledger.md
+++ b/examples/audiobook-curator/docs/parity-ledger.md
@@ -17,7 +17,7 @@ adapter coverage.
 | Sources are immutable; mutation is plan-only without explicit `apply` | mutation foundation | real/synthetic before-and-after hashes |
 | No shell execution; bounded output; caller cancellation; no local media deadline | capability/process foundation | child-process tests |
 | Natural ordering, Unicode-safe identity, safe filenames without apostrophes | domain text foundation | ported pure tests |
-| Claude and Codex derive Skill, script, and MCP from one TSX application | `src/application.tsx` | artifact and installed-host tests |
+| Claude and Codex derive Skill, script, and MCP from one config plus conventions | `agent-bundle.config.ts`, `src/application.ts` | artifact and installed-host tests |
 
 ## Operations
 
diff --git a/examples/audiobook-curator/package.json b/examples/audiobook-curator/package.json
index 681802341..c8a167544 100644
--- a/examples/audiobook-curator/package.json
+++ b/examples/audiobook-curator/package.json
@@ -2,7 +2,7 @@
   "name": "@agent-bundle-example/audiobook-curator",
   "version": "1.0.0",
   "private": true,
-  "description": "A complete RSC-authored Claude and Codex audiobook-curation plugin, CLI, Skill, and MCP server.",
+  "description": "A complete framework-mode Claude and Codex audiobook-curation plugin, CLI, Skill, and MCP server.",
   "type": "module",
   "engines": {
     "node": ">=22.19.0"
diff --git a/examples/audiobook-curator/src/application.tsx b/examples/audiobook-curator/src/application.ts
similarity index 56%
rename from examples/audiobook-curator/src/application.tsx
rename to examples/audiobook-curator/src/application.ts
index 6278ae6ec..7230c3e1e 100644
--- a/examples/audiobook-curator/src/application.tsx
+++ b/examples/audiobook-curator/src/application.ts
@@ -1,19 +1,11 @@
 /**
- * The audiobook-curator application: one `defineRscAgentBundle` tree that
- * composes the Skill, the CLI Script, the MCP server, and the operation
- * catalog. The operations themselves live in feature modules under
- * `./operations/`; this file only merges their defaults and declares the
- * bundle.
+ * The audiobook-curator application: runtime identity plus the operation
+ * catalog. Structure — targets, the Skill, the CLI script, the MCP server —
+ * lives in `agent-bundle.config.ts` and file conventions; the operations
+ * themselves live in feature modules under `./operations/`, and this file
+ * only merges their defaults.
  */
-import {
-  AgentBundle,
-  McpServer,
-  Operation,
-  Script,
-  Skill,
-  defineRscAgentBundle,
-} from '@agent-bundle/rsc-runtime/plugin';
-import React from 'react';
+import { defineRscApplication } from '@agent-bundle/rsc-runtime/plugin';
 
 import {
   audibleOperations,
@@ -62,32 +54,18 @@ const operationDefinitions = (operations: Required<AudiobookCuratorOperations>)
 
 export const createAudiobookCuratorApplication = (
   options: { readonly operations?: AudiobookCuratorOperations } = {},
-) => {
-  const definitions = operationDefinitions({
+) => defineRscApplication({
+  description: 'Complete plan-first audiobook inventory, matching, conversion, repair, and integrity audit.',
+  name: 'audiobook-curator',
+  operations: operationDefinitions({
     ...defaultAudibleOperations,
     ...defaultDiscoveryOperations,
     ...defaultEvidenceOperations,
     ...defaultMediaMutationOperations,
     ...defaultOutputOperations,
     ...options.operations,
-  });
-  return defineRscAgentBundle(
-    <AgentBundle
-      description="Complete plan-first audiobook inventory, matching, conversion, repair, and integrity audit."
-      marketplace
-      name="audiobook-curator"
-      node="22.19.0"
-      targets={['claude', 'codex']}
-      version="1.0.0"
-    >
-      <Skill source="./skills/curate-audiobooks" />
-      {/* The framework process envelope invokes the exported `main`; no
-          hand-written self-executing entry file is needed. */}
-      <Script entry="./src/cli.ts" name="audiobook-curator" />
-      <McpServer entry="./src/mcp-server.ts" name="curator" />
-      {definitions.map((definition) => <Operation definition={definition} key={definition.id} />)}
-    </AgentBundle>,
-  );
-};
+  }),
+  version: '1.0.0',
+});
 
 export const audiobookCuratorApplication = createAudiobookCuratorApplication();
diff --git a/examples/audiobook-curator/src/mcp-server.ts b/examples/audiobook-curator/src/mcp-server.ts
deleted file mode 100644
index 38e2e3b72..000000000
--- a/examples/audiobook-curator/src/mcp-server.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { createRscMcpServer } from '@agent-bundle/rsc-runtime/plugin';
-
-import { audiobookCuratorApplication } from './application.js';
-
-export const createAudiobookCuratorServer = () => createRscMcpServer(audiobookCuratorApplication, 'curator');
-
-/**
- * Default-exported server factory: `agent-bundle build` detects it and wraps
- * this entry in the framework stdio lifecycle shell (console-to-stderr guard,
- * SIGINT/SIGTERM handling, stdin-EOF exit, bounded shutdown, heartbeat).
- */
-export default createAudiobookCuratorServer;
diff --git a/examples/audiobook-curator/src/mcp/curator.ts b/examples/audiobook-curator/src/mcp/curator.ts
new file mode 100644
index 000000000..045a42a98
--- /dev/null
+++ b/examples/audiobook-curator/src/mcp/curator.ts
@@ -0,0 +1,13 @@
+import { createRscMcpServer } from '@agent-bundle/rsc-runtime/plugin';
+
+import { audiobookCuratorApplication } from '../application.js';
+
+export const createAudiobookCuratorServer = () => createRscMcpServer(audiobookCuratorApplication, 'curator');
+
+/**
+ * Default-exported server factory at the conventional `src/mcp/curator.ts`
+ * entry: `agent-bundle build` detects it and wraps it in the framework stdio
+ * lifecycle shell (console-to-stderr guard, SIGINT/SIGTERM handling,
+ * stdin-EOF exit, bounded shutdown, heartbeat).
+ */
+export default createAudiobookCuratorServer;
diff --git a/examples/audiobook-curator/tests/application.test.tsx b/examples/audiobook-curator/tests/application.test.tsx
index 2d76ce7d7..da43ab37b 100644
--- a/examples/audiobook-curator/tests/application.test.tsx
+++ b/examples/audiobook-curator/tests/application.test.tsx
@@ -1,12 +1,17 @@
 import { lowerMcpResult } from '@agent-bundle/rsc-runtime';
 import { describe, expect, it } from '@rstest/core';
 
+import maybeFactoryConfig from '../agent-bundle.config.ts';
 import {
   createAudiobookCuratorApplication,
   type AudiobookCuratorOperations,
 } from '../src/application.js';
 import { runCli } from '../src/cli.js';
 
+// defineConfig also admits factories; this example's config is a static object.
+if (typeof maybeFactoryConfig === 'function') throw new Error('expected a static config object');
+const config = maybeFactoryConfig;
+
 const operations = (): AudiobookCuratorOperations => ({
   audit: async (input) => ({
     audioSha256: 'b'.repeat(64),
@@ -63,13 +68,15 @@ const operations = (): AudiobookCuratorOperations => ({
 });
 
 describe('audiobook curator RSC application', () => {
-  it('owns config, CLI commands, and MCP tools in one definition', () => {
-    const application = createAudiobookCuratorApplication({ operations: operations() });
+  it('declares structure in config and owns CLI commands and MCP tools in the application', () => {
+    expect(config.targets).toEqual(['claude', 'codex']);
+    expect(Object.keys(config.scripts ?? {})).toEqual(['audiobook-curator']);
+    expect(Object.keys(config.mcp?.servers ?? {})).toEqual(['curator']);
+    // No skills entry: skills/curate-audiobooks/SKILL.md ships by convention.
+    expect(config.skills).toBeUndefined();
 
-    expect(application.config.targets).toEqual(['claude', 'codex']);
-    expect(application.config.skills).toEqual(['./skills/curate-audiobooks']);
-    expect(Object.keys(application.config.scripts ?? {})).toEqual(['audiobook-curator']);
-    expect(Object.keys(application.config.mcp?.servers ?? {})).toEqual(['curator']);
+    const application = createAudiobookCuratorApplication({ operations: operations() });
+    expect(application.name).toBe('audiobook-curator');
     expect(application.operations.map((operation) => operation.cli?.name)).toEqual([
       'acoustic-verify',
       'acoustic-identify',
diff --git a/packages/agent-bundle/package.json b/packages/agent-bundle/package.json
index 38fb15d48..e63feb375 100644
--- a/packages/agent-bundle/package.json
+++ b/packages/agent-bundle/package.json
@@ -87,6 +87,8 @@
   },
   "devDependencies": {
     "@modelcontextprotocol/server": "2.0.0",
-    "@types/ws": "8.18.1"
+    "@types/react": "19.2.18",
+    "@types/ws": "8.18.1",
+    "react": "19.2.8"
   }
 }
diff --git a/packages/agent-bundle/src/adapters/portable.ts b/packages/agent-bundle/src/adapters/portable.ts
index cececcee1..98f24fe5b 100644
--- a/packages/agent-bundle/src/adapters/portable.ts
+++ b/packages/agent-bundle/src/adapters/portable.ts
@@ -240,6 +240,15 @@ const plan = (model: NormalizedPlugin): TargetArtifactPlan => {
 
   for (const skill of model.skills) {
     if (!hasPortableTarget(skill.targets)) continue;
+    if (skill.markdown !== undefined) {
+      // A rendered skill's SKILL.md is compiled from its component module.
+      entries.push({
+        content: skill.markdown,
+        kind: 'write',
+        relativePath: `skills/${skill.name}/SKILL.md`,
+        sourceInputs: sourceInputs(skill.source),
+      });
+    }
     for (const resource of skill.resources) {
       entries.push({
         bytes: resource.bytes,
diff --git a/packages/agent-bundle/src/adapters/types.ts b/packages/agent-bundle/src/adapters/types.ts
index 5117e1442..c3e4e0781 100644
--- a/packages/agent-bundle/src/adapters/types.ts
+++ b/packages/agent-bundle/src/adapters/types.ts
@@ -206,6 +206,15 @@ export const standardPluginArtifactPlan = (input: StandardPluginArtifactsInput):
   }
   for (const skill of input.sharedCopyEntries === false ? [] : model.skills) {
     if (!isSelected(skill.targets)) continue;
+    if (skill.markdown !== undefined) {
+      // A rendered skill's SKILL.md is compiled from its component module.
+      entries.push({
+        content: skill.markdown,
+        kind: 'write',
+        relativePath: `skills/${skill.name}/SKILL.md`,
+        sourceInputs: sourceInputs(skill.source),
+      });
+    }
     for (const resource of skill.resources) {
       entries.push({
         bytes: resource.bytes,
diff --git a/packages/agent-bundle/src/config/discover.ts b/packages/agent-bundle/src/config/discover.ts
index 1e295002b..e306294a9 100644
--- a/packages/agent-bundle/src/config/discover.ts
+++ b/packages/agent-bundle/src/config/discover.ts
@@ -5,8 +5,13 @@ import fastGlob from 'fast-glob';
 
 import type { AgentBundleConfig } from '../core/types.ts';
 import { isProjectPathIgnored, readProjectIgnoreRules } from './ignore.ts';
+import { isRenderedSkillSourceName } from './rendered-skill.ts';
 import { parseSkill, type SkillDocument } from './skill.ts';
 
+/** A skill directory is identified by SKILL.md or a rendered-skill source module. */
+const isSkillDocumentName = (name: string): boolean =>
+  name === 'SKILL.md' || isRenderedSkillSourceName(name);
+
 /** One discovered project-level asset file with its artifact destination under `assets/`. */
 export interface DiscoveredAsset {
   readonly bytes: number;
@@ -16,6 +21,13 @@ export interface DiscoveredAsset {
 
 export interface DiscoveredProject {
   assets?: DiscoveredAsset[];
+  /**
+   * Conventional `skills/<name>/SKILL.md` documents that explicit `skills`
+   * configuration leaves uncovered — the confusable shadowed state surfaced
+   * by the AB4734 migration nudge. Absent when config is silent (the
+   * convention itself applies) or when every conventional skill is covered.
+   */
+  shadowedConventionalSkills?: readonly string[];
   skills: SkillDocument[];
 }
 
@@ -31,7 +43,7 @@ const expandConfiguredSkill = async (projectRoot: string, skill: string): Promis
     onlyFiles: false,
   });
   return matches
-    .filter((match) => match.dirent.isDirectory() || match.name === 'SKILL.md')
+    .filter((match) => match.dirent.isDirectory() || isSkillDocumentName(match.name))
     .map((match) => match.path);
 };
 
@@ -89,23 +101,36 @@ export const discoverProject = async (
   const projectRoot = resolve(root);
   const rules = await readProjectIgnoreRules(projectRoot);
   const configuredSkills = config.skills;
+  const conventionalSources = (await fastGlob('skills/*/SKILL.{md,ts,tsx}', {
+    absolute: true,
+    cwd: projectRoot,
+    dot: true,
+    followSymbolicLinks: false,
+    onlyFiles: true,
+  })).filter((source) => !isProjectPathIgnored(rules, projectRoot, source));
   const sources =
     configuredSkills === undefined
-      ? await fastGlob('skills/*/SKILL.md', {
-          absolute: true,
-          cwd: projectRoot,
-          dot: true,
-          followSymbolicLinks: false,
-          onlyFiles: true,
-        })
+      ? conventionalSources
       : (await Promise.all(configuredSkills.map((skill) => expandConfiguredSkill(projectRoot, skill)))).flat();
   const skillDirs = [...new Set(sources
     .filter((source) => !isProjectPathIgnored(rules, projectRoot, source))
-    .map((source) => (basename(source) === 'SKILL.md' ? dirname(source) : source)))]
+    .map((source) => (isSkillDocumentName(basename(source)) ? dirname(source) : source)))]
     .sort((left, right) => left.localeCompare(right));
+  const coveredDirs = new Set(skillDirs);
+  const shadowedByDir = new Map<string, string>();
+  if (configuredSkills !== undefined) {
+    for (const source of [...conventionalSources].sort((left, right) => left.localeCompare(right))) {
+      const skillDir = dirname(source);
+      if (!coveredDirs.has(skillDir) && !shadowedByDir.has(skillDir)) {
+        shadowedByDir.set(skillDir, source);
+      }
+    }
+  }
+  const shadowedConventionalSkills = [...shadowedByDir.values()];
 
   return {
     assets: await discoverAssets(projectRoot, config.assets, rules),
+    ...(shadowedConventionalSkills.length === 0 ? {} : { shadowedConventionalSkills }),
     skills: await Promise.all(
       skillDirs.map((skillDir) => parseSkill(skillDir, projectRoot, rules)),
     ),
diff --git a/packages/agent-bundle/src/config/normalize.ts b/packages/agent-bundle/src/config/normalize.ts
index cab329de8..80527b186 100644
--- a/packages/agent-bundle/src/config/normalize.ts
+++ b/packages/agent-bundle/src/config/normalize.ts
@@ -657,6 +657,7 @@ export const normalizeProject = async (
       dir: skill.dir,
       frontmatter,
       id: `skill:${name}`,
+      ...(skill.rendered === true ? { markdown: skill.markdown } : {}),
       name,
       provenance: skillProvenance(loaded, skill.source),
       resources: skill.resources.map((resource) => ({ ...resource })),
diff --git a/packages/agent-bundle/src/config/render-markdown.ts b/packages/agent-bundle/src/config/render-markdown.ts
new file mode 100644
index 000000000..988c2edcf
--- /dev/null
+++ b/packages/agent-bundle/src/config/render-markdown.ts
@@ -0,0 +1,260 @@
+/**
+ * The minimal honest React-element-tree → Markdown renderer behind rendered
+ * skills (`skills/<name>/SKILL.tsx`). It walks plain element objects (the
+ * shape React's automatic JSX runtime produces) without depending on React
+ * itself, resolves function components (sync or async), and hand-emits
+ * Markdown for a documented element subset. Anything outside the subset is a
+ * `MarkdownRenderError` naming the element — never a silent approximation.
+ *
+ * Supported elements: `h1`–`h6`, `p`, `ul`/`ol`/`li` (nested), `strong`/`b`,
+ * `em`/`i`, `code`, `pre` (fenced, `language-*` class), `blockquote`, `a`,
+ * `hr`, `br`, fragments, arrays, strings, and numbers.
+ */
+
+const reactFragment = Symbol.for('react.fragment');
+
+/** Resolution depth cap: a component chain deeper than this is a cycle. */
+const maxComponentDepth = 256;
+
+type ElementProps = Readonly<Record<string, unknown>> & { readonly children?: unknown };
+
+interface ElementLike {
+  readonly props: ElementProps;
+  readonly type: unknown;
+}
+
+export class MarkdownRenderError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'MarkdownRenderError';
+  }
+}
+
+const isElementLike = (value: unknown): value is ElementLike =>
+  typeof value === 'object' &&
+  value !== null &&
+  'type' in value &&
+  'props' in value &&
+  typeof (value as ElementLike).props === 'object' &&
+  (value as ElementLike).props !== null;
+
+const isThenable = (value: unknown): value is PromiseLike<unknown> =>
+  typeof value === 'object' && value !== null && typeof (value as PromiseLike<unknown>).then === 'function';
+
+const componentName = (type: unknown): string =>
+  typeof type === 'function' && type.name !== '' ? type.name : 'anonymous component';
+
+/** Calls function components (awaiting async ones) until an intrinsic node remains. */
+const resolveNode = async (node: unknown, depth = 0): Promise<unknown> => {
+  if (depth > maxComponentDepth) {
+    throw new MarkdownRenderError('Rendered skill component resolution exceeded the depth limit; check for a component rendering itself.');
+  }
+  if (!isElementLike(node) || typeof node.type !== 'function') return node;
+  let rendered: unknown;
+  try {
+    rendered = (node.type as (props: ElementProps) => unknown)(node.props);
+  } catch (error) {
+    throw new MarkdownRenderError(
+      `Rendered skill component ${componentName(node.type)} threw: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+  return resolveNode(isThenable(rendered) ? await rendered : rendered, depth + 1);
+};
+
+const childrenOf = (element: ElementLike): unknown => element.props.children;
+
+/** Flattens arrays and fragments into one resolved child list. */
+const resolveChildren = async (node: unknown): Promise<unknown[]> => {
+  const resolved = await resolveNode(node);
+  if (resolved === null || resolved === undefined || typeof resolved === 'boolean') return [];
+  if (Array.isArray(resolved)) {
+    const nested = await Promise.all(resolved.map((child) => resolveChildren(child)));
+    return nested.flat();
+  }
+  if (isElementLike(resolved) && resolved.type === reactFragment) {
+    return resolveChildren(childrenOf(resolved));
+  }
+  return [resolved];
+};
+
+const unsupported = (tag: string): never => {
+  throw new MarkdownRenderError(
+    `Rendered skill content contains unsupported element <${tag}>; supported elements are h1-h6, p, ul, ol, li, strong, b, em, i, code, pre, blockquote, a, hr, br, and fragments. Write the construct as plain Markdown text or hand-author SKILL.md instead.`,
+  );
+};
+
+const headingLevels: Readonly<Record<string, number>> = Object.freeze({
+  h1: 1, h2: 2, h3: 3, h4: 4, h5: 5, h6: 6,
+});
+
+const inlineTags = new Set(['a', 'b', 'br', 'code', 'em', 'i', 'strong']);
+
+const flattenTextChildren = async (node: unknown, tag: string): Promise<string> => {
+  const children = await resolveChildren(node);
+  let text = '';
+  for (const child of children) {
+    if (typeof child === 'string' || typeof child === 'number') {
+      text += String(child);
+      continue;
+    }
+    throw new MarkdownRenderError(`<${tag}> in rendered skill content may contain only text.`);
+  }
+  return text;
+};
+
+const renderInline = async (node: unknown): Promise<string> => {
+  const children = await resolveChildren(node);
+  let text = '';
+  for (const child of children) {
+    if (typeof child === 'string' || typeof child === 'number') {
+      text += String(child);
+      continue;
+    }
+    if (!isElementLike(child) || typeof child.type !== 'string') {
+      throw new MarkdownRenderError('Rendered skill content contains a value that is neither text nor a supported element.');
+    }
+    const tag = child.type;
+    switch (tag) {
+      case 'strong':
+      case 'b':
+        text += `**${await renderInline(childrenOf(child))}**`;
+        break;
+      case 'em':
+      case 'i':
+        text += `*${await renderInline(childrenOf(child))}*`;
+        break;
+      case 'code':
+        text += `\`${await flattenTextChildren(childrenOf(child), 'code')}\``;
+        break;
+      case 'a': {
+        const href = child.props.href;
+        if (typeof href !== 'string' || href === '') {
+          throw new MarkdownRenderError('<a> in rendered skill content requires a nonempty string href.');
+        }
+        text += `[${await renderInline(childrenOf(child))}](${href})`;
+        break;
+      }
+      case 'br':
+        text += '  \n';
+        break;
+      default:
+        unsupported(tag);
+    }
+  }
+  return text;
+};
+
+const fenceLanguage = (codeElement: ElementLike): string => {
+  const className = codeElement.props.className;
+  if (typeof className !== 'string') return '';
+  const match = /(?:^|\s)language-([\w+-]+)/u.exec(className);
+  return match?.[1] ?? '';
+};
+
+const renderCodeBlock = async (pre: ElementLike): Promise<string> => {
+  const children = await resolveChildren(childrenOf(pre));
+  let language = '';
+  let text = '';
+  for (const child of children) {
+    if (typeof child === 'string' || typeof child === 'number') {
+      text += String(child);
+      continue;
+    }
+    if (isElementLike(child) && child.type === 'code') {
+      language = fenceLanguage(child);
+      text += await flattenTextChildren(childrenOf(child), 'code');
+      continue;
+    }
+    throw new MarkdownRenderError('<pre> in rendered skill content may contain only text or one <code> element.');
+  }
+  const body = text.endsWith('\n') ? text.slice(0, -1) : text;
+  return `\`\`\`${language}\n${body}\n\`\`\``;
+};
+
+const indentContinuation = (text: string, indent: string): string =>
+  text.split('\n').map((line, index) => (index === 0 || line === '' ? line : `${indent}${line}`)).join('\n');
+
+const renderListItem = async (item: unknown, marker: string): Promise<string> => {
+  if (!isElementLike(item) || item.type !== 'li') {
+    throw new MarkdownRenderError('<ul> and <ol> in rendered skill content may contain only <li> elements.');
+  }
+  const blocks = await renderBlocks(childrenOf(item));
+  const indent = ' '.repeat(marker.length);
+  return `${marker}${indentContinuation(blocks.join('\n\n'), indent)}`;
+};
+
+const renderList = async (list: ElementLike): Promise<string> => {
+  const items = await resolveChildren(childrenOf(list));
+  const rendered = await Promise.all(items.map((item, index) =>
+    renderListItem(item, list.type === 'ol' ? `${index + 1}. ` : '- ')));
+  if (rendered.length === 0) {
+    throw new MarkdownRenderError('<ul> and <ol> in rendered skill content require at least one <li>.');
+  }
+  return rendered.join('\n');
+};
+
+const renderBlockElement = async (element: ElementLike): Promise<string> => {
+  const tag = element.type as string;
+  const heading = headingLevels[tag];
+  if (heading !== undefined) {
+    return `${'#'.repeat(heading)} ${await renderInline(childrenOf(element))}`;
+  }
+  switch (tag) {
+    case 'p':
+      return renderInline(childrenOf(element));
+    case 'ul':
+    case 'ol':
+      return renderList(element);
+    case 'pre':
+      return renderCodeBlock(element);
+    case 'blockquote': {
+      const blocks = await renderBlocks(childrenOf(element));
+      return blocks.join('\n\n').split('\n').map((line) => (line === '' ? '>' : `> ${line}`)).join('\n');
+    }
+    case 'hr':
+      return '---';
+    default:
+      return unsupported(tag);
+  }
+};
+
+/** Renders children as a sequence of Markdown blocks; loose inline content coalesces into paragraphs. */
+const renderBlocks = async (node: unknown): Promise<string[]> => {
+  const children = await resolveChildren(node);
+  const blocks: string[] = [];
+  let paragraph = '';
+  const flush = (): void => {
+    const trimmed = paragraph.trim();
+    if (trimmed !== '') blocks.push(trimmed);
+    paragraph = '';
+  };
+  for (const child of children) {
+    if (typeof child === 'string' || typeof child === 'number') {
+      paragraph += String(child);
+      continue;
+    }
+    if (!isElementLike(child) || typeof child.type !== 'string') {
+      throw new MarkdownRenderError('Rendered skill content contains a value that is neither text nor a supported element.');
+    }
+    if (inlineTags.has(child.type)) {
+      paragraph += await renderInline([child]);
+      continue;
+    }
+    flush();
+    blocks.push(await renderBlockElement(child));
+  }
+  flush();
+  return blocks;
+};
+
+/**
+ * Renders one resolved element tree to a Markdown document body ending in a
+ * single trailing newline. Throws `MarkdownRenderError` outside the subset.
+ */
+export const renderElementToMarkdown = async (node: unknown): Promise<string> => {
+  const blocks = await renderBlocks(node);
+  if (blocks.length === 0) {
+    throw new MarkdownRenderError('Rendered skill content produced no Markdown.');
+  }
+  return `${blocks.join('\n\n')}\n`;
+};
diff --git a/packages/agent-bundle/src/config/rendered-skill.ts b/packages/agent-bundle/src/config/rendered-skill.ts
new file mode 100644
index 000000000..75d94b3a0
--- /dev/null
+++ b/packages/agent-bundle/src/config/rendered-skill.ts
@@ -0,0 +1,131 @@
+import { existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { createJiti } from 'jiti';
+import { stringify as stringifyYaml } from 'yaml';
+
+import type { Diagnostic } from '../core/diagnostics.ts';
+import { MarkdownRenderError, renderElementToMarkdown } from './render-markdown.ts';
+
+/**
+ * The rendered-skill convention: `skills/<name>/SKILL.tsx` (or `.ts`)
+ * default-exports a component and exports a `frontmatter` record; the build
+ * compiles the rendered tree to the `SKILL.md` document every host consumes.
+ * A hand-authored `SKILL.md` in the same directory always wins (config beats
+ * convention; an authored file beats a generated one).
+ */
+const renderedSkillFileNames = ['SKILL.tsx', 'SKILL.ts'] as const;
+
+/** The source file behind a rendered skill in `skillDir`, when the convention applies. */
+export const renderedSkillSourceAt = (skillDir: string): string | undefined => {
+  for (const fileName of renderedSkillFileNames) {
+    const candidate = join(skillDir, fileName);
+    try {
+      if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+    } catch {
+      // A racing deletion means the convention does not apply.
+    }
+  }
+  return undefined;
+};
+
+/** True for the conventional rendered-skill source file names. */
+export const isRenderedSkillSourceName = (fileName: string): boolean =>
+  (renderedSkillFileNames as readonly string[]).includes(fileName);
+
+export interface CompiledRenderedSkill {
+  readonly body: string;
+  readonly frontmatter: Record<string, unknown>;
+  /** The full compiled document: YAML frontmatter followed by the rendered body. */
+  readonly markdown: string;
+}
+
+export type RenderedSkillCompilation =
+  | { readonly document: CompiledRenderedSkill; readonly status: 'compiled' }
+  | { readonly diagnostic: Diagnostic; readonly status: 'failed' };
+
+const failure = (code: string, message: string, sourcePath: string): RenderedSkillCompilation => ({
+  diagnostic: { code, message, severity: 'error', sourcePath },
+  status: 'failed',
+});
+
+const isPlainRecord = (value: unknown): value is Record<string, unknown> => {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+
+const describeError = (error: unknown): string =>
+  error instanceof Error ? error.message : String(error);
+
+/**
+ * Loads and compiles one rendered skill source to its Markdown document. The
+ * module executes through the same jiti pipeline that already runs consumer
+ * TypeScript at config-load time, with the automatic JSX runtime resolved
+ * from the consumer project.
+ */
+export const compileRenderedSkill = async (source: string): Promise<RenderedSkillCompilation> => {
+  let moduleExports: Record<string, unknown>;
+  try {
+    const jiti = createJiti(source, {
+      interopDefault: true,
+      jsx: { runtime: 'automatic' },
+      moduleCache: false,
+      nativeModules: ['typescript'],
+    });
+    moduleExports = await jiti.import<Record<string, unknown>>(source);
+  } catch (error) {
+    return failure('AB3003', `Rendered Skill module failed to load: ${describeError(error)}`, source);
+  }
+
+  const component = moduleExports.default;
+  if (typeof component !== 'function') {
+    return failure(
+      'AB3004',
+      'Rendered Skill module must default-export a component function.',
+      source,
+    );
+  }
+  const frontmatter = moduleExports.frontmatter;
+  if (!isPlainRecord(frontmatter)) {
+    return failure(
+      'AB3004',
+      'Rendered Skill module must export a `frontmatter` record with the skill name and description.',
+      source,
+    );
+  }
+
+  let body: string;
+  try {
+    body = await renderElementToMarkdown({ props: {}, type: component });
+  } catch (error) {
+    return failure(
+      'AB3005',
+      error instanceof MarkdownRenderError
+        ? error.message
+        : `Rendered Skill content failed to render: ${describeError(error)}`,
+      source,
+    );
+  }
+
+  let serializedFrontmatter: string;
+  try {
+    serializedFrontmatter = stringifyYaml(frontmatter);
+  } catch (error) {
+    return failure(
+      'AB3004',
+      `Rendered Skill frontmatter is not serializable YAML: ${describeError(error)}`,
+      source,
+    );
+  }
+
+  const snapshot = structuredClone(frontmatter);
+  return {
+    document: {
+      body,
+      frontmatter: snapshot,
+      markdown: `---\n${serializedFrontmatter}---\n\n${body}`,
+    },
+    status: 'compiled',
+  };
+};
diff --git a/packages/agent-bundle/src/config/skill.ts b/packages/agent-bundle/src/config/skill.ts
index 1cc20df47..c804946c2 100644
--- a/packages/agent-bundle/src/config/skill.ts
+++ b/packages/agent-bundle/src/config/skill.ts
@@ -11,6 +11,11 @@ import {
   readProjectIgnoreRules,
   toPosixPath,
 } from './ignore.ts';
+import {
+  compileRenderedSkill,
+  isRenderedSkillSourceName,
+  renderedSkillSourceAt,
+} from './rendered-skill.ts';
 import { parseSkillMarkdown } from './skill-references.ts';
 
 export interface SkillResource {
@@ -26,6 +31,12 @@ export interface SkillDocument {
   frontmatter: Record<string, unknown>;
   /** Exact authored/emitted Markdown; splitting remains server-owned. */
   markdown: string;
+  /**
+   * Present when the document was compiled from the rendered-skill convention
+   * (`SKILL.tsx`/`SKILL.ts`): `source` names the component module, and
+   * `markdown` holds the compiled document the build must emit as SKILL.md.
+   */
+  rendered?: true;
   resources: SkillResource[];
   source: string;
 }
@@ -64,7 +75,10 @@ const resourceList = async (
     onlyFiles: true,
   });
   const includedSources = sources.filter(
-    (source) => !isProjectPathIgnored(rules, root, source),
+    (source) =>
+      !isProjectPathIgnored(rules, root, source) &&
+      // The rendered-skill source files are build inputs, never shipped resources.
+      !isRenderedSkillSourceName(toPosixPath(relative(skillDir, source))),
   );
 
   return Promise.all(
@@ -96,6 +110,44 @@ const malformedFrontmatter = (source: string, error: unknown): Diagnostic => ({
   sourcePath: source,
 });
 
+const renderedSourceShadowNudge = (source: string, renderedSource: string): Diagnostic => ({
+  code: 'AB4735',
+  severity: 'info',
+  message: `${renderedSource} is present but the hand-authored SKILL.md wins; the rendered skill source is shadowed.`,
+  recovery: 'Optional: remove SKILL.md to adopt the rendered skill, or remove the component module to silence this nudge.',
+  sourcePath: source,
+});
+
+const parseRenderedSkill = async (
+  dir: string,
+  renderedSource: string,
+  resources: SkillResource[],
+): Promise<SkillDocument> => {
+  const compiled = await compileRenderedSkill(renderedSource);
+  if (compiled.status === 'failed') {
+    return {
+      body: '',
+      diagnostics: [compiled.diagnostic],
+      dir,
+      frontmatter: {},
+      markdown: '',
+      rendered: true,
+      resources,
+      source: renderedSource,
+    };
+  }
+  return {
+    body: compiled.document.body,
+    diagnostics: [],
+    dir,
+    frontmatter: compiled.document.frontmatter,
+    markdown: compiled.document.markdown,
+    rendered: true,
+    resources,
+    source: renderedSource,
+  };
+};
+
 export const parseSkill = async (
   skillDir: string,
   projectRoot?: string,
@@ -107,11 +159,15 @@ export const parseSkill = async (
   const root = projectRoot === undefined ? await findProjectRoot(dir) : resolve(projectRoot);
   const rules = projectIgnoreRules ?? await readProjectIgnoreRules(root);
   const resources = await resourceList(dir, root, rules);
+  const renderedSource = renderedSkillSourceAt(dir);
 
   let markdown: string;
   try {
     markdown = await readFile(source, 'utf8');
   } catch (error: unknown) {
+    if (renderedSource !== undefined && isErrno(error, 'ENOENT')) {
+      return parseRenderedSkill(dir, renderedSource, resources);
+    }
     return {
       body: '',
       diagnostics: [
@@ -130,11 +186,12 @@ export const parseSkill = async (
     };
   }
 
+  const shadowNudges = renderedSource === undefined ? [] : [renderedSourceShadowNudge(source, renderedSource)];
   const parsed = parseSkillMarkdown(markdown);
   if (parsed.status === 'missing-frontmatter') {
     return {
       body: parsed.body,
-      diagnostics: [missingFrontmatter(source)],
+      diagnostics: [missingFrontmatter(source), ...shadowNudges],
       dir,
       frontmatter: {},
       markdown,
@@ -146,7 +203,7 @@ export const parseSkill = async (
   if (parsed.status === 'valid') {
     return {
       body: parsed.body,
-      diagnostics: [],
+      diagnostics: [...shadowNudges],
       dir,
       frontmatter: parsed.frontmatter,
       markdown,
@@ -157,7 +214,7 @@ export const parseSkill = async (
 
   return {
     body: parsed.body,
-    diagnostics: [malformedFrontmatter(source, parsed.message)],
+    diagnostics: [malformedFrontmatter(source, parsed.message), ...shadowNudges],
     dir,
     frontmatter: {},
     markdown,
diff --git a/packages/agent-bundle/src/config/validate.ts b/packages/agent-bundle/src/config/validate.ts
index d61a82768..8e4fb5418 100644
--- a/packages/agent-bundle/src/config/validate.ts
+++ b/packages/agent-bundle/src/config/validate.ts
@@ -936,6 +936,21 @@ const packageConventionShadowNudges = (loaded: LoadedConfig): Diagnostic[] => {
   return diagnostics;
 };
 
+/**
+ * AB4734: explicit `skills` configuration leaves a conventional
+ * `skills/<name>/SKILL.md` document uncovered, so the convention is silently
+ * shadowed — the skills-directory analogue of AB4731/AB4732/AB4733.
+ */
+const skillConventionShadowNudges = (
+  loaded: LoadedConfig,
+  discovered: DiscoveredProject,
+): Diagnostic[] => (discovered.shadowedConventionalSkills ?? []).map((source) => nudgeDiagnostic(
+  'AB4734',
+  `${relativePosix(loaded.context.projectRoot, source)} is present but explicit skills configuration does not cover it; the conventional skill is shadowed.`,
+  source,
+  'Optional: remove the explicit skills configuration to adopt the skills/<name>/SKILL.md convention, add the directory to skills, or remove it to silence this nudge.',
+));
+
 const isRspackHatchValue = (value: unknown): boolean =>
   typeof value === 'function' || isRecord(value);
 
@@ -1035,6 +1050,7 @@ export const validateSource = (
   diagnostics.push(...validateScripts(loaded, registry));
   diagnostics.push(...validateTools(loaded));
   diagnostics.push(...packageConventionShadowNudges(loaded));
+  diagnostics.push(...skillConventionShadowNudges(loaded, discovered));
 
   return diagnostics;
 };
@@ -1226,6 +1242,13 @@ export const validateModel = (
   };
   for (const target of model.targets) {
     for (const skill of model.skills) {
+      if (skill.markdown !== undefined) {
+        recordOutput(
+          posix.join(target.name, 'skills', skill.name, 'SKILL.md'),
+          skill.source,
+          target.name,
+        );
+      }
       for (const resource of skill.resources) {
         recordOutput(
           posix.join(target.name, 'skills', skill.name, resource.relativePath),
diff --git a/packages/agent-bundle/src/core/types.ts b/packages/agent-bundle/src/core/types.ts
index 5b5105b76..14af61dbe 100644
--- a/packages/agent-bundle/src/core/types.ts
+++ b/packages/agent-bundle/src/core/types.ts
@@ -225,6 +225,12 @@ export interface NormalizedSkill {
   readonly dir: string;
   readonly frontmatter: Readonly<Record<string, unknown>>;
   readonly id: string;
+  /**
+   * The compiled SKILL.md document of a rendered skill (`SKILL.tsx`
+   * convention). When present, adapters emit it as a generated write entry;
+   * static skills ship their authored SKILL.md as a copied resource instead.
+   */
+  readonly markdown?: string;
   readonly name: string;
   readonly provenance: SourceProvenance;
   readonly resources: readonly NormalizedSkillResource[];
diff --git a/packages/agent-bundle/tests/config.test.ts b/packages/agent-bundle/tests/config.test.ts
index e05e48ea7..31eee1be8 100644
--- a/packages/agent-bundle/tests/config.test.ts
+++ b/packages/agent-bundle/tests/config.test.ts
@@ -87,6 +87,9 @@ it('honors an explicit empty skills list instead of conventional discovery', asy
 
     await expect(discoverProject(fixture.root, loaded.config)).resolves.toEqual({
       assets: [],
+      // The conventional skill stays undiscovered but is reported as shadowed
+      // so validation can raise the AB4734 nudge.
+      shadowedConventionalSkills: [fixture.skillSource],
       skills: [],
     });
   } finally {
diff --git a/packages/agent-bundle/tests/fixtures/rendered-skill/skills/deploy-checklist/SKILL.tsx b/packages/agent-bundle/tests/fixtures/rendered-skill/skills/deploy-checklist/SKILL.tsx
new file mode 100644
index 000000000..04bd94b32
--- /dev/null
+++ b/packages/agent-bundle/tests/fixtures/rendered-skill/skills/deploy-checklist/SKILL.tsx
@@ -0,0 +1,48 @@
+/**
+ * A rendered skill: the component tree below compiles to the SKILL.md this
+ * directory ships. The frontmatter export carries the document metadata.
+ */
+
+interface StepProps {
+  readonly detail: string;
+  readonly title: string;
+}
+
+const Step = ({ detail, title }: StepProps) => (
+  <li>
+    <strong>{title}</strong> — {detail}
+  </li>
+);
+
+export const frontmatter = {
+  description: 'Walks a release through the deploy checklist with rendered, data-driven steps.',
+  name: 'deploy-checklist',
+};
+
+const steps: readonly StepProps[] = [
+  { detail: 'Green build on main.', title: 'CI' },
+  { detail: 'Changelog covers every merged PR.', title: 'Notes' },
+];
+
+export default function DeployChecklist() {
+  return (
+    <>
+      <h1>Deploy checklist</h1>
+      <p>
+        Run every step <em>in order</em>; the playbook in{' '}
+        <a href="references/playbook.md">references/playbook.md</a> has the details.
+      </p>
+      <ol>
+        {steps.map((step) => (
+          <Step detail={step.detail} key={step.title} title={step.title} />
+        ))}
+      </ol>
+      <pre>
+        <code className="language-sh">{'agent-bundle build\n'}</code>
+      </pre>
+      <blockquote>
+        <p>Ship only when the checklist is green.</p>
+      </blockquote>
+    </>
+  );
+}
diff --git a/packages/agent-bundle/tests/fixtures/rendered-skill/skills/deploy-checklist/references/playbook.md b/packages/agent-bundle/tests/fixtures/rendered-skill/skills/deploy-checklist/references/playbook.md
new file mode 100644
index 000000000..b2d7f1503
--- /dev/null
+++ b/packages/agent-bundle/tests/fixtures/rendered-skill/skills/deploy-checklist/references/playbook.md
@@ -0,0 +1,3 @@
+# Deploy playbook
+
+The long-form companion the rendered checklist links to.
diff --git a/packages/agent-bundle/tests/package-conventions.test.ts b/packages/agent-bundle/tests/package-conventions.test.ts
index 05d08246f..1cf0bea02 100644
--- a/packages/agent-bundle/tests/package-conventions.test.ts
+++ b/packages/agent-bundle/tests/package-conventions.test.ts
@@ -5,6 +5,7 @@ import { join } from 'node:path';
 import { afterEach, describe, expect, it } from '@rstest/core';
 
 import {
+  discoverProject,
   normalizeProject,
   validateSource,
   type NormalizationTargetRegistry,
@@ -425,6 +426,57 @@ describe('migration nudges (AB473x)', () => {
     expect(diagnostics).toEqual([]);
   });
 
+  const skillMarkdown = (name: string): string =>
+    `---\nname: ${name}\ndescription: The ${name} skill for nudge coverage.\n---\n\n# ${name}\n\nBody.\n`;
+
+  const discoveredAndValidated = async (
+    config: Omit<AgentBundleConfig, 'plugin'>,
+    files: Readonly<Record<string, string>>,
+  ) => {
+    const root = await projectRoot(files);
+    const loaded = loadedProject({
+      ...config,
+      plugin: { name: 'review-tools', version: '1.0.0' },
+    }, root);
+    const discovered = await discoverProject(root, loaded.config);
+    return { diagnostics: validateSource(loaded, discovered, registry), root };
+  };
+
+  it('nudges AB4734 when explicit skills configuration shadows a conventional skill', async () => {
+    const { diagnostics, root } = await discoveredAndValidated(
+      { skills: ['skills/covered'] },
+      {
+        'skills/covered/SKILL.md': skillMarkdown('covered'),
+        'skills/shadowed/SKILL.md': skillMarkdown('shadowed'),
+      },
+    );
+    expect(diagnostics).toEqual([{
+      code: 'AB4734',
+      message: expect.stringContaining('skills/shadowed/SKILL.md'),
+      recovery: expect.stringContaining('Optional'),
+      severity: 'info',
+      sourcePath: `${root}/skills/shadowed/SKILL.md`,
+    }]);
+  });
+
+  it('stays silent when skills config is absent or covers every conventional skill', async () => {
+    const files = {
+      'skills/one/SKILL.md': skillMarkdown('one'),
+      'skills/two/SKILL.md': skillMarkdown('two'),
+    };
+    const conventional = await discoveredAndValidated({}, files);
+    expect(conventional.diagnostics).toEqual([]);
+
+    const globCovered = await discoveredAndValidated({ skills: ['skills/*'] }, files);
+    expect(globCovered.diagnostics).toEqual([]);
+
+    const literalCovered = await discoveredAndValidated(
+      { skills: ['skills/one', 'skills/two/SKILL.md'] },
+      files,
+    );
+    expect(literalCovered.diagnostics).toEqual([]);
+  });
+
   it('never raises nudges above info severity', async () => {
     const { diagnostics } = await validated(
       {
diff --git a/packages/agent-bundle/tests/rendered-skills.test.ts b/packages/agent-bundle/tests/rendered-skills.test.ts
new file mode 100644
index 000000000..019e0eb83
--- /dev/null
+++ b/packages/agent-bundle/tests/rendered-skills.test.ts
@@ -0,0 +1,293 @@
+import { mkdir, mkdtemp, realpath, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, describe, expect, it } from '@rstest/core';
+
+import {
+  discoverProject,
+  normalizeProject,
+  parseSkill,
+  validateSource,
+  type NormalizationTargetRegistry,
+} from '../src/config/index.ts';
+import { compileRenderedSkill } from '../src/config/rendered-skill.ts';
+import { renderElementToMarkdown } from '../src/config/render-markdown.ts';
+import { standardPluginArtifactPlan } from '../src/adapters/types.ts';
+import type { AgentBundleConfig } from '../src/core/types.ts';
+import type { LoadedConfig } from '../src/config/load.ts';
+
+const fixtureRoot = join(import.meta.dirname, 'fixtures', 'rendered-skill');
+
+const registry: NormalizationTargetRegistry = {
+  configExtensions: () => [],
+  defaultTargetNames: () => ['portable'],
+  has: (name) => ['portable', 'codex', 'claude'].includes(name),
+  supports: () => true,
+};
+
+const roots: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { force: true, recursive: true })));
+});
+
+const projectRoot = async (files: Readonly<Record<string, string>>): Promise<string> => {
+  const root = await realpath(await mkdtemp(join(tmpdir(), 'agent-bundle-rendered-skill-')));
+  roots.push(root);
+  for (const [path, contents] of Object.entries(files)) {
+    const destination = join(root, path);
+    await mkdir(join(destination, '..'), { recursive: true });
+    await writeFile(destination, contents);
+  }
+  return root;
+};
+
+const loadedProject = (config: AgentBundleConfig, root: string): LoadedConfig => ({
+  config,
+  configPath: `${root}/agent-bundle.config.ts`,
+  context: {
+    command: 'build',
+    mode: 'production',
+    projectRoot: root,
+    selectedTargets: [],
+  },
+});
+
+/** Element helper mirroring the plain object shape the automatic JSX runtime produces. */
+const element = (type: unknown, props: Record<string, unknown> = {}): Record<string, unknown> =>
+  ({ props, type });
+
+describe('renderElementToMarkdown', () => {
+  it('renders the supported block and inline subset', async () => {
+    const markdown = await renderElementToMarkdown([
+      element('h2', { children: 'Steps' }),
+      'Loose text with ',
+      element('code', { children: 'inline()' }),
+      ' calls.',
+      element('ul', {
+        children: [
+          element('li', { children: ['First ', element('em', { children: 'gently' })] }),
+          element('li', {
+            children: [
+              'Second',
+              element('ul', { children: [element('li', { children: 'Nested detail' })] }),
+            ],
+          }),
+        ],
+      }),
+      element('hr'),
+      element('p', { children: ['Line one', element('br'), 'line two'] }),
+    ]);
+
+    expect(markdown).toBe([
+      '## Steps',
+      '',
+      'Loose text with `inline()` calls.',
+      '',
+      '- First *gently*',
+      '- Second',
+      '',
+      '  - Nested detail',
+      '',
+      '---',
+      '',
+      'Line one  \nline two',
+      '',
+    ].join('\n'));
+  });
+
+  it('resolves sync and async function components', async () => {
+    const Title = () => element('h1', { children: 'Rendered' });
+    const Body = async () => element('p', { children: 'From an async component.' });
+    const markdown = await renderElementToMarkdown([element(Title), element(Body)]);
+    expect(markdown).toBe('# Rendered\n\nFrom an async component.\n');
+  });
+
+  it('rejects unsupported elements by name', async () => {
+    await expect(renderElementToMarkdown(element('table'))).rejects.toThrow('unsupported element <table>');
+    await expect(renderElementToMarkdown(element('p', { children: element('img', { src: 'x.png' }) })))
+      .rejects.toThrow('unsupported element <img>');
+  });
+
+  it('rejects an empty document and a self-rendering component', async () => {
+    await expect(renderElementToMarkdown([])).rejects.toThrow('produced no Markdown');
+    const Loop = (): Record<string, unknown> => element(Loop);
+    await expect(renderElementToMarkdown(element(Loop))).rejects.toThrow('depth limit');
+  });
+});
+
+describe('rendered skill compilation', () => {
+  const expectedBody = [
+    '# Deploy checklist',
+    '',
+    'Run every step *in order*; the playbook in [references/playbook.md](references/playbook.md) has the details.',
+    '',
+    '1. **CI** — Green build on main.',
+    '2. **Notes** — Changelog covers every merged PR.',
+    '',
+    '```sh',
+    'agent-bundle build',
+    '```',
+    '',
+    '> Ship only when the checklist is green.',
+    '',
+  ].join('\n');
+
+  it('compiles the JSX fixture through jiti to the full SKILL.md document', async () => {
+    const compiled = await compileRenderedSkill(
+      join(fixtureRoot, 'skills', 'deploy-checklist', 'SKILL.tsx'),
+    );
+    expect(compiled.status).toBe('compiled');
+    if (compiled.status !== 'compiled') return;
+    expect(compiled.document.markdown).toBe([
+      '---',
+      'description: Walks a release through the deploy checklist with rendered, data-driven steps.',
+      'name: deploy-checklist',
+      '---',
+      '',
+      expectedBody,
+    ].join('\n'));
+  });
+
+  it('parses a rendered skill directory: compiled body, module source, no source-file resource', async () => {
+    const skill = await parseSkill(join(fixtureRoot, 'skills', 'deploy-checklist'), fixtureRoot);
+    expect(skill.diagnostics).toEqual([]);
+    expect(skill.rendered).toBe(true);
+    expect(skill.source.endsWith('SKILL.tsx')).toBe(true);
+    expect(skill.body).toBe(expectedBody);
+    expect(skill.frontmatter).toEqual({
+      description: 'Walks a release through the deploy checklist with rendered, data-driven steps.',
+      name: 'deploy-checklist',
+    });
+    expect(skill.resources.map((resource) => resource.relativePath)).toEqual(['references/playbook.md']);
+  });
+
+  it('discovers rendered-only skill directories by convention and validates them cleanly', async () => {
+    const loaded = loadedProject({ plugin: { name: 'rendered', version: '1.0.0' } }, fixtureRoot);
+    const discovered = await discoverProject(fixtureRoot, loaded.config);
+    expect(discovered.skills.map((skill) => skill.frontmatter.name)).toEqual(['deploy-checklist']);
+    expect(validateSource(loaded, discovered, registry)).toEqual([]);
+
+    const model = await normalizeProject(loaded, discovered, registry);
+    expect(model.skills[0]).toMatchObject({
+      markdown: expect.stringContaining('# Deploy checklist'),
+      provenance: { kind: 'conventional' },
+    });
+  });
+
+  it('emits the compiled SKILL.md as a generated write entry in artifact plans', async () => {
+    const loaded = loadedProject({ plugin: { name: 'rendered', version: '1.0.0' } }, fixtureRoot);
+    const model = await normalizeProject(loaded, await discoverProject(fixtureRoot, loaded.config), registry);
+    const plan = standardPluginArtifactPlan({
+      diagnostics: [],
+      hookDocumentValid: true,
+      hookEntries: [],
+      hookManifestPath: 'hooks/hooks.json',
+      isSelected: () => true,
+      marketplaceRelativePath: 'marketplace.json',
+      marketplaceValid: true,
+      mcpValid: true,
+      model,
+      plugin: {},
+      pluginRelativePath: 'plugin.json',
+      targetName: 'portable',
+    });
+    const skillEntries = plan.entries.filter((entry) => entry.relativePath.startsWith('skills/'));
+    expect(skillEntries).toEqual([
+      expect.objectContaining({
+        content: expect.stringContaining('# Deploy checklist'),
+        kind: 'write',
+        relativePath: 'skills/deploy-checklist/SKILL.md',
+      }),
+      expect.objectContaining({
+        kind: 'copy',
+        relativePath: 'skills/deploy-checklist/references/playbook.md',
+      }),
+    ]);
+  });
+
+  it('loads rendered modules that build plain element objects without react', async () => {
+    const root = await projectRoot({
+      'skills/plain/SKILL.ts': [
+        "export const frontmatter = { description: 'A plain rendered skill.', name: 'plain' };",
+        "const paragraph = { props: { children: 'Composed without JSX.' }, type: 'p' };",
+        "export default () => [{ props: { children: 'Plain' }, type: 'h1' }, paragraph];",
+        '',
+      ].join('\n'),
+    });
+    const skill = await parseSkill(join(root, 'skills', 'plain'), root);
+    expect(skill.diagnostics).toEqual([]);
+    expect(skill.markdown).toBe([
+      '---',
+      'description: A plain rendered skill.',
+      'name: plain',
+      '---',
+      '',
+      '# Plain',
+      '',
+      'Composed without JSX.',
+      '',
+    ].join('\n'));
+  });
+
+  it('reports AB3003 for a module that fails to load', async () => {
+    const root = await projectRoot({
+      'skills/broken/SKILL.ts': "throw new Error('boom');\nexport default () => null;\n",
+    });
+    const skill = await parseSkill(join(root, 'skills', 'broken'), root);
+    expect(skill.diagnostics).toEqual([expect.objectContaining({ code: 'AB3003', severity: 'error' })]);
+  });
+
+  it('reports AB3004 for a missing default component or frontmatter export', async () => {
+    const root = await projectRoot({
+      'skills/no-component/SKILL.ts': "export const frontmatter = { name: 'no-component' };\n",
+      'skills/no-frontmatter/SKILL.ts': "export default () => ({ props: { children: 'x' }, type: 'p' });\n",
+    });
+    const noComponent = await parseSkill(join(root, 'skills', 'no-component'), root);
+    expect(noComponent.diagnostics).toEqual([expect.objectContaining({
+      code: 'AB3004',
+      message: expect.stringContaining('default-export a component'),
+    })]);
+    const noFrontmatter = await parseSkill(join(root, 'skills', 'no-frontmatter'), root);
+    expect(noFrontmatter.diagnostics).toEqual([expect.objectContaining({
+      code: 'AB3004',
+      message: expect.stringContaining('frontmatter'),
+    })]);
+  });
+
+  it('reports AB3005 when the tree renders outside the supported subset', async () => {
+    const root = await projectRoot({
+      'skills/tabular/SKILL.ts': [
+        "export const frontmatter = { description: 'Tables are unsupported.', name: 'tabular' };",
+        "export default () => ({ props: {}, type: 'table' });",
+        '',
+      ].join('\n'),
+    });
+    const skill = await parseSkill(join(root, 'skills', 'tabular'), root);
+    expect(skill.diagnostics).toEqual([expect.objectContaining({
+      code: 'AB3005',
+      message: expect.stringContaining('<table>'),
+    })]);
+  });
+
+  it('nudges AB4735 when a hand-authored SKILL.md shadows the rendered source', async () => {
+    const root = await projectRoot({
+      'skills/both/SKILL.md': '---\nname: both\ndescription: The authored document wins.\n---\n\n# Both\n\nAuthored.\n',
+      'skills/both/SKILL.tsx': [
+        "export const frontmatter = { description: 'Never compiled.', name: 'both' };",
+        "export default () => ({ props: { children: 'Rendered' }, type: 'h1' });",
+        '',
+      ].join('\n'),
+    });
+    const skill = await parseSkill(join(root, 'skills', 'both'), root);
+    expect(skill.rendered).toBeUndefined();
+    expect(skill.body).toContain('Authored.');
+    expect(skill.diagnostics).toEqual([expect.objectContaining({
+      code: 'AB4735',
+      recovery: expect.stringContaining('Optional'),
+      severity: 'info',
+    })]);
+    expect(skill.resources.map((resource) => resource.relativePath)).toEqual(['SKILL.md']);
+  });
+});
diff --git a/packages/create-agent-bundle/templates/minimal/README.md b/packages/create-agent-bundle/templates/minimal/README.md
index be8ec9499..1c71c9b7e 100644
--- a/packages/create-agent-bundle/templates/minimal/README.md
+++ b/packages/create-agent-bundle/templates/minimal/README.md
@@ -16,7 +16,8 @@ npm run check      # validate + build + typecheck + test
 
 - `agent-bundle.config.ts` — the one typed config.
 - `skills/getting-started/` — a Skill: `SKILL.md` frontmatter plus optional
-  `references/` and `assets/`.
+  `references/` and `assets/`. Every `skills/<name>/SKILL.md` directory is
+  discovered automatically; add a folder and it ships.
 - `tests/` — run with `npm run test`.
 
 ## The agent-bundle dependency
diff --git a/packages/create-agent-bundle/templates/minimal/agent-bundle.config.ts b/packages/create-agent-bundle/templates/minimal/agent-bundle.config.ts
index 9438c11b8..12d4d0ea9 100644
--- a/packages/create-agent-bundle/templates/minimal/agent-bundle.config.ts
+++ b/packages/create-agent-bundle/templates/minimal/agent-bundle.config.ts
@@ -1,11 +1,12 @@
 import { defineConfig } from 'agent-bundle';
 
 export default defineConfig({
+  // No `skills` field needed: every `skills/<name>/SKILL.md` directory is
+  // discovered by convention. Declare `skills:` only to override the layout.
   plugin: {
     description: 'A skills-only agent plugin scaffolded from the minimal template.',
     name: 'my-agent-plugin',
     version: '0.1.0',
   },
-  skills: ['skills/getting-started'],
   targets: ['portable', 'codex', 'claude'],
 });
diff --git a/packages/rsc-runtime/README.md b/packages/rsc-runtime/README.md
index 5565e2b0c..1c6d6d604 100644
--- a/packages/rsc-runtime/README.md
+++ b/packages/rsc-runtime/README.md
@@ -27,23 +27,16 @@ exactly as `JSON.stringify` serializes them. Values that cannot round-trip as
 JSON — cycles, accessors, sparse arrays, non-finite numbers, non-plain objects —
 are still rejected, and the error names the offending key path.
 
-## Complete plugin applications
+## Applications
 
-The `@agent-bundle/rsc-runtime/plugin` entry defines an Agent Bundle application
-once and derives its compiler configuration, CLI commands, and MCP tool catalog
-from the same typed operation registry:
+Structure — targets, skills, scripts, MCP servers, MCP apps — lives in
+`agent-bundle.config.ts` and file conventions; JSX renders. The
+`@agent-bundle/rsc-runtime/plugin` entry defines the application's runtime
+identity and typed operation catalog once and derives its CLI commands and
+MCP tool registrations from that one registry:
 
 ```tsx
-import {
-  AgentBundle,
-  McpApp,
-  McpServer,
-  Operation,
-  Script,
-  Skill,
-  defineOperation,
-  defineRscAgentBundle,
-} from '@agent-bundle/rsc-runtime/plugin';
+import { defineOperation, defineRscApplication } from '@agent-bundle/rsc-runtime/plugin';
 import { Mcp } from '@agent-bundle/rsc-runtime';
 import { z } from 'zod';
 
@@ -76,29 +69,21 @@ const status = defineOperation({
   resultSchema,
 });
 
-export const application = defineRscAgentBundle(
-  <AgentBundle name="example" targets={['claude', 'codex']} version="1.0.0">
-    <Skill source="./skills/example" />
-    <Script entry="./src/cli-entry.ts" name="example" />
-    <McpServer entry="./src/mcp-server.ts" name="runtime">
-      <McpApp
-        entry="./views/status-panel.ts"
-        name="status"
-        resourceUri="ui://example/status.html"
-        template="./views/status-panel.html"
-      />
-    </McpServer>
-    <Operation definition={status} />
-  </AgentBundle>,
-);
+export const application = defineRscApplication({
+  name: 'example',
+  operations: [status],
+  version: '1.0.0',
+});
 ```
 
-Export `application.config` from `agent-bundle.config.ts`, use
-`runRscCli(application, argv)` for the executable, and use
-`createRscMcpServer(application, 'runtime')` for stdio MCP. Operation inputs,
-implementations, output validation, and result renderers cannot drift between the
-two surfaces. Definition lowering rejects duplicate ownership and references to
-undeclared MCP servers before Agent Bundle compilation begins.
+Use `runRscCli(application, argv)` in the conventional `src/cli.ts` entry and
+`createRscMcpServer(application, 'runtime')` in the conventional
+`src/mcp/runtime.ts` entry. Operation inputs, implementations, output
+validation, and result renderers cannot drift between the two surfaces, and
+`defineRscApplication` rejects duplicate operation ids, CLI commands, and MCP
+tools up front. The server name passed to `createRscMcpServer` selects the
+operations whose `mcp.server` matches; the server's structural declaration
+(entry, targets, apps) belongs to `agent-bundle.config.ts`.
 
 The optional `mcp.title` and `mcp._meta` ride the tool listing verbatim —
 `_meta: { ui: { resourceUri } }` is how MCP Apps hosts bind a tool to its
@@ -107,17 +92,5 @@ operation declares (`readOnly`, plus `destructive` / `idempotent` /
 `openWorld` when present); absent hints stay absent on the wire, where they
 keep their MCP-spec default semantics.
 
-`<McpApp>` children of `<McpServer>` lower into the owning server's
-`mcp.servers[<name>].apps` record, so `application.config` stays the single
-source of truth for MCP Apps: the compiler bundles each view into a
-self-contained HTML resource served through `import apps from
-'agent-bundle/mcp-apps'`. App `targets` default to the owning server's
-targets. Several servers may serve one shared widget by declaring the same
-`<McpApp>` (identical `name`, `entry`, `resourceUri`, `template`, and
-`_meta`; per-server `targets` may differ) — it compiles once and lands in
-every declaring server's registry. Conflicting redeclarations of an app
-name, or one `resourceUri` spread across different app names, are rejected
-during lowering.
-
 This layer intentionally does not own transport persistence or application
 state. Those remain explicit dependencies of operation implementations.
diff --git a/packages/rsc-runtime/package.json b/packages/rsc-runtime/package.json
index 19820b476..6e2862762 100644
--- a/packages/rsc-runtime/package.json
+++ b/packages/rsc-runtime/package.json
@@ -45,7 +45,6 @@
     "typecheck": "tsc -p tsconfig.build.json --noEmit"
   },
   "peerDependencies": {
-    "agent-bundle": "^0.1.0",
     "react": "^19.2.0"
   },
   "dependencies": {
@@ -58,7 +57,6 @@
     "@rslib/core": "0.23.2",
     "@rstest/core": "0.11.10",
     "@types/react": "19.2.18",
-    "agent-bundle": "workspace:*",
     "react": "19.2.8"
   }
 }
diff --git a/packages/rsc-runtime/src/application.ts b/packages/rsc-runtime/src/application.ts
new file mode 100644
index 000000000..0d29e0ead
--- /dev/null
+++ b/packages/rsc-runtime/src/application.ts
@@ -0,0 +1,62 @@
+import type { RscOperationDefinition } from './operation.js';
+
+/**
+ * Framework mode's application: structure (targets, skills, servers,
+ * scripts) lives in `agent-bundle.config.ts` and file conventions; the
+ * application is only the runtime identity plus the operation catalog whose
+ * results the RSC layer renders.
+ */
+export interface RscApplicationOptions {
+  readonly description?: string;
+  readonly name: string;
+  readonly operations: readonly Readonly<RscOperationDefinition>[];
+  readonly version: string;
+}
+
+export interface RscApplication {
+  readonly description?: string;
+  readonly name: string;
+  readonly operations: readonly Readonly<RscOperationDefinition>[];
+  readonly version: string;
+}
+
+const canonicalName = /^[a-z][a-z0-9._-]{0,63}$/u;
+
+const duplicate = (values: readonly string[], label: string): void => {
+  if (new Set(values).size !== values.length) {
+    throw new Error(`RSC application contains a duplicate ${label}`);
+  }
+};
+
+export const defineRscApplication = (
+  options: RscApplicationOptions,
+): Readonly<RscApplication> => {
+  if (typeof options.name !== 'string' || !canonicalName.test(options.name)) {
+    throw new Error('RSC application name must be a canonical lowercase identifier');
+  }
+  if (typeof options.version !== 'string' || options.version.trim() === '') {
+    throw new Error('RSC application version must be non-empty');
+  }
+  if (options.description !== undefined && (typeof options.description !== 'string' || options.description.trim() === '')) {
+    throw new Error('RSC application description must be non-empty when present');
+  }
+  const operations = [...options.operations];
+  for (const operation of operations) {
+    if (operation === null || typeof operation !== 'object' || !Object.isFrozen(operation)) {
+      throw new Error('RSC application operations must come from defineOperation');
+    }
+  }
+  duplicate(operations.map((operation) => operation.id), 'operation id');
+  duplicate(operations.flatMap((operation) => operation.cli === undefined ? [] : [operation.cli.name]), 'CLI command');
+  duplicate(
+    operations.flatMap((operation) => operation.mcp === undefined ? [] : [`${operation.mcp.server}:${operation.mcp.name}`]),
+    'MCP tool',
+  );
+
+  return Object.freeze({
+    ...(options.description === undefined ? {} : { description: options.description }),
+    name: options.name,
+    operations: Object.freeze(operations),
+    version: options.version,
+  });
+};
diff --git a/packages/rsc-runtime/src/cli.ts b/packages/rsc-runtime/src/cli.ts
index 83fb8cb5d..176da1f60 100644
--- a/packages/rsc-runtime/src/cli.ts
+++ b/packages/rsc-runtime/src/cli.ts
@@ -1,20 +1,19 @@
-import type { RscAgentBundleApplication } from './plugin-definition.js';
+import type { RscApplication } from './application.js';
 
 export interface RscCliOptions {
   readonly signal?: AbortSignal;
   readonly write?: (value: string) => void;
 }
 
-const help = (application: Readonly<RscAgentBundleApplication>): string => {
-  const plugin = application.config.plugin;
+const help = (application: Readonly<RscApplication>): string => {
   const commands = application.operations.flatMap((operation) => operation.cli === undefined
     ? []
     : [`  ${operation.cli.usage.padEnd(34)} ${operation.cli.summary}`]);
-  return `${plugin.name}${plugin.description === undefined ? '' : ` - ${plugin.description}`}\n\nCommands:\n${commands.join('\n')}\n`;
+  return `${application.name}${application.description === undefined ? '' : ` - ${application.description}`}\n\nCommands:\n${commands.join('\n')}\n`;
 };
 
 export const runRscCli = async (
-  application: Readonly<RscAgentBundleApplication>,
+  application: Readonly<RscApplication>,
   argv: readonly string[],
   options: RscCliOptions = {},
 ): Promise<0 | 1 | 2> => {
diff --git a/packages/rsc-runtime/src/mcp-server.ts b/packages/rsc-runtime/src/mcp-server.ts
index 5c5cb5d6f..74d40517f 100644
--- a/packages/rsc-runtime/src/mcp-server.ts
+++ b/packages/rsc-runtime/src/mcp-server.ts
@@ -1,17 +1,21 @@
 import { McpServer as ProtocolMcpServer } from '@modelcontextprotocol/server';
 
+import type { RscApplication } from './application.js';
 import { lowerMcpResult } from './lower-mcp.js';
-import type { RscAgentBundleApplication } from './plugin-definition.js';
 
 export const createRscMcpServer = (
-  application: Readonly<RscAgentBundleApplication>,
+  application: Readonly<RscApplication>,
   serverName: string,
 ): ProtocolMcpServer => {
-  const serverDefinition = application.config.mcp?.servers[serverName];
-  if (serverDefinition === undefined) throw new Error(`Unknown RSC MCP server: ${serverName}`);
+  // The server's structural declaration (entry, targets) lives in
+  // agent-bundle.config.ts; here the name only selects which operations to
+  // serve, so a name no operation references is a wiring mistake.
+  if (!application.operations.some((operation) => operation.mcp?.server === serverName)) {
+    throw new Error(`Unknown RSC MCP server: ${serverName}`);
+  }
   const server = new ProtocolMcpServer({
-    name: application.config.plugin.name,
-    version: application.config.plugin.version,
+    name: application.name,
+    version: application.version,
   });
   for (const operation of application.operations) {
     if (operation.mcp?.server !== serverName) continue;
diff --git a/packages/rsc-runtime/src/plugin-definition.ts b/packages/rsc-runtime/src/plugin-definition.ts
deleted file mode 100644
index b2ff67220..000000000
--- a/packages/rsc-runtime/src/plugin-definition.ts
+++ /dev/null
@@ -1,252 +0,0 @@
-import type { AgentBundleConfig, AgentBundleMcpApp, AgentBundleMcpServer } from 'agent-bundle/config';
-import { Children, isValidElement, type ReactElement, type ReactNode } from 'react';
-
-import {
-  AgentBundle,
-  McpApp,
-  McpServer,
-  Operation,
-  Script,
-  Skill,
-  type AgentBundleProps,
-  type McpAppProps,
-  type McpServerProps,
-  type OperationProps,
-  type ScriptProps,
-  type SkillProps,
-} from './plugin-elements.js';
-import { frozenJsonRecord } from './lower-mcp.js';
-import type { RscOperationDefinition } from './operation.js';
-
-type DefinitionElement = { readonly props: Record<string, unknown>; readonly type: string };
-type DefinitionComponent = (props: never) => ReactElement;
-type ScriptEntry = { readonly entry: string; readonly targets: readonly string[] };
-
-const components = new Set<unknown>([AgentBundle, Skill, Script, McpApp, McpServer, Operation]);
-const canonicalName = /^[a-z][a-z0-9._-]{0,63}$/u;
-const canonicalTarget = /^[a-z][a-z0-9-]{0,31}$/u;
-const canonicalAppName = /^[a-z][a-z0-9-]{0,63}$/u;
-
-const resolveElement = (node: ReactNode): DefinitionElement => {
-  let candidate = node;
-  while (isValidElement(candidate) && components.has(candidate.type)) {
-    candidate = (candidate.type as DefinitionComponent)(candidate.props as never);
-  }
-  if (!isValidElement(candidate) || typeof candidate.type !== 'string' || !candidate.type.startsWith('rsc-agent-')) {
-    throw new Error('RSC plugin definition contains an unsupported element');
-  }
-  return { props: candidate.props as Record<string, unknown>, type: candidate.type };
-};
-
-const requiredName = (value: unknown, label: string): string => {
-  if (typeof value !== 'string' || !canonicalName.test(value)) throw new Error(`${label} must be a canonical lowercase identifier`);
-  return value;
-};
-
-const requiredPath = (value: unknown, label: string): string => {
-  if (
-    typeof value !== 'string'
-    || value.length < 3
-    || value.length > 4096
-    || !value.startsWith('./')
-    || value.includes('\\')
-    || value.split('/').some((segment) => segment === '..' || segment === '')
-  ) {
-    throw new Error(`${label} must be a contained project-relative path`);
-  }
-  return value;
-};
-
-const targets = (value: unknown, label: string): readonly string[] => {
-  if (!Array.isArray(value) || value.length === 0 || value.length > 16) throw new Error(`${label} must not be empty`);
-  const normalized = value.map((entry) => {
-    if (typeof entry !== 'string' || !canonicalTarget.test(entry)) throw new Error(`${label} contains an invalid target`);
-    return entry;
-  });
-  if (new Set(normalized).size !== normalized.length) throw new Error(`${label} contains a duplicate target`);
-  return Object.freeze(normalized);
-};
-
-const childTargets = (value: unknown, rootTargets: readonly string[], label: string): readonly string[] => {
-  if (value === undefined) return rootTargets;
-  const selected = targets(value, label);
-  if (selected.some((target) => !rootTargets.includes(target))) throw new Error(`${label} selects an undeclared target`);
-  return selected;
-};
-
-const duplicate = (values: readonly string[], label: string): void => {
-  if (new Set(values).size !== values.length) throw new Error(`RSC plugin definition contains a duplicate ${label}`);
-};
-
-const requiredAppName = (value: unknown, label: string): string => {
-  if (typeof value !== 'string' || !canonicalAppName.test(value)) {
-    throw new Error(`${label} must be a stable lowercase kebab-case identifier`);
-  }
-  return value;
-};
-
-const requiredResourceUri = (value: unknown, label: string): string => {
-  if (typeof value === 'string') {
-    try {
-      const uri = new URL(value);
-      if (uri.protocol === 'ui:' && uri.hostname.length > 0) return value;
-    } catch {
-      // fall through to the shared error below
-    }
-  }
-  throw new Error(`${label} must use ui:// with a nonempty host`);
-};
-
-/** Deterministic JSON with recursively sorted object keys, for value-identity comparisons. */
-const canonicalJson = (value: unknown): string => JSON.stringify(value, (_key, entry: unknown) =>
-  entry !== null && typeof entry === 'object' && !Array.isArray(entry)
-    ? Object.fromEntries(Object.entries(entry as Record<string, unknown>).sort(([left], [right]) => left.localeCompare(right)))
-    : entry) ?? 'undefined';
-
-const lowerMcpApps = (
-  children: unknown,
-  serverName: string,
-  serverTargets: readonly string[],
-): Readonly<Record<string, AgentBundleMcpApp>> | undefined => {
-  const apps: Array<readonly [string, Readonly<AgentBundleMcpApp>]> = [];
-  for (const appNode of Children.toArray(children as ReactNode)) {
-    const app = resolveElement(appNode);
-    if (app.type !== 'rsc-agent-mcp-app') {
-      throw new Error(`MCP server ${serverName} contains unsupported child ${app.type}`);
-    }
-    const props = app.props as unknown as McpAppProps;
-    const appName = requiredAppName(props.name, `MCP server ${serverName} app name`);
-    apps.push(Object.freeze([appName, Object.freeze<AgentBundleMcpApp>({
-      ...(props._meta === undefined
-        ? {}
-        : { _meta: frozenJsonRecord(props._meta, `MCP app ${appName} _meta must be JSON-serializable`) }),
-      entry: requiredPath(props.entry, `MCP app ${appName} entry`),
-      resourceUri: requiredResourceUri(props.resourceUri, `MCP app ${appName} resourceUri`),
-      targets: childTargets(props.targets, serverTargets, `MCP app ${appName} targets`),
-      ...(props.template === undefined ? {} : { template: requiredPath(props.template, `MCP app ${appName} template`) }),
-    })]));
-  }
-  if (apps.length === 0) return undefined;
-  duplicate(apps.map(([appName]) => appName), `MCP app name on server ${serverName}`);
-  return Object.freeze(Object.fromEntries(apps));
-};
-
-/**
- * The same app name may appear on several servers only as one shared app: an
- * identical declaration compiled once and served from every declaring server.
- * Targets may differ per server; everything else must match, and a resource
- * URI may not span app names.
- */
-const assertSharedApps = (servers: readonly (readonly [string, Readonly<AgentBundleMcpServer>])[]): void => {
-  const identities = new Map<string, string>();
-  const uriOwners = new Map<string, string>();
-  for (const [serverName, server] of servers) {
-    for (const [appName, app] of Object.entries(server.apps ?? {})) {
-      const identity = canonicalJson({ _meta: app._meta, entry: app.entry, resourceUri: app.resourceUri, template: app.template });
-      const known = identities.get(appName);
-      if (known !== undefined && known !== identity) {
-        throw new Error(`MCP app ${appName} on server ${serverName} does not match its declaration on another server`);
-      }
-      identities.set(appName, identity);
-      const owner = uriOwners.get(app.resourceUri);
-      if (owner !== undefined && owner !== appName) {
-        throw new Error(`MCP app resource URI ${app.resourceUri} is already declared by app ${owner}`);
-      }
-      uriOwners.set(app.resourceUri, appName);
-    }
-  }
-};
-
-const immutableConfigArray = <T>(values: readonly T[]): T[] => Object.freeze([...values]) as T[];
-
-export interface RscAgentBundleApplication {
-  readonly config: Readonly<AgentBundleConfig>;
-  readonly operations: readonly Readonly<RscOperationDefinition>[];
-}
-
-export const defineRscAgentBundle = (node: ReactNode): Readonly<RscAgentBundleApplication> => {
-  const root = resolveElement(node);
-  if (root.type !== 'rsc-agent-bundle') throw new Error('Expected exactly one AgentBundle root');
-  const rootProps = root.props as unknown as AgentBundleProps;
-  const name = requiredName(rootProps.name, 'Agent Bundle name');
-  const version = typeof rootProps.version === 'string' && rootProps.version.trim() !== ''
-    ? rootProps.version
-    : (() => { throw new Error('Agent Bundle version must be non-empty'); })();
-  const rootTargets = targets(rootProps.targets, 'Agent Bundle targets');
-  const skills: string[] = [];
-  const scripts: Array<readonly [string, Readonly<ScriptEntry>]> = [];
-  const servers: Array<readonly [string, Readonly<AgentBundleMcpServer>]> = [];
-  const operations: Readonly<RscOperationDefinition>[] = [];
-
-  for (const childNode of Children.toArray(rootProps.children)) {
-    const child = resolveElement(childNode);
-    switch (child.type) {
-      case 'rsc-agent-skill': {
-        const props = child.props as unknown as SkillProps;
-        skills.push(requiredPath(props.source, 'Skill source'));
-        break;
-      }
-      case 'rsc-agent-script': {
-        const props = child.props as unknown as ScriptProps;
-        const scriptName = requiredName(props.name, 'Script name');
-        scripts.push(Object.freeze([scriptName, Object.freeze({
-          entry: requiredPath(props.entry, `Script ${scriptName} entry`),
-          targets: childTargets(props.targets, rootTargets, `Script ${scriptName} targets`),
-        })]));
-        break;
-      }
-      case 'rsc-agent-mcp-server': {
-        const props = child.props as unknown as McpServerProps;
-        const serverName = requiredName(props.name, 'MCP server name');
-        const serverTargets = childTargets(props.targets, rootTargets, `MCP server ${serverName} targets`);
-        const apps = lowerMcpApps(child.props.children, serverName, serverTargets);
-        servers.push(Object.freeze([serverName, Object.freeze({
-          ...(apps === undefined ? {} : { apps }),
-          entry: requiredPath(props.entry, `MCP server ${serverName} entry`),
-          targets: serverTargets,
-        })]));
-        break;
-      }
-      case 'rsc-agent-operation': {
-        const props = child.props as unknown as OperationProps;
-        if (props.definition === null || typeof props.definition !== 'object' || !Object.isFrozen(props.definition)) {
-          throw new Error('Operation definition must come from defineOperation');
-        }
-        operations.push(props.definition);
-        break;
-      }
-      default:
-        throw new Error(`AgentBundle contains unsupported child ${child.type}`);
-    }
-  }
-
-  duplicate(skills, 'skill source');
-  duplicate(scripts.map(([scriptName]) => scriptName), 'script name');
-  duplicate(servers.map(([serverName]) => serverName), 'MCP server name');
-  assertSharedApps(servers);
-  duplicate(operations.map((operation) => operation.id), 'operation id');
-  duplicate(operations.flatMap((operation) => operation.cli === undefined ? [] : [operation.cli.name]), 'CLI command');
-  duplicate(operations.flatMap((operation) => operation.mcp === undefined ? [] : [`${operation.mcp.server}:${operation.mcp.name}`]), 'MCP tool');
-  const serverNames = new Set(servers.map(([serverName]) => serverName));
-  for (const operation of operations) {
-    if (operation.mcp !== undefined && !serverNames.has(operation.mcp.server)) {
-      throw new Error(`Operation ${operation.id} references unknown MCP server ${operation.mcp.server}`);
-    }
-  }
-
-  const config = Object.freeze<AgentBundleConfig>({
-    ...(servers.length === 0 ? {} : { mcp: Object.freeze({ servers: Object.freeze(Object.fromEntries(servers)) }) }),
-    ...(rootProps.marketplace === undefined ? {} : { marketplace: rootProps.marketplace }),
-    plugin: Object.freeze({
-      ...(rootProps.description === undefined ? {} : { description: rootProps.description }),
-      name,
-      version,
-    }),
-    ...(rootProps.node === undefined ? {} : { runtime: Object.freeze({ node: rootProps.node }) }),
-    ...(scripts.length === 0 ? {} : { scripts: Object.freeze(Object.fromEntries(scripts)) }),
-    ...(skills.length === 0 ? {} : { skills: immutableConfigArray(skills) }),
-    targets: immutableConfigArray(rootTargets),
-  });
-
-  return Object.freeze({ config, operations: Object.freeze([...operations]) });
-};
diff --git a/packages/rsc-runtime/src/plugin-elements.ts b/packages/rsc-runtime/src/plugin-elements.ts
deleted file mode 100644
index 5a9c58868..000000000
--- a/packages/rsc-runtime/src/plugin-elements.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-import { createElement, type PropsWithChildren, type ReactElement } from 'react';
-
-import type { RscOperationDefinition } from './operation.js';
-
-export interface AgentBundleProps extends PropsWithChildren {
-  readonly description?: string;
-  readonly marketplace?: boolean;
-  readonly name: string;
-  readonly node?: string;
-  readonly targets: readonly string[];
-  readonly version: string;
-}
-
-export interface SkillProps {
-  readonly source: string;
-}
-
-export interface ScriptProps {
-  readonly entry: string;
-  readonly name: string;
-  readonly targets?: readonly string[];
-}
-
-export interface McpServerProps extends PropsWithChildren {
-  readonly entry: string;
-  readonly name: string;
-  readonly targets?: readonly string[];
-}
-
-export interface McpAppProps {
-  /** Resource-level metadata compiled into the app registry, e.g. host presentation hints. */
-  readonly _meta?: Readonly<Record<string, unknown>>;
-  readonly entry: string;
-  readonly name: string;
-  readonly resourceUri: string;
-  readonly targets?: readonly string[];
-  readonly template?: string;
-}
-
-export interface OperationProps {
-  readonly definition: Readonly<RscOperationDefinition>;
-}
-
-export const AgentBundle = ({ children, ...props }: AgentBundleProps): ReactElement =>
-  createElement('rsc-agent-bundle', props, children);
-
-export const Skill = (props: SkillProps): ReactElement => createElement('rsc-agent-skill', props);
-
-export const Script = (props: ScriptProps): ReactElement => createElement('rsc-agent-script', props);
-
-export const McpServer = ({ children, ...props }: McpServerProps): ReactElement =>
-  createElement('rsc-agent-mcp-server', props, children);
-
-export const McpApp = (props: McpAppProps): ReactElement => createElement('rsc-agent-mcp-app', props);
-
-export const Operation = (props: OperationProps): ReactElement => createElement('rsc-agent-operation', props);
diff --git a/packages/rsc-runtime/src/plugin.ts b/packages/rsc-runtime/src/plugin.ts
index 20aeae831..423b6fbab 100644
--- a/packages/rsc-runtime/src/plugin.ts
+++ b/packages/rsc-runtime/src/plugin.ts
@@ -1,3 +1,5 @@
+export { defineRscApplication } from './application.js';
+export type { RscApplication, RscApplicationOptions } from './application.js';
 export { runRscCli } from './cli.js';
 export type { RscCliOptions } from './cli.js';
 export { createRscMcpServer } from './mcp-server.js';
@@ -9,15 +11,4 @@ export type {
   RscOperationContext,
   RscOperationDefinition,
   RscOperationInput,
-} from './operation.js';
-export { defineRscAgentBundle } from './plugin-definition.js';
-export type { RscAgentBundleApplication } from './plugin-definition.js';
-export { AgentBundle, McpApp, McpServer, Operation, Script, Skill } from './plugin-elements.js';
-export type {
-  AgentBundleProps,
-  McpAppProps,
-  McpServerProps,
-  OperationProps,
-  ScriptProps,
-  SkillProps,
-} from './plugin-elements.js';
+} from './operation.js';
\ No newline at end of file
diff --git a/packages/rsc-runtime/tests/application.test.ts b/packages/rsc-runtime/tests/application.test.ts
new file mode 100644
index 000000000..43ea7296f
--- /dev/null
+++ b/packages/rsc-runtime/tests/application.test.ts
@@ -0,0 +1,180 @@
+import { describe, expect, it } from '@rstest/core';
+import { createElement } from 'react';
+import { z } from 'zod';
+
+import { createRscMcpServer, defineOperation, defineRscApplication, runRscCli } from '../src/index.js';
+
+const operation = (id: string, overrides: { readonly cliName?: string; readonly mcpName?: string } = {}) =>
+  defineOperation({
+    cli: {
+      name: overrides.cliName ?? id,
+      parse: () => ({}),
+      summary: `${id} summary.`,
+      usage: id,
+    },
+    execute: async () => ({ ok: true }),
+    id,
+    inputSchema: z.object({}).strict(),
+    mcp: {
+      description: `${id} tool.`,
+      name: overrides.mcpName ?? id,
+      readOnly: true,
+      server: 'demo',
+    },
+    render: () => createElement('mcp-result', null, createElement('mcp-text', null, 'ok')),
+    resultSchema: z.object({ ok: z.boolean() }).strict(),
+  });
+
+describe('defineRscApplication', () => {
+  it('returns a frozen application carrying identity and operations', () => {
+    const status = operation('status');
+    const application = defineRscApplication({
+      description: 'Demo application.',
+      name: 'demo-app',
+      operations: [status],
+      version: '1.0.0',
+    });
+
+    expect(application).toEqual({
+      description: 'Demo application.',
+      name: 'demo-app',
+      operations: [status],
+      version: '1.0.0',
+    });
+    expect(Object.isFrozen(application)).toBe(true);
+    expect(Object.isFrozen(application.operations)).toBe(true);
+    expect(Object.hasOwn(defineRscApplication({ name: 'demo-app', operations: [], version: '1.0.0' }), 'description')).toBe(false);
+  });
+
+  it('rejects malformed identity fields', () => {
+    expect(() => defineRscApplication({ name: 'Demo App', operations: [], version: '1.0.0' }))
+      .toThrow('RSC application name must be a canonical lowercase identifier');
+    expect(() => defineRscApplication({ name: 'demo-app', operations: [], version: '  ' }))
+      .toThrow('RSC application version must be non-empty');
+    expect(() => defineRscApplication({ description: ' ', name: 'demo-app', operations: [], version: '1.0.0' }))
+      .toThrow('RSC application description must be non-empty when present');
+  });
+
+  it('rejects duplicate operation ids, CLI commands, and MCP tools', () => {
+    expect(() => defineRscApplication({
+      name: 'demo-app',
+      operations: [operation('status'), operation('status', { cliName: 'other', mcpName: 'other' })],
+      version: '1.0.0',
+    })).toThrow('RSC application contains a duplicate operation id');
+    expect(() => defineRscApplication({
+      name: 'demo-app',
+      operations: [operation('status'), operation('other', { cliName: 'status' })],
+      version: '1.0.0',
+    })).toThrow('RSC application contains a duplicate CLI command');
+    expect(() => defineRscApplication({
+      name: 'demo-app',
+      operations: [operation('status'), operation('other', { mcpName: 'status' })],
+      version: '1.0.0',
+    })).toThrow('RSC application contains a duplicate MCP tool');
+  });
+
+  it('rejects operations not built by defineOperation', () => {
+    expect(() => defineRscApplication({
+      name: 'demo-app',
+      operations: [{ ...operation('status') }],
+      version: '1.0.0',
+    })).toThrow('RSC application operations must come from defineOperation');
+  });
+});
+
+describe('runRscCli', () => {
+  it('runs root help, command help, and execution from the shared operation', async () => {
+    const status = defineOperation({
+      cli: {
+        name: 'status',
+        parse: (argv) => ({ subject: argv[0] ?? 'library' }),
+        summary: 'Read curator status.',
+        usage: 'status [subject]',
+      },
+      execute: async (input: { readonly subject: string }) => ({
+        message: `${input.subject} ready`,
+        operation: 'status' as const,
+      }),
+      id: 'status',
+      inputSchema: z.object({ subject: z.string().min(1) }).strict(),
+      mcp: {
+        description: 'Read curator status.',
+        name: 'curator_status',
+        readOnly: true,
+        server: 'curator',
+      },
+      render: (result) => createElement(
+        'mcp-result',
+        { structuredContent: result },
+        createElement('mcp-text', null, result.message),
+      ),
+      resultSchema: z.object({
+        message: z.string(),
+        operation: z.literal('status'),
+      }).strict(),
+    });
+    const application = defineRscApplication({
+      description: 'Curate audiobooks.',
+      name: 'audiobook-curator',
+      operations: [status],
+      version: '1.0.0',
+    });
+    const output: string[] = [];
+
+    await expect(runRscCli(application, ['--help'], { write: (value) => output.push(value) })).resolves.toBe(0);
+    expect(output.join('')).toContain('status [subject]');
+
+    output.length = 0;
+    await expect(runRscCli(application, ['status', '--help'], { write: (value) => output.push(value) })).resolves.toBe(0);
+    expect(output.join('')).toContain('Read curator status.');
+
+    output.length = 0;
+    await expect(runRscCli(application, ['status', 'collection'], { write: (value) => output.push(value) })).resolves.toBe(0);
+    expect(JSON.parse(output.join(''))).toEqual({ message: 'collection ready', operation: 'status' });
+  });
+});
+
+describe('defineOperation MCP extras', () => {
+  it('preserves listing title and _meta on the frozen MCP definition without sharing the caller object', () => {
+    const metadata: Record<string, unknown> = { ui: { resourceUri: 'ui://curator/widget.html' } };
+    const withExtras = (mcp: Record<string, unknown>) => defineOperation({
+      execute: async () => ({ ok: true }),
+      id: 'extras',
+      inputSchema: z.object({}).strict(),
+      mcp: {
+        description: 'Extras probe.',
+        name: 'extras',
+        readOnly: true,
+        server: 'curator',
+        ...mcp,
+      },
+      render: () => createElement('mcp-result', null, createElement('mcp-text', null, 'ok')),
+      resultSchema: z.object({ ok: z.boolean() }).strict(),
+    });
+
+    const operation = withExtras({ _meta: metadata, title: 'Extras' });
+    (metadata.ui as Record<string, unknown>).resourceUri = 'ui://curator/changed.html';
+    expect(operation.mcp?.title).toBe('Extras');
+    expect(operation.mcp?._meta).toEqual({ ui: { resourceUri: 'ui://curator/widget.html' } });
+    expect(Object.isFrozen(operation.mcp?._meta)).toBe(true);
+    expect(Object.isFrozen(operation.mcp?._meta?.ui)).toBe(true);
+
+    const cyclic: Record<string, unknown> = {};
+    cyclic.self = cyclic;
+    expect(() => withExtras({ _meta: cyclic })).toThrow(
+      'Operation extras MCP _meta must be JSON-serializable (cyclic value at self)',
+    );
+    expect(() => withExtras({ title: '   ' })).toThrow('Operation extras MCP title must be non-empty and bounded');
+  });
+});
+
+describe('createRscMcpServer selection', () => {
+  it('rejects a server name no operation references', () => {
+    const application = defineRscApplication({
+      name: 'demo-app',
+      operations: [operation('status')],
+      version: '1.0.0',
+    });
+    expect(() => createRscMcpServer(application, 'ghost')).toThrow('Unknown RSC MCP server: ghost');
+  });
+});
diff --git a/packages/rsc-runtime/tests/mcp-server-wire.test.ts b/packages/rsc-runtime/tests/mcp-server-wire.test.ts
index 726a9f699..feac1d243 100644
--- a/packages/rsc-runtime/tests/mcp-server-wire.test.ts
+++ b/packages/rsc-runtime/tests/mcp-server-wire.test.ts
@@ -12,13 +12,10 @@ import { createElement } from 'react';
 import { z } from 'zod';
 
 import {
-  AgentBundle,
-  McpServer,
   Mcp,
-  Operation,
   createRscMcpServer,
   defineOperation,
-  defineRscAgentBundle,
+  defineRscApplication,
 } from '../src/index.js';
 
 const widgetResourceUri = 'ui://demo/widget.html';
@@ -63,13 +60,11 @@ const removeOperation = defineOperation({
   resultSchema: z.object({ removed: z.boolean() }).strict(),
 });
 
-const application = defineRscAgentBundle(createElement(
-  AgentBundle,
-  { name: 'wire-demo', targets: ['claude'], version: '1.0.0' },
-  createElement(McpServer, { entry: './src/mcp-server.ts', name: 'demo' }),
-  createElement(Operation, { definition: searchOperation }),
-  createElement(Operation, { definition: removeOperation }),
-));
+const application = defineRscApplication({
+  name: 'wire-demo',
+  operations: [searchOperation, removeOperation],
+  version: '1.0.0',
+});
 
 interface WireTool {
   readonly _meta?: Record<string, unknown>;
diff --git a/packages/rsc-runtime/tests/plugin-app.test.ts b/packages/rsc-runtime/tests/plugin-app.test.ts
deleted file mode 100644
index a978209e4..000000000
--- a/packages/rsc-runtime/tests/plugin-app.test.ts
+++ /dev/null
@@ -1,276 +0,0 @@
-import { describe, expect, it } from '@rstest/core';
-import { createElement } from 'react';
-import { z } from 'zod';
-
-import {
-  AgentBundle,
-  McpApp,
-  McpServer,
-  Operation,
-  Script,
-  Skill,
-  defineOperation,
-  defineRscAgentBundle,
-  runRscCli,
-  type McpAppProps,
-} from '../src/index.js';
-
-const statusOperation = defineOperation({
-  cli: {
-    name: 'status',
-    parse: (argv) => ({ subject: argv[0] ?? 'library' }),
-    summary: 'Read curator status.',
-    usage: 'status [subject]',
-  },
-  execute: async (input: { readonly subject: string }) => ({
-    message: `${input.subject} ready`,
-    operation: 'status' as const,
-  }),
-  id: 'status',
-  inputSchema: z.object({ subject: z.string().min(1) }).strict(),
-  mcp: {
-    description: 'Read curator status.',
-    name: 'curator_status',
-    readOnly: true,
-    server: 'curator',
-  },
-  render: (result) => createElement(
-    'mcp-result',
-    { structuredContent: result },
-    createElement('mcp-text', null, result.message),
-  ),
-  resultSchema: z.object({
-    message: z.string(),
-    operation: z.literal('status'),
-  }).strict(),
-});
-
-const applicationNode = () => createElement(
-  AgentBundle,
-  {
-    description: 'Curate audiobooks.',
-    name: 'audiobook-curator',
-    targets: ['claude', 'codex'],
-    version: '1.0.0',
-  },
-  createElement(Skill, { source: './skills/curate-audiobooks' }),
-  createElement(Script, { entry: './src/cli-entry.ts', name: 'audiobook-curator' }),
-  createElement(McpServer, { entry: './src/mcp-server.ts', name: 'curator' }),
-  createElement(Operation, { definition: statusOperation }),
-);
-
-describe('RSC plugin applications', () => {
-  it('lowers one tree into an exact Agent Bundle config and operation registry', () => {
-    const application = defineRscAgentBundle(applicationNode());
-
-    expect(application.config).toEqual({
-      mcp: {
-        servers: {
-          curator: {
-            entry: './src/mcp-server.ts',
-            targets: ['claude', 'codex'],
-          },
-        },
-      },
-      plugin: {
-        description: 'Curate audiobooks.',
-        name: 'audiobook-curator',
-        version: '1.0.0',
-      },
-      scripts: {
-        'audiobook-curator': {
-          entry: './src/cli-entry.ts',
-          targets: ['claude', 'codex'],
-        },
-      },
-      skills: ['./skills/curate-audiobooks'],
-      targets: ['claude', 'codex'],
-    });
-    expect(application.operations).toEqual([statusOperation]);
-    expect(Object.isFrozen(application)).toBe(true);
-    expect(Object.isFrozen(application.config)).toBe(true);
-    expect(Object.isFrozen(application.operations)).toBe(true);
-  });
-
-  it('runs root help, command help, and execution from the shared operation', async () => {
-    const application = defineRscAgentBundle(applicationNode());
-    const output: string[] = [];
-
-    await expect(runRscCli(application, ['--help'], { write: (value) => output.push(value) })).resolves.toBe(0);
-    expect(output.join('')).toContain('status [subject]');
-
-    output.length = 0;
-    await expect(runRscCli(application, ['status', '--help'], { write: (value) => output.push(value) })).resolves.toBe(0);
-    expect(output.join('')).toContain('Read curator status.');
-
-    output.length = 0;
-    await expect(runRscCli(application, ['status', 'collection'], { write: (value) => output.push(value) })).resolves.toBe(0);
-    expect(JSON.parse(output.join(''))).toEqual({ message: 'collection ready', operation: 'status' });
-  });
-
-  it('rejects duplicate operation, script, server, and skill ownership', () => {
-    const duplicates = [
-      createElement(Operation, { definition: statusOperation }),
-      createElement(Script, { entry: './src/other.ts', name: 'audiobook-curator' }),
-      createElement(McpServer, { entry: './src/other-server.ts', name: 'curator' }),
-      createElement(Skill, { source: './skills/curate-audiobooks' }),
-    ];
-
-    for (const duplicate of duplicates) {
-      expect(() => defineRscAgentBundle(
-        createElement(
-          AgentBundle,
-          { name: 'audiobook-curator', targets: ['claude'], version: '1.0.0' },
-          ...applicationNode().props.children,
-          duplicate,
-        ),
-      )).toThrow(/duplicate/iu);
-    }
-  });
-
-  it('lowers McpApp children into the owning server apps record', () => {
-    const application = defineRscAgentBundle(createElement(
-      AgentBundle,
-      { name: 'widget-host', targets: ['claude', 'codex'], version: '1.0.0' },
-      createElement(
-        McpServer,
-        { entry: './src/mcp-server.ts', name: 'library' },
-        createElement(McpApp, {
-          _meta: { ui: { prefersBorder: true } },
-          entry: './views/widget.ts',
-          name: 'widget',
-          resourceUri: 'ui://widget-host/widget.html',
-          targets: ['claude'],
-          template: './views/widget.html',
-        }),
-      ),
-    ));
-
-    expect(application.config.mcp).toEqual({
-      servers: {
-        library: {
-          apps: {
-            widget: {
-              _meta: { ui: { prefersBorder: true } },
-              entry: './views/widget.ts',
-              resourceUri: 'ui://widget-host/widget.html',
-              targets: ['claude'],
-              template: './views/widget.html',
-            },
-          },
-          entry: './src/mcp-server.ts',
-          targets: ['claude', 'codex'],
-        },
-      },
-    });
-    const apps = application.config.mcp?.servers['library']?.apps;
-    expect(Object.isFrozen(apps)).toBe(true);
-    expect(Object.isFrozen(apps?.['widget'])).toBe(true);
-    expect(Object.isFrozen(apps?.['widget']?._meta)).toBe(true);
-  });
-
-  it('shares one identical app across servers and rejects conflicting redeclarations', () => {
-    const widget = (overrides: Partial<McpAppProps> = {}) => createElement(McpApp, {
-      entry: './views/widget.ts',
-      name: 'widget',
-      resourceUri: 'ui://widget-host/widget.html',
-      ...overrides,
-    });
-    const bundle = (...serverChildren: readonly (readonly [string, ReturnType<typeof widget>])[]) =>
-      defineRscAgentBundle(createElement(
-        AgentBundle,
-        { name: 'widget-host', targets: ['claude'], version: '1.0.0' },
-        ...serverChildren.map(([name, app]) => createElement(McpServer, { entry: `./src/${name}.ts`, name }, app)),
-      ));
-
-    const shared = bundle(['library', widget()], ['public', widget()]);
-    expect(shared.config.mcp?.servers['library']?.apps?.['widget']).toEqual(
-      shared.config.mcp?.servers['public']?.apps?.['widget'],
-    );
-
-    expect(() => bundle(['library', widget()], ['public', widget({ entry: './views/other.ts' })])).toThrow(
-      'MCP app widget on server public does not match its declaration on another server',
-    );
-    expect(() => bundle(['library', widget()], ['public', widget({ name: 'copycat' })])).toThrow(
-      'MCP app resource URI ui://widget-host/widget.html is already declared by app widget',
-    );
-  });
-
-  it('rejects malformed app declarations at lowering time', () => {
-    const appHost = (...children: readonly ReturnType<typeof createElement>[]) => () => defineRscAgentBundle(createElement(
-      AgentBundle,
-      { name: 'widget-host', targets: ['claude'], version: '1.0.0' },
-      createElement(McpServer, { entry: './src/mcp-server.ts', name: 'library' }, ...children),
-    ));
-    const app = (overrides: Partial<McpAppProps>) => createElement(McpApp, {
-      entry: './views/widget.ts',
-      name: 'widget',
-      resourceUri: 'ui://widget-host/widget.html',
-      ...overrides,
-    });
-
-    expect(appHost(app({}), app({ resourceUri: 'ui://widget-host/other.html' }))).toThrow(
-      'RSC plugin definition contains a duplicate MCP app name on server library',
-    );
-    expect(appHost(createElement(Skill, { source: './skills/misplaced' }))).toThrow(
-      'MCP server library contains unsupported child rsc-agent-skill',
-    );
-    expect(appHost(app({ name: 'Widget' }))).toThrow(
-      'MCP server library app name must be a stable lowercase kebab-case identifier',
-    );
-    expect(appHost(app({ resourceUri: 'https://example.test/widget.html' }))).toThrow(
-      'MCP app widget resourceUri must use ui:// with a nonempty host',
-    );
-    expect(appHost(app({ targets: ['codex'] }))).toThrow('MCP app widget targets selects an undeclared target');
-    const cyclic: Record<string, unknown> = {};
-    cyclic.self = cyclic;
-    expect(appHost(app({ _meta: cyclic }))).toThrow(
-      'MCP app widget _meta must be JSON-serializable (cyclic value at self)',
-    );
-    expect(appHost(app({ entry: '../views/widget.ts' }))).toThrow(
-      'MCP app widget entry must be a contained project-relative path',
-    );
-  });
-
-  it('preserves listing title and _meta on the frozen MCP definition without sharing the caller object', () => {
-    const metadata: Record<string, unknown> = { ui: { resourceUri: 'ui://curator/widget.html' } };
-    const withExtras = (mcp: Record<string, unknown>) => defineOperation({
-      execute: async () => ({ ok: true }),
-      id: 'extras',
-      inputSchema: z.object({}).strict(),
-      mcp: {
-        description: 'Extras probe.',
-        name: 'extras',
-        readOnly: true,
-        server: 'curator',
-        ...mcp,
-      },
-      render: () => createElement('mcp-result', null, createElement('mcp-text', null, 'ok')),
-      resultSchema: z.object({ ok: z.boolean() }).strict(),
-    });
-
-    const operation = withExtras({ _meta: metadata, title: 'Extras' });
-    (metadata.ui as Record<string, unknown>).resourceUri = 'ui://curator/changed.html';
-    expect(operation.mcp?.title).toBe('Extras');
-    expect(operation.mcp?._meta).toEqual({ ui: { resourceUri: 'ui://curator/widget.html' } });
-    expect(Object.isFrozen(operation.mcp?._meta)).toBe(true);
-    expect(Object.isFrozen(operation.mcp?._meta?.ui)).toBe(true);
-
-    const cyclic: Record<string, unknown> = {};
-    cyclic.self = cyclic;
-    expect(() => withExtras({ _meta: cyclic })).toThrow(
-      'Operation extras MCP _meta must be JSON-serializable (cyclic value at self)',
-    );
-    expect(() => withExtras({ title: '   ' })).toThrow('Operation extras MCP title must be non-empty and bounded');
-  });
-
-  it('rejects operations whose MCP owner does not exist', () => {
-    expect(() => defineRscAgentBundle(
-      createElement(
-        AgentBundle,
-        { name: 'audiobook-curator', targets: ['claude'], version: '1.0.0' },
-        createElement(Operation, { definition: statusOperation }),
-      ),
-    )).toThrow('Operation status references unknown MCP server curator');
-  });
-});
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index f38d538c0..1327241c2 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -248,9 +248,15 @@ importers:
         specifier: 2.9.0
         version: 2.9.0
     devDependencies:
+      '@types/react':
+        specifier: 19.2.18
+        version: 19.2.18
       '@types/ws':
         specifier: 8.18.1
         version: 8.18.1
+      react:
+        specifier: 19.2.8
+        version: 19.2.8
 
   packages/create-agent-bundle:
     devDependencies:
@@ -291,9 +297,6 @@ importers:
       '@types/react':
         specifier: 19.2.18
         version: 19.2.18
-      agent-bundle:
-        specifier: workspace:*
-        version: link:../agent-bundle
       react:
         specifier: 19.2.8
         version: 19.2.8