opencastle 0.9.2 → 0.10.1

package/src/orchestrator/customizations/README.md

@@ -25,7 +25,8 @@ Skills reference these files with relative links like `../../customizations/stac
 | File | Purpose |
 |------|---------|
 | `agent-registry.md` | Specialist agents with model tier assignments and scope examples |
-| `skill-matrix.md` | Maps capability slots to concrete skill names per agent role |
+| `skill-matrix.json` | Maps capability slots to concrete skill names per agent role (machine-readable) |
+| `skill-matrix.md` | Documentation companion explaining the skill matrix concept |
 
 ### `stack/` — Tech stack config
 

package/src/orchestrator/customizations/agents/skill-matrix.json

@@ -0,0 +1,106 @@
+{
+  "bindings": {
+    "framework": {
+      "entries": [],
+      "description": "SSR/SSG, routing, layouts, Server/Client Components"
+    },
+    "database": {
+      "entries": [],
+      "description": "Schema, migrations, auth flow, roles"
+    },
+    "cms": {
+      "entries": [],
+      "description": "Document types, queries, schema management"
+    },
+    "deployment": {
+      "entries": [],
+      "description": "Hosting, cron jobs, env vars, caching, headers"
+    },
+    "codebase-tool": {
+      "entries": [],
+      "description": "Task running, building, linting, testing, code generation"
+    },
+    "testing": {
+      "entries": [],
+      "description": "Unit testing frameworks, coverage, test planning"
+    },
+    "e2e-testing": {
+      "entries": [],
+      "description": "Browser automation, E2E testing, viewport testing, visual validation"
+    },
+    "task-management": {
+      "entries": [],
+      "description": "Issue tracking, naming, priorities, workflow states"
+    }
+  },
+  "agents": {
+    "Developer": {
+      "slots": ["framework"],
+      "directSkills": ["validation-gates", "code-commenting", "react-development", "api-patterns"]
+    },
+    "Database Engineer": {
+      "slots": ["database"],
+      "directSkills": ["validation-gates", "security-hardening"]
+    },
+    "UI/UX Expert": {
+      "slots": ["e2e-testing"],
+      "directSkills": ["validation-gates", "frontend-design", "accessibility-standards", "react-development"]
+    },
+    "Content Engineer": {
+      "slots": ["cms"],
+      "directSkills": ["validation-gates"]
+    },
+    "Testing Expert": {
+      "slots": ["e2e-testing", "testing"],
+      "directSkills": ["validation-gates", "testing-workflow"]
+    },
+    "Security Expert": {
+      "slots": ["database"],
+      "directSkills": ["validation-gates", "documentation-standards", "security-hardening"]
+    },
+    "Data Expert": {
+      "slots": [],
+      "directSkills": ["validation-gates", "data-engineering"]
+    },
+    "DevOps Expert": {
+      "slots": ["deployment"],
+      "directSkills": ["validation-gates", "documentation-standards"]
+    },
+    "Performance Expert": {
+      "slots": [],
+      "directSkills": ["validation-gates", "performance-optimization"]
+    },
+    "Architect": {
+      "slots": ["codebase-tool"],
+      "directSkills": ["documentation-standards"]
+    },
+    "Copywriter": {
+      "slots": ["cms"],
+      "directSkills": ["documentation-standards"]
+    },
+    "SEO Specialist": {
+      "slots": ["framework", "cms"],
+      "directSkills": ["validation-gates", "documentation-standards", "seo-patterns"]
+    },
+    "API Designer": {
+      "slots": ["framework"],
+      "directSkills": ["validation-gates", "documentation-standards", "api-patterns", "security-hardening"]
+    },
+    "Release Manager": {
+      "slots": ["codebase-tool", "deployment"],
+      "directSkills": ["validation-gates", "documentation-standards"]
+    },
+    "Documentation Writer": {
+      "slots": [],
+      "directSkills": ["documentation-standards", "code-commenting"]
+    },
+    "Researcher": {
+      "slots": [],
+      "directSkills": ["context-map", "self-improvement"]
+    },
+    "Team Lead": {
+      "slots": ["task-management"],
+      "directSkills": ["team-lead-reference", "session-checkpoints", "validation-gates", "fast-review", "panel-majority-vote", "context-map", "memory-merger", "agent-hooks", "decomposition", "orchestration-protocols"]
+    }
+  }
+}

package/src/orchestrator/customizations/agents/skill-matrix.md

@@ -1,149 +1,86 @@
-````markdown
 # Skill Matrix
 
-Maps abstract technology capabilities to concrete skill implementations. Agents reference **capability slots** instead of hardcoded technology skills — when the stack changes, update the bindings here and all agents automatically resolve to the correct skill.
+Maps abstract technology capabilities to concrete skill implementations. The matrix distinguishes two types of skills:
 
-**Process/methodology skills** (session checkpoints, validation gates, self-improvement, etc.) are referenced directly in agent files — they don't go through the matrix.
+- **Binding slots** — Plugin-driven, technology-specific skills resolved at runtime (e.g., `database` → `supabase-database`). These change when the tech stack changes.
+- **Core skills** — Hardcoded, stack-agnostic skills referenced directly in agent files (e.g., `validation-gates`, `security-hardening`, `performance-optimization`). These are always available regardless of plugins.
+
+## Data File
+
+The machine-readable bindings are in [`skill-matrix.json`](skill-matrix.json). The CLI (`opencastle init` and `opencastle update`) reads and writes this file directly. Agents should read the JSON to resolve capability slots.
 
 ## How It Works
 
 ```
