opencastle 0.32.4 → 0.32.6

package/src/orchestrator/plugins/nextjs/SKILL.md

@@ -16,149 +16,93 @@ description: "Next.js framework best practices covering App Router, server/clien
 │   ├── loading.tsx          # Loading UI (Suspense boundary)
 │   ├── error.tsx            # Error boundary (Client Component)
 │   ├── not-found.tsx        # 404 page
-│   ├── global-error.tsx     # Root error boundary
 │   ├── (marketing)/         # Route group (no URL segment)
-│   │   ├── about/page.tsx   # → /about
-│   │   └── blog/page.tsx    # → /blog
+│   │   └── about/page.tsx   # → /about
 │   ├── dashboard/
 │   │   ├── layout.tsx       # Nested layout
-│   │   ├── page.tsx         # → /dashboard
 │   │   └── [id]/page.tsx    # → /dashboard/:id
 │   └── api/
 │       └── users/route.ts   # API route handler
 ├── components/              # Shared React components
 ├── lib/                     # Utilities, helpers, server logic
-├── public/                  # Static assets (served as-is)
+├── public/                  # Static assets
 ├── next.config.ts           # Next.js configuration
 ├── middleware.ts            # Edge middleware
 └── .env.local               # Environment variables (not committed)
 ```
 
-- **Route Groups** `(name)` — organize routes without affecting the URL.
-- **Private Folders** `_internal` — opt out of routing entirely.
-- **Parallel Routes** `@modal` — render multiple pages in the same layout.
-- **Intercepting Routes** `(.)photo` — intercept navigation to show modals.
+Route Groups `(name)` organize routes without affecting the URL. Private Folders `_internal` opt out of routing. Parallel Routes `@modal` render multiple pages in the same layout.
 
 ## Rendering Strategies
 
-Next.js supports multiple rendering strategies per route:
-
 | Strategy | When | How |
 |----------|------|-----|
 | **Static (SSG)** | Build time | Default for pages with no dynamic data |
-| **Incremental Static Regeneration (ISR)** | Build + revalidation | `fetch` with `next: { revalidate: N }` or route segment config |
-| **Server-Side Rendering (SSR)** | Every request | `export const dynamic = 'force-dynamic'` or dynamic functions (`cookies()`, `headers()`) |
-| **Client-Side Rendering (CSR)** | Browser | `'use client'` components with `useEffect`/SWR |
+| **ISR** | Build + revalidation | `fetch` with `next: { revalidate: N }` or route segment config |
+| **SSR** | Every request | `export const dynamic = 'force-dynamic'` or dynamic functions |
+| **CSR** | Browser | `'use client'` components with `useEffect`/SWR |
 | **Streaming** | Progressive | `<Suspense>` boundaries + `loading.tsx` |
-| **Partial Prerendering (PPR)** | Build + streaming | Static shell with dynamic holes via `<Suspense>` |
-
-### Route Segment Config
-
-Control per-route rendering behavior:
+| **PPR** | Build + streaming | Static shell with dynamic holes via `<Suspense>` |
 
-```tsx
-// app/dashboard/page.tsx
-export const dynamic = 'force-dynamic';        // SSR every request
-export const revalidate = 60;                   // ISR: revalidate every 60s
-export const fetchCache = 'default-cache';      // Cache fetch requests
-export const runtime = 'nodejs';                // 'nodejs' | 'edge'
-```
+Route segment config: `export const dynamic = 'force-dynamic'`, `export const revalidate = 60`, `export const runtime = 'edge'`.
 
 ## Server and Client Components
 
-**Default: Server Components** — data fetching, heavy logic, non-interactive UI.
-
+**Default: Server Components** — data fetching, heavy logic, non-interactive UI.  
 **Client Components** — add `'use client'` at top. Use for interactivity, state, browser APIs.
 
-### Decision Table
-
-| Need | Component Type | Why |
-|------|---------------|-----|
-| Fetch data at request time | Server | Direct DB/API access, no client waterfall |
-| Read cookies/headers | Server | Available only on the server |
-| Interactive UI (clicks, inputs) | Client | Requires event handlers |
-| Use `useState` / `useEffect` | Client | React hooks need client runtime |
-| Access browser APIs (localStorage, geolocation) | Client | Not available on server |
-| Render static/non-interactive content | Server | Smaller bundle, faster paint |
-| Show loading spinners for async children | Server (with `<Suspense>`) | Streams HTML progressively |
+| Need | Component Type |
+|------|---------------|
+| Fetch data / read cookies/headers | Server |
+| Interactive UI (clicks, inputs) | Client |
+| `useState` / `useEffect` / browser APIs | Client |
+| Static/non-interactive content | Server |
+| Async children with loading state | Server + `<Suspense>` |
 
 ### Critical Rule
 
-**Never use `next/dynamic` with `{ ssr: false }` inside a Server Component.** Move client-only logic into a dedicated `'use client'` component, then import it normally.
+**Never use `next/dynamic` with `{ ssr: false }` inside a Server Component.** Extract to a dedicated `'use client'` component and import it normally.
 
 ## Data Fetching
 
-### Server-Side Fetching
-
-Fetch directly in `async` Server Components. Next.js deduplicates identical `fetch` calls.
+### Server-Side
 
 ```tsx
 export default async function ProjectsPage() {
-  const projects = await fetch('https://api.example.com/projects', {
-    next: { revalidate: 60 },
-  }).then((res) => res.json());
-  return <ul>{projects.map((p: { id: string; name: string }) => <li key={p.id}>{p.name}</li>)}</ul>;
+  const data = await fetch('/api/projects', { next: { revalidate: 60 } }).then((r) => r.json());
+  return <ul>{data.map((p: { id: string; name: string }) => <li key={p.id}>{p.name}</li>)}</ul>;
 }
 ```
 
-### Server Actions (Mutations)
-
-Define with `'use server'`. Call from Client Components via `action` or `startTransition`.
+### Server Actions
 
 ```tsx