-Agent file                  Skill Matrix                 Skill file
+Agent file                  skill-matrix.json            Skill file
 ┌──────────────┐           ┌──────────────┐           ┌──────────────┐
-│ Developer    │           │ framework:   │           │ nextjs-      │
-│  needs:      │──lookup──▶│  nextjs      │──load────▶│ patterns     │
-│  framework   │           │              │           │              │
-│  ui-library  │           │ ui-library:  │           │ react-       │
-│  api-layer   │           │  react       │──load────▶│ development  │
-│              │           │              │           │              │
-│              │           │ api-layer:   │           │ api-         │
-│              │           │  nextjs-api  │──load────▶│ patterns     │
-│              │           │              │           │              │
+│ Developer    │           │ "framework": │           │ nextjs-      │
+│  needs:      │──lookup──▶│  entries: [  │──load────▶│ framework    │
+│  framework   │           │   {name,     │           │              │
+│              │           │    skill}    │           │              │
+│              │           │  ]           │           │              │
 └──────────────┘           └──────────────┘           └──────────────┘
 ```
 
 1. **Agents** declare which capability slots they need (e.g., `framework`, `database`)
-2. **This matrix** maps each slot to the current technology and its skill file
-3. **When delegating**, resolve slots through this matrix to load the correct skill
-4. **To switch tech**, update only the binding row — no agent files change
-
-## Stack Bindings
-
-<!-- Populated by the `bootstrap-customizations` prompt based on detected technologies. -->
-
-### Primary Stack
-
-| Slot | Technology | Skill | Description |
-|------|-----------|-------|-------------|
-| `language` | | _(general.instructions.md)_ | Primary programming language, type system |
-| `ui-library` | | | Component architecture, hooks, state, styling |
-| `framework` | | | SSR/SSG, routing, layouts, Server/Client Components |
-| `database` | | | Schema, migrations, auth flow, roles |
-| `cms` | | | Document types, queries, schema management |
-| `deployment` | | | Hosting, cron jobs, env vars, caching, headers |
-| `codebase-tool` | | | Task running, building, linting, testing, code generation |
-
-### Tooling
-
-| Slot | Technology | Skill | Description |
-|------|-----------|-------|-------------|
-| `api-layer` | | | API routes, validation, search architecture |
-| `data-pipeline` | | | ETL, scraping, data processing |
-| `testing` | | | Unit/integration tests, coverage, test planning |
-| `e2e-testing` | | | Browser automation, viewport testing, visual validation |
-| `task-management` | | | Issue tracking, naming, priorities, workflow states |
-
-### Disciplines
-
-| Slot | Approach | Skill | Description |
-|------|---------|-------|-------------|
-| `performance` | | `performance-optimization` | Bundle size, rendering, caching, profiling |
-| `security` | | `security-hardening` | Auth, headers, input validation, vulnerability mgmt |
-| `accessibility` | WCAG 2.2 Level AA | `accessibility-standards` | Keyboard nav, screen readers, contrast, semantics |
-| `design-system` | | `frontend-design` | Design thinking, typography, color, motion, layout |
-| `seo` | | `seo-patterns` | Technical SEO patterns for meta tags, JSON-LD, sitemaps, URL strategy |
-
-## Agent Capability Matrix
-
-Each row shows which capability slots an agent needs (resolved through this matrix) and which process skills it uses directly.
-
-| Agent | Capability Slots | Direct Skills |
-|-------|-----------------|---------------|
-| **Developer** | `framework`, `ui-library`, `api-layer` | `validation-gates` |
-| **Database Engineer** | `database`, `security` | — |
-| **UI/UX Expert** | `design-system`, `ui-library`, `accessibility` | `e2e-testing`¹ |
-| **Content Engineer** | `cms` | — |
-| **Testing Expert** | `e2e-testing`, `testing` | `validation-gates` |
-| **Security Expert** | `security`, `database` | — |
-| **Data Expert** | `data-pipeline` | — |
-| **DevOps Expert** | `deployment` | — |
-| **Performance Expert** | `performance` | — |
-| **Architect** | `codebase-tool` | `documentation-standards` |
-| **Copywriter** | `cms` | `documentation-standards` |
-| **SEO Specialist** | `framework`, `cms`, `seo` | — |
-| **API Designer** | `api-layer`, `framework`, `security` | — |
-| **Release Manager** | `codebase-tool`, `deployment` | `validation-gates`, `documentation-standards` |
-| **Documentation Writer** | — | `documentation-standards`, `code-commenting` |
-| **Researcher** | — | `context-map`, `self-improvement` |
-| **Team Lead** | `task-management` | `team-lead-reference`, `session-checkpoints`, `validation-gates`, `fast-review`, `panel-majority-vote`, `context-map`, `memory-merger`, `agent-hooks` |
-
-¹ UI/UX Expert uses `e2e-testing` as a utility (viewport resize commands) — resolved through the matrix like other slots.
-
-## Process Skills (Always Direct)
-
-These are methodology/workflow skills — not tied to any technology. Referenced directly in agent files, never through capability slots.
-
-| Skill | Purpose |
-|-------|---------|
-| `self-improvement` | Lessons-learned protocol, retry documentation |
-| `session-checkpoints` | Session state saving, resuming, forking |
-| `context-map` | File impact mapping before complex changes |
-| `panel-majority-vote` | 3-reviewer quality gate (PASS/BLOCK) |
-| `memory-merger` | Graduate lessons into permanent skills/instructions |
-| `code-commenting` | Self-documenting code patterns, annotation tags |
-| `agent-hooks` | Agent lifecycle hooks (session-start, session-end, etc.) |
-| `agent-memory` | Agent expertise tracking, cross-session knowledge graph |
-| `task-management` | Issue tracking conventions, naming, priorities |
-| `team-lead-reference` | Team Lead orchestration reference, model routing |
-| `fast-review` | Mandatory single-reviewer gate after every delegation |
-| `validation-gates` | Shared validation gate definitions (lint, test, build) |
-| `documentation-standards` | Documentation templates, formatting rules |
+2. **`skill-matrix.json`** maps each slot to one or more technologies and their skill files
+3. **When delegating**, resolve slots through the JSON to load the correct skill(s)
+4. **To switch tech**, update only the binding entries — no agent files change
+
+## Multiple Technologies Per Slot
+
+A slot can have multiple entries. For example, a project using both Supabase and Prisma:
+
+```json
+"database": {
+  "entries": [
+    { "name": "Supabase", "skill": "supabase-database" },
+    { "name": "Prisma", "skill": "prisma-database" }
+  ],
+  "description": "Schema, migrations, auth flow, roles"
+}
+```
+
+When resolving, load **all** skills listed in the slot's entries.
 
 ## Switching Technologies
 
-### Example: Supabase → Convex
+### Example: Migrate to a new plugin (Supabase → Azure)
 
-1. Create a new skill: `skills/convex-database/SKILL.md`
-2. Update this matrix: `database` row → Technology: `Convex`, Skill: `convex-database`
+1. Create (or install) the Azure plugin: `plugins/azure/SKILL.md` + `plugins/azure/config.ts`
+2. Update `skill-matrix.json`: replace the database entries
 3. Update `project.instructions.md` to reflect the new tech stack
 4. **No agent files change** — Database Engineer, Security Expert still reference the `database` slot
 
-### Example: React → Svelte + Next.js → SvelteKit
+### Example: Migrate to an existing plugin (Linear → Jira)
 
-1. Create skills: `skills/svelte-development/SKILL.md`, `skills/sveltekit-patterns/SKILL.md`
-2. Update matrix: `ui-library` → `Svelte` / `svelte-development`
-3. Update matrix: `framework` → `SvelteKit` / `sveltekit-patterns`
-4. Update `project.instructions.md` and `general.instructions.md`
-5. **No agent files change** — Developer, UI/UX Expert still reference `framework` and `ui-library` slots
+1. Plugin already exists: `plugins/jira/SKILL.md`
+2. Update `skill-matrix.json`: replace the `task-management` entries
+3. **No agent files change** — Team Lead still references the `task-management` slot
 
-### Example: Jest → Vitest
+### Example: Add a second plugin
 
-1. Create skill: `skills/vitest-workflow/SKILL.md`
-2. Update matrix: `testing` → `Vitest` / `vitest-workflow`
-3. **No agent files change** — Testing Expert still references the `testing` slot
+1. Update `skill-matrix.json`: add another entry to the `framework` slot
+2. Both framework skills will be loaded when agents resolve the `framework` slot
 
-### Example: Linear → Jira
+## Missing Plugin or Empty Slot
 
-1. Skill already exists: `skills/jira-management/SKILL.md`
-2. Update matrix: `task-management` → `Jira` / `jira-management`
-3. **No agent files change** — Team Lead still references the `task-management` slot
+When resolving a capability slot, two failure cases can occur:
+
+1. **Empty slot** — The slot's `entries` array is empty (no plugin installed for that technology). Example: an agent needs `database` but no database plugin was selected during `opencastle init`.
+2. **Missing plugin** — The slot references a skill name (e.g., `"skill": "convex-database"`) but no matching plugin `SKILL.md` file exists on disk.
+
+In both cases, **tell the user** that the capability is unavailable and why:
+
+- *"The `database` slot has no entries in `skill-matrix.json`. Install a database plugin (e.g., `supabase`, `prisma`) via `opencastle update`, or add entries manually."*
+- *"The `database` slot references skill `convex-database`, but no matching plugin was found. Install the Convex plugin or run `opencastle update` to fix the binding."*
+
+**Do NOT silently skip the slot or proceed without the skill.** The agent should surface the gap clearly so the user can resolve it.
 
 ## Design Principles
 
-1. **Single source of truth** — Technology choices live here, not scattered across agent files
+1. **Single source of truth** — All skill assignments (slots and direct) live in `skill-matrix.json`, not in agent files
 2. **Agents are stack-agnostic** — They describe *what* they need, not *which* tool they use
-3. **Swap without rewriting** — Changing one matrix row updates every agent that uses that slot
-4. **Process skills are stable** — Methodology doesn't change with technology; direct references are fine
-5. **Capability slots are composable** — Agents can combine any slots (e.g., Security Expert needs both `security` + `database`)
-
-````
+3. **Swap without rewriting** — Changing entries updates every agent that uses that slot
+4. **Process skills are stable** — Methodology doesn't change with technology; direct skill references in the matrix are fine
+5. **Capability slots are composable** — Agents can combine slots and direct skills freely (e.g., Security Expert uses the `database` slot + `security-hardening` direct skill)

package/src/orchestrator/instructions/general.instructions.md

@@ -34,7 +34,7 @@ applyTo: '**'
 
 ## Technology Standards
 
-Load the corresponding skill for detailed conventions before writing code in that domain. These are **not optional**. See `.github/customizations/agents/skill-matrix.md` for the full domain-to-skill mapping.
+Load the corresponding skill for detailed conventions before writing code in that domain. These are **not optional**. See `.github/customizations/agents/skill-matrix.json` for the full domain-to-skill mapping.
 
 | Domain | Skill |
 |--------|-------|

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

@@ -0,0 +1,288 @@
+---
+name: astro-framework
+description: "Astro framework best practices for content-driven sites, islands architecture, routing, integrations, and project structure. Use when creating or modifying Astro pages, layouts, components, or content collections."
+---
+
+<!-- ⚠️ This file is managed by OpenCastle. Edits will be overwritten on update. Customize in the .github/customizations/ directory instead. -->
+
+# Astro Framework
+
+## Project Structure
+
+- **Use `src/pages/` directory** for file-based routing. Each `.astro`, `.md`, or `.mdx` file becomes a route.
+- Top-level: `src/`, `public/`, `astro.config.mjs`.
+- Inside `src/`: `pages/`, `layouts/`, `components/`, `content/`, `styles/`, `assets/`.
+- **`public/`** — static assets served as-is (favicons, robots.txt, fonts).
+- **`src/assets/`** — images and assets processed by Astro's build pipeline.
+
+```
+src/
+├── pages/
+│   ├── index.astro          # → /
+│   ├── about.astro           # → /about
+│   └── blog/
+│       ├── index.astro       # → /blog
+│       └── [slug].astro      # → /blog/:slug
+├── layouts/
+│   └── BaseLayout.astro
+├── components/
+│   ├── Header.astro
+│   └── Counter.tsx           # React island
+├── content/
+│   └── blog/                 # Content collection
+│       ├── first-post.md
+│       └── second-post.md
+└── styles/
+    └── global.css
+```
+
+## Component Model
+
+**Default: Zero JS** — Astro components (`.astro`) render to HTML with no client-side JavaScript.
+
+**Islands Architecture** — Interactive components use `client:*` directives to hydrate only where needed.
+
+### Astro Components
+
+```astro
+---
+// Component script (runs at build time / server)
+interface Props {
+  title: string;
+  description?: string;
+}
+const { title, description = 'Default description' } = Astro.props;
+const data = await fetch('https://api.example.com/data').then(r => r.json());
+---
+
+<section>
+  <h2>{title}</h2>
+  <p>{description}</p>
+  <ul>
+    {data.items.map((item: { id: string; name: string }) => (
+      <li>{item.name}</li>
+    ))}
+  </ul>
+</section>
+
+<style>
+  /* Scoped by default */
+  section { max-width: 800px; margin: 0 auto; }
+</style>
+```
+
+### Client Directives (Islands)
+
+| Directive | When It Hydrates | Use Case |
+|-----------|-----------------|----------|
+| `client:load` | Immediately on page load | Critical interactive UI |
+| `client:idle` | After page is idle | Non-critical UI (analytics widgets) |
+| `client:visible` | When element enters viewport | Below-the-fold components |
+| `client:media="(max-width: 768px)"` | When media query matches | Mobile-only interactivity |
+| `client:only="react"` | Client-only, no SSR | Components that can't server-render |
+
+```astro
+---
+import Counter from '../components/Counter.tsx';
+import HeavyChart from '../components/HeavyChart.tsx';
+---
+
+<!-- Hydrates immediately -->
+<Counter client:load />
+
+<!-- Hydrates when visible -->
+<HeavyChart client:visible />
+```
+
+## Content Collections
+
+Define collections in `src/content.config.ts` (Astro v5+) using the Content Layer API:
+
+```ts
+import { defineCollection, z } from 'astro:content';
+import { glob } from 'astro/loaders';
+
+const blog = defineCollection({
+  loader: glob({ pattern: '**/*.{md,mdx}', base: './src/content/blog' }),
+  schema: z.object({
+    title: z.string(),
+    description: z.string(),
+    pubDate: z.coerce.date(),
+    updatedDate: z.coerce.date().optional(),
+    heroImage: z.string().optional(),
+    draft: z.boolean().default(false),
+    tags: z.array(z.string()).default([]),
+  }),
+});
+
+export const collections = { blog };
+```
+
+### Querying Collections
+
+```astro
+---
+import { getCollection, getEntry } from 'astro:content';
+
+// All published posts, sorted by date
+const posts = (await getCollection('blog', ({ data }) => !data.draft))
+  .sort((a, b) => b.data.pubDate.valueOf() - a.data.pubDate.valueOf());
+
+// Single entry
+const entry = await getEntry('blog', 'first-post');
+---
+```
+
+## Routing
+
+### Static Routes
+
+Every `.astro` or `.md` file in `src/pages/` becomes a route.
+
+### Dynamic Routes
+
+```astro
+---
+// src/pages/blog/[slug].astro
+import { getCollection } from 'astro:content';
+
+export async function getStaticPaths() {
+  const posts = await getCollection('blog');
+  return posts.map(post => ({
+    params: { slug: post.id },
+    props: { post },
+  }));
+}
+
+const { post } = Astro.props;
+const { Content } = await post.render();
+---
+
+<Content />
+```
+
+### Server-Side Rendering (On-Demand)
+
+Enable SSR with an adapter in `astro.config.mjs`:
+
+```js
+import { defineConfig } from 'astro/config';
+import node from '@astrojs/node';
+
+export default defineConfig({
+  output: 'server', // or 'hybrid' for mixed static + server
+  adapter: node({ mode: 'standalone' }),
+});
+```
+
+## Layouts
+
+```astro
+---
+// src/layouts/BaseLayout.astro
+interface Props {
+  title: string;
+  description?: string;
+}
+const { title, description = 'My Astro Site' } = Astro.props;
+---
+
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="description" content={description} />
+    <title>{title}</title>
+  </head>
+  <body>
+    <slot />
+  </body>
+</html>
+```
+
+## Integrations
+
+Use `astro add` for official integrations:
+
+```bash
+npx astro add react        # Add React support
+npx astro add tailwind     # Add Tailwind CSS v4
+npx astro add mdx          # Add MDX support
+npx astro add sitemap      # Add sitemap generation
+npx astro add node         # Add Node.js SSR adapter
+npx astro add vercel       # Add Vercel adapter
+npx astro add netlify      # Add Netlify adapter
+npx astro add cloudflare   # Add Cloudflare adapter
+```
+
+## API Routes (Endpoints)
+
+```ts
+// src/pages/api/search.ts
+import type { APIRoute } from 'astro';
+
+export const GET: APIRoute = async ({ url }) => {
+  const query = url.searchParams.get('q');
+  const results = await searchDatabase(query);
+  return new Response(JSON.stringify(results), {
+    headers: { 'Content-Type': 'application/json' },
+  });
+};
+
+export const POST: APIRoute = async ({ request }) => {
+  const body = await request.json();
+  // handle mutation
+  return new Response(JSON.stringify({ ok: true }), { status: 200 });
+};
+```
+
+## Actions (Server Mutations)
+
+Define type-safe server actions in `src/actions/index.ts`:
+
+```ts
+import { defineAction } from 'astro:actions';
+import { z } from 'astro:schema';
+
+export const server = {
+  subscribe: defineAction({
+    accept: 'form',
+    input: z.object({ email: z.string().email() }),
+    handler: async ({ email }) => {
+      await addToNewsletter(email);
+      return { success: true };
+    },
+  }),
+};
+```
+
+## Performance Patterns
+
+- **Zero JS by default** — only ship JavaScript for interactive islands.
+- **Image optimization** — use `astro:assets` for automatic image optimization.
+- **View Transitions** — use `<ViewTransitions />` for smooth page navigation.
+- **Prefetching** — enabled by default for visible links.
+- **CSS scoping** — styles in `.astro` files are scoped automatically.
+
+```astro
+---
+import { Image } from 'astro:assets';
+import heroImage from '../assets/hero.jpg';
+---
+
+<Image src={heroImage} alt="Hero" width={800} />
+```
+
+## Anti-Patterns
+
+| Anti-Pattern | Why It's Wrong | Do This Instead |
+|-------------|---------------|-----------------|
+| `client:load` on every component | Defeats zero-JS benefit, bloats bundle | Use `client:idle` or `client:visible` for non-critical UI |
+| Importing large JS libraries in `.astro` | Runs at build but bundles nothing useful | Import in framework components with `client:*` |
+| Skipping content collections for blog/docs | Manual file handling is error-prone | Use content collections with typed schemas |
+| Hardcoding data in pages | Not maintainable, no type safety | Use content collections or fetch from APIs |
+| Using `client:only` when SSR works | Loses SEO benefits and fast first paint | Use `client:load` or `client:visible` instead |
+| Giant monolithic pages | Hard to maintain and test | Split into layouts + reusable components |
+| Ignoring `astro add` for integrations | Manual config is error-prone | Use `astro add` for official integrations |
+| Missing `alt` on images | Accessibility violation | Always provide descriptive `alt` text |

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

@@ -0,0 +1,28 @@
+import type { PluginConfig } from '../types.js';
+
+export const config: PluginConfig = {
+  id: 'astro',
+  name: 'Astro',
+  category: 'tech',
+  subCategory: 'framework',
+  label: 'Astro',
+  hint: 'Content-driven web framework with islands architecture and Docs MCP',
+  skillName: 'astro-framework',
+  mcpServerKey: 'Astro docs',
+  mcpConfig: {
+    type: 'http',
+    url: 'https://mcp.docs.astro.build/mcp',
+  },
+  authType: 'none',
+  envVars: [],
+  agentToolMap: {
+    'developer': [
+      'astro-docs/search_astro_docs',
+    ],
+    'documentation-writer': [
+      'astro-docs/search_astro_docs',
+    ],
+  },
+  docsUrl: 'https://www.opencastle.dev/docs/plugins#astro',
+  officialDocs: 'https://docs.astro.build',
+};

package/src/orchestrator/plugins/chrome-devtools/config.ts

@@ -4,7 +4,7 @@ export const config: PluginConfig = {
   id: 'chrome-devtools',
   name: 'Chrome DevTools',
   category: 'tech',
-  subCategory: 'testing',
+  subCategory: 'e2e-testing',
   label: 'Chrome DevTools',
   hint: 'Browser testing, screenshots, DOM inspection',
   skillName: 'browser-testing',
@@ -22,7 +22,7 @@ export const config: PluginConfig = {
     'testing-expert': ['chrome-devtools/*'],
     'ui-ux-expert': ['chrome-devtools/*'],
   },
-  docsUrl: '/guides/plugins#chrome-devtools',
+  docsUrl: 'https://www.opencastle.dev/docs/plugins#chrome-devtools',
   officialDocs: 'https://developer.chrome.com/docs/devtools',
   mcpPackage: 'chrome-devtools-mcp',
   preselected: true,