-// lib/actions.ts
 'use server';
 import { revalidatePath } from 'next/cache';
 export async function createItem(formData: FormData) {
-  const name = formData.get('name') as string;
-  await db.items.create({ data: { name } });
+  await db.items.create({ data: { name: formData.get('name') as string } });
   revalidatePath('/items');
 }
 ```
 
-```tsx
-// components/CreateItemForm.tsx
-'use client';
-import { createItem } from '@/lib/actions';
-export default function CreateItemForm() {
-  return <form action={createItem}><input name="name" required /><button type="submit">Add</button></form>;
-}
-```
+Use from a Client Component: `<form action={createItem}>...</form>`
 
-### Parallel Data Fetching
-
-Initiate independent fetches simultaneously — never `await` sequentially.
+### Parallel Fetching
 
 ```tsx
-export default async function DashboardPage() {
-  const [metrics, activity] = await Promise.all([getMetrics(), getRecentActivity()]);
-  return <><MetricsPanel data={metrics} /><ActivityFeed items={activity} /></>;
-}
+const [metrics, activity] = await Promise.all([getMetrics(), getRecentActivity()]);
 ```
 
-## Caching and Revalidation
+## Caching
 
 | Mechanism | Scope | How to Use |
 |-----------|-------|------------|
 | **Request Memoization** | Per-request | Automatic deduplication of identical `fetch` calls |
-| **Data Cache** | Cross-request | `fetch` results cached by default; opt out with `cache: 'no-store'` |
+| **Data Cache** | Cross-request | Cached by default; opt out with `cache: 'no-store'` |
 | **Full Route Cache** | Build time | Static routes cached as HTML + RSC payload |
 | **Router Cache** | Client-side | Prefetched and visited routes cached in browser |
 
-### Revalidation
-
-```tsx
-// Time-based — revalidate every 60 seconds
-fetch(url, { next: { revalidate: 60 } });
-
-// On-demand — revalidate by path or tag
-import { revalidatePath, revalidateTag } from 'next/cache';
-revalidatePath('/blog');
-revalidateTag('posts');
-
-// Tag a fetch for on-demand revalidation
-fetch(url, { next: { tags: ['posts'] } });
-```
+On-demand revalidation: `revalidatePath('/blog')` or `revalidateTag('posts')`. Tag a fetch: `fetch(url, { next: { tags: ['posts'] } })`.
 
 ## Routing
 
@@ -166,211 +110,61 @@ fetch(url, { next: { tags: ['posts'] } });
 
 | File | Purpose |
 |------|---------|
-| `page.tsx` | Route UI (makes segment publicly accessible) |
-| `layout.tsx` | Shared layout (wraps children, persists across navigation) |
+| `page.tsx` | Route UI |
+| `layout.tsx` | Shared layout (persists across navigation) |
 | `template.tsx` | Like layout but re-mounts on navigation |
 | `loading.tsx` | Loading UI (automatic Suspense boundary) |
-| `error.tsx` | Error UI (Client Component, automatic error boundary) |
+| `error.tsx` | Error UI (Client Component) |
 | `not-found.tsx` | 404 UI |
-| `route.ts` | API endpoint (no UI) |
+| `route.ts` | API endpoint |
 | `default.tsx` | Fallback for parallel routes |
 
 ### Dynamic Routes
 
-```
-app/blog/[slug]/page.tsx        → /blog/:slug
-app/shop/[...slug]/page.tsx     → /shop/:slug+ (catch-all)
-app/shop/[[...slug]]/page.tsx   → /shop or /shop/:slug+ (optional catch-all)
-```
-
-### Route Handlers (API Routes)
-
-```ts
-// app/api/users/route.ts
-import { NextRequest, NextResponse } from 'next/server';
-
-export async function GET(request: NextRequest) {
-  const { searchParams } = request.nextUrl;
-  const query = searchParams.get('q');
-  const users = await findUsers(query);
-  return NextResponse.json(users);
-}
-
-export async function POST(request: NextRequest) {
-  const body = await request.json();
-  const user = await createUser(body);
-  return NextResponse.json(user, { status: 201 });
-}
-```
-
-## Error Handling
-
-```tsx
-// app/dashboard/error.tsx — must be a Client Component
-'use client';
-export default function DashboardError({ error, reset }: { error: Error; reset: () => void }) {
-  return <div role="alert"><h2>Something went wrong</h2><button onClick={reset}>Try again</button></div>;
-}
-```
-
-```tsx
-// app/projects/[id]/page.tsx — trigger not-found boundary
-import { notFound } from 'next/navigation';
-export default async function ProjectPage({ params }: { params: { id: string } }) {
-  const project = await getProject(params.id);
-  if (!project) notFound();
-  return <h1>{project.name}</h1>;
-}
-```
+- `app/blog/[slug]/page.tsx` → `/blog/:slug`
+- `app/shop/[...slug]/page.tsx` → `/shop/:slug+` (catch-all)
+- `app/shop/[[...slug]]/page.tsx` → `/shop` or `/shop/:slug+` (optional)
 
 ## Middleware
 
-Runs at the Edge before every matched request. Use for auth, redirects, rewrites, headers.
+Runs at the Edge before every matched request. Use for auth, redirects, rewrites.
 
 ```ts
 import { NextResponse, type NextRequest } from 'next/server';
-
-export function middleware(request: NextRequest) {
-  const token = request.cookies.get('session')?.value;
-  if (!token && request.nextUrl.pathname.startsWith('/dashboard')) {
-    return NextResponse.redirect(new URL('/login', request.url));
-  }
-  // Add custom headers
-  const response = NextResponse.next();
-  response.headers.set('x-request-id', crypto.randomUUID());
-  return response;
+export function middleware(req: NextRequest) {
+  if (!req.cookies.get('session') && req.nextUrl.pathname.startsWith('/dashboard'))
+    return NextResponse.redirect(new URL('/login', req.url));
+  return NextResponse.next();
 }
-
-export const config = { matcher: ['/dashboard/:path*', '/settings/:path*'] };
+export const config = { matcher: ['/dashboard/:path*'] };
 ```
 
-## Configuration
-
-### `next.config.ts`
-
-```ts
-import type { NextConfig } from 'next';
-
-const nextConfig: NextConfig = {
-  reactStrictMode: true,
-  images: {
-    remotePatterns: [
-      { protocol: 'https', hostname: 'cdn.example.com' },
-    ],
-  },
-  experimental: {
-    ppr: true,                    // Partial Prerendering
-    typedRoutes: true,            // Type-safe <Link> hrefs
-  },
-  // Redirects, rewrites, headers
-  async redirects() {
-    return [{ source: '/old-path', destination: '/new-path', permanent: true }];
-  },
-};
-
-export default nextConfig;
-```
-
-### Environment Variables
+## Environment Variables
 
 | Prefix | Available in | Use Case |
 |--------|-------------|----------|
 | `NEXT_PUBLIC_` | Server + Client | Public values (API base URLs, feature flags) |
 | No prefix | Server only | Secrets (DB URLs, API keys, tokens) |
 
-Files loaded (in priority order): `.env.local`, `.env.development` / `.env.production`, `.env`.
-
-## Image and Font Optimization
-
-### Images
-
-```tsx
-import Image from 'next/image';
-import heroImg from '@/public/hero.jpg';
-
-// Local image — auto width/height from import
-<Image src={heroImg} alt="Hero" priority />
-
-// Remote image — must specify dimensions
-<Image src="https://cdn.example.com/photo.jpg" alt="Photo" width={800} height={600} />
-```
-
-### Fonts
-
-```tsx
-// app/layout.tsx
-import { Inter } from 'next/font/google';
-const inter = Inter({ subsets: ['latin'], display: 'swap' });
-
-export default function RootLayout({ children }: { children: React.ReactNode }) {
-  return <html lang="en" className={inter.className}><body>{children}</body></html>;
-}
-```
-
-## Metadata and SEO
-
-```tsx
-// app/layout.tsx — static metadata
-import type { Metadata } from 'next';
-
-export const metadata: Metadata = {
-  title: { default: 'My App', template: '%s | My App' },
-  description: 'App description',
-  openGraph: { title: 'My App', description: 'App description', type: 'website' },
-};
-```
-
-```tsx
-// app/blog/[slug]/page.tsx — dynamic metadata
-import type { Metadata } from 'next';
-
-export async function generateMetadata({ params }: { params: { slug: string } }): Promise<Metadata> {
-  const post = await getPost(params.slug);
-  return { title: post.title, description: post.excerpt };
-}
-```
-
-## Performance Patterns
-
-- **Default to Server Components** — smaller client bundles, faster paint.
-- **`<Suspense>` + `loading.tsx`** — stream content progressively; never block the whole page.
-- **`Promise.all()`** — parallel data fetching for independent data.
-- **Dynamic imports** — lazy-load heavy Client Components with `next/dynamic`.
-- **`<Image>`** — automatic lazy loading, responsive sizing, format conversion.
-- **`next/font`** — zero layout shift, self-hosted fonts.
-- **Route segment config** — fine-tune caching and rendering per route.
-
-## Deployment
-
-Next.js deploys to multiple targets:
-
-| Target | Config | Notes |
-|--------|--------|-------|
-| **Vercel** | Zero-config | Full feature support including Edge, ISR, Middleware |
-| **Node.js server** | `output: 'standalone'` | Minimal `standalone/` folder with server |
-| **Docker** | `output: 'standalone'` | Copy `.next/standalone` + `.next/static` + `public` |
-| **Static export** | `output: 'export'` | No server features (no SSR, API routes, middleware) |
+Files (priority order): `.env.local`, `.env.development` / `.env.production`, `.env`.
 
-## Component Practices & Naming
+## Image, Font, and Metadata
 
-- PascalCase for component files/exports. camelCase for hooks.
-- Shared components in `components/`. Route-specific components co-located in route folder.
-- TypeScript interfaces for props. Explicit types and defaults.
-- Co-locate tests with components.
-- Folders: `kebab-case`. Types/Interfaces: `PascalCase`. Constants: `UPPER_SNAKE_CASE`.
+- **Images**: Use `<Image>` from `next/image` — auto lazy loading, responsive sizing, format conversion. Configure `images.remotePatterns` in `next.config.ts` for remote URLs.
+- **Fonts**: Use `next/font/google` — zero layout shift, self-hosted, no external network request.
+- **Metadata**: Export `metadata` (static) or `generateMetadata` (dynamic) per page/layout for SEO and social previews.
 
 ## Anti-Patterns
 
 | Anti-Pattern | Why It's Wrong | Do This Instead |
 |-------------|---------------|-----------------|
-| `'use client'` on every component | Bloats JS bundle, defeats RSC benefits | Default to Server Components; add `'use client'` only when needed |
-| Sequential `await` for independent data | Creates a waterfall, slows page load | Use `Promise.all()` for parallel fetches |
-| `next/dynamic` with `ssr: false` in Server Components | Build/runtime crash | Extract to a Client Component, import normally |
-| Fetching in `useEffect` when server fetch works | Extra client roundtrip, loading flash | Fetch in the Server Component or use Server Actions |
-| Giant `layout.tsx` with all providers | Hard to test, couples unrelated concerns | Split providers into a `Providers` Client Component |
-| Catching errors without `error.tsx` | Unhandled errors crash the page | Add `error.tsx` per route segment |
-| Hardcoding secrets in source files | Security risk, leaks in version control | Use `.env.local` and `process.env` |
+| `'use client'` on every component | Bloats JS bundle, defeats RSC benefits | Default to Server Components |
+| Sequential `await` for independent data | Waterfall, slows page load | Use `Promise.all()` |
+| `next/dynamic` with `ssr: false` in Server Components | Build/runtime crash | Extract to Client Component |
+| Fetching in `useEffect` when server fetch works | Extra roundtrip, loading flash | Fetch in Server Component or Server Actions |
+| Giant `layout.tsx` with all providers | Hard to test, couples concerns | Split into a `Providers` Client Component |
+| No `error.tsx` per segment | Unhandled errors crash the page | Add `error.tsx` per route segment |
+| Hardcoding secrets in source | Security risk, version control leak | Use `.env.local` and `process.env` |
 | Skipping `loading.tsx` / `<Suspense>` | Blank screen while data loads | Add `loading.tsx` or wrap in `<Suspense>` |
-| Using `getServerSideProps` / `getStaticProps` | Legacy Pages Router patterns | Use App Router with `async` Server Components |
-| Ignoring `next.config.ts` for images | Remote images blocked by default | Configure `images.remotePatterns` |
+| `getServerSideProps` / `getStaticProps` | Legacy Pages Router | Use App Router with async Server Components |
 | Missing `metadata` exports | Poor SEO, no social previews | Export `metadata` or `generateMetadata` per page |

package/src/orchestrator/plugins/notion/SKILL.md

@@ -0,0 +1,205 @@
+---
+name: notion-knowledge-management
+description: "Notion workspace patterns for knowledge capture, research documentation, architectural decisions, and spec management. Use when capturing research findings, writing specs, documenting decisions, or managing a team knowledge base."
+---
+
+<!-- ⚠️ This file is managed by OpenCastle. Edits will be overwritten on update. Customize in the .opencastle/ directory instead. -->
+
+# Knowledge Management with Notion
+
+Conventions for working with the team's Notion workspace via the official Notion MCP server. Covers page and database operations, research capture, decision documentation, and permission-aware workflows.
+
+## MCP Server
+
+| Field | Value |
+|-------|-------|
+| **Endpoint** | `https://mcp.notion.com/mcp` (HTTP, remote) |
+| **Auth** | OAuth — users authenticate via Notion account when the MCP connection is established |
+| **Type** | HTTP MCP (no local process to spawn) |
+
+### Authentication
+
+The Notion MCP server uses OAuth. When the MCP connection is first opened in your IDE, you will be prompted to authorise access to your Notion workspace. No API key or token is required in `.env`.
+
+> **Scope:** The integration is granted access only to pages and databases explicitly shared with it. Before using MCP tools, ensure the relevant pages/databases are shared with the OpenCastle integration in Notion.
+
+## Available MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `search` | Search pages and databases across the workspace by keyword |
+| `create_page` | Create a new page (standalone or inside a parent page/database) |
+| `update_page` | Update page properties or archive a page |
+| `append_block_children` | Append content blocks (paragraphs, headings, bullets, code) to a page |
+| `query_database` | Query a Notion database with filters and sorts |
+
+## Working with Pages and Databases
+
+### Page Hierarchy Hygiene
+
+Keep the workspace navigable by placing new pages in the right location:
+
+```
+Workspace root
+├── Engineering/
+│   ├── Architecture Decisions/   ← ADRs go here
+│   ├── Specs/                    ← Feature specs go here
+│   └── Research/                 ← Research notes go here
+├── Team/
+│   ├── Meeting Notes/            ← Meeting intelligence
+│   └── Decisions Log/            ← Key team decisions
+└── Project: <name>/              ← Per-project space
+    ├── Roadmap
+    ├── Known Issues
+    └── Release Notes/
+```
+
+- Always use `search` first to check if a page already exists before creating a new one.
+- Create pages as children of the appropriate parent — never at the workspace root unless explicitly requested.
+- Use databases (not flat pages) for collections that need filtering, sorting, or status tracking (e.g., ADRs, specs).
+
+### Page Creation Pattern
+
+When creating a page:
+
+1. `search` for an existing page with a similar title to avoid duplicates
+2. `create_page` with `parent` set to the correct parent page or database
+3. `append_block_children` to add structured content
+
+```json
+// Example: Create a spec page
+{
+  "parent": { "page_id": "<Engineering/Specs parent ID>" },
+  "properties": {
+    "title": [{ "type": "text", "text": { "content": "[Spec] Price Range Filter" } }]
+  }
+}
+```
+
+## Capturing Research and Decisions
+
+### Research Note Structure
+
+Use this outline when capturing research findings:
+
+```
+# [Research] <Topic>
+
+## Summary
+One-paragraph overview of findings.
+
+## Sources
+- <URL or reference> — <why it is relevant>
+
+## Key Findings
+- Finding 1
+- Finding 2
+
+## Implications
+How these findings affect the current task or architecture.
+
+## Open Questions
+- Question 1
+```
+
+### Architectural Decision Record (ADR) Structure
+
+```
+# ADR-NNN: <Short title>
+
+**Status:** Proposed | Accepted | Deprecated | Superseded
+**Date:** YYYY-MM-DD
+
+## Context
+What is the problem or decision to be made?
+
+## Decision
+What was decided?
+
+## Consequences
+What tradeoffs or follow-on work does this create?
+
+## Alternatives Considered
+- Option A — why rejected
+- Option B — why rejected
+```
+
+### Spec-to-Implementation Link
+
+When a spec page drives implementation, add an **Implementation** section at the bottom:
+
+```
+## Implementation
+- **Branch:** `feat/price-range-filter`
+- **PR:** <link>
+- **Tracker:** <Linear/Jira/Trello card link>
+- **Status:** In Progress / Done
+```
+
+This closes the loop between the knowledge base and the task tracker.
+
+## Meeting Intelligence
+
+When capturing meeting notes, use the following structure:
+
+```
+# Meeting: <Title> — YYYY-MM-DD
+
+**Attendees:** Name1, Name2
+**Type:** Planning / Review / Retrospective / Decision
+
+## Summary
+
+## Decisions Made
+- Decision 1 (owner: Name)
+
+## Action Items
+- [ ] Action item (owner: Name, due: YYYY-MM-DD)
+
+## Context / Discussion Notes
+```
+
+After the meeting, add action items to the task tracker.
+
+## Permission-Aware Workflows
+
+Notion access is page-scoped. Follow these rules to avoid permission errors:
+
+1. **Before writing** — run `search` to verify you can see the target page. If it does not appear, the integration has not been granted access.
+2. **Sharing** — ask the user to share the relevant page or database with the OpenCastle integration before running MCP tools against it.
+3. **Databases vs pages** — use `query_database` only on pages that are databases. Use `append_block_children` to add content to regular pages.
+4. **Archived pages** — `search` does not return archived pages. If a page is missing, it may have been archived. Ask the user to restore it.
+
+## Database Query Patterns
+
+### Filter by Status
+
+```json
+{
+  "filter": {
+    "property": "Status",
+    "select": { "equals": "In Progress" }
+  }
+}
+```
+
+### Sort by Last Edited
+
+```json
+{
+  "sorts": [
+    { "timestamp": "last_edited_time", "direction": "descending" }
+  ]
+}
+```
+
+## Agent Usage Guidelines
+
+| Agent | Primary Use |
+|-------|-------------|
+| **Team Lead** | Create spec pages, capture decisions, link tracker issues to specs |
+| **Researcher** | Capture research notes, query databases for prior art, document findings |
+| **Documentation Writer** | Write and update documentation pages, maintain page hierarchy |
+| **Architect** | Write ADRs, create technical specs, link specs to implementation PRs |
+
+**Never** delete pages via MCP — use `update_page` with `archived: true` if a page needs to be removed, and confirm with the user first.

package/src/orchestrator/plugins/notion/config.ts

@@ -0,0 +1,47 @@
+import type { PluginConfig } from '../types.js';
+
+export const config: PluginConfig = {
+  id: 'notion',
+  name: 'Notion',
+  category: 'team',
+  subCategory: 'knowledge-management',
+  label: 'Notion',
+  hint: 'Workspace knowledge base and documentation hub',
+  skillName: 'notion-knowledge-management',
+  mcpServerKey: 'Notion',
+  mcpConfig: {
+    type: 'http',
+    url: 'https://mcp.notion.com/mcp',
+  },
+  authType: 'oauth',
+  envVars: [],
+  agentToolMap: {
+    'team-lead': [
+      'Notion/search',
+      'Notion/create_page',
+      'Notion/update_page',
+      'Notion/query_database',
+      'Notion/append_block_children',
+    ],
+    'researcher': [
+      'Notion/search',
+      'Notion/create_page',
+      'Notion/append_block_children',
+      'Notion/query_database',
+    ],
+    'documentation-writer': [
+      'Notion/search',
+      'Notion/create_page',
+      'Notion/update_page',
+      'Notion/append_block_children',
+    ],
+    'architect': [
+      'Notion/search',
+      'Notion/create_page',
+      'Notion/update_page',
+      'Notion/query_database',
+    ],
+  },
+  docsUrl: 'https://www.opencastle.dev/docs/plugins#notion',
+  officialDocs: 'https://developers.notion.com/docs/mcp',
+};