code-ai-installer 1.3.0 → 1.4.0

package/locales/en/.agents/skills/typescript_beast_practices/SKILL.md

@@ -0,0 +1,435 @@
+---
+name: typescript_beast_practices
+description: Senior-level TypeScript practices: strict mode, utility types, discriminated unions, type guards, branded types, type-safe API contracts with Zod, safe DTOs, minimizing any/as. Use this skill when writing or reviewing any TypeScript code — especially when typing API responses, modeling domain states, working with generics, and for questions "how to properly type X".
+---
+
+# Skill: TypeScript Beast Practices
+
+Specific DO/DON'T patterns for type-safe, refactoring-friendly code.
+
+**Sections:**
+1. [Configuration: strict and why](#1-configuration)
+2. [Utility Types: built-in tools](#2-utility-types)
+3. [Discriminated Unions: modeling states](#3-discriminated-unions)
+4. [Type Guards and Narrowing](#4-type-guards)
+5. [Branded Types: semantic safety](#5-branded-types)
+6. [Generics: when and how](#6-generics)
+7. [Zod: type-safe boundaries](#7-zod)
+8. [Bans: any, as, !](#8-bans)
+
+---
+
+## 1. Configuration
+
+### ✅ DO: minimal strict tsconfig
+```json
+{
+  "compilerOptions": {
+    "strict": true,               // enables all flags below at once
+    "noUncheckedIndexedAccess": true, // arr[i] → T | undefined, not T
+    "noImplicitReturns": true,    // all branches must return a value
+    "noFallthroughCasesInSwitch": true,
+    "exactOptionalPropertyTypes": true, // { a?: string } ≠ { a: string | undefined }
+    "moduleResolution": "bundler",
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM"]
+  }
+}
+```
+
+### What `strict: true` includes
+| Flag | What it catches |
+|---|---|
+| `strictNullChecks` | `null`/`undefined` are not assignable to any type |
+| `strictFunctionTypes` | Unsafe function parameter covariance |
+| `strictPropertyInitialization` | Class fields must be initialized |
+| `noImplicitAny` | Ban on implicit `any` |
+| `noImplicitThis` | `this` must be typed |
+
+---
+
+## 2. Utility Types
+
+### ✅ DO: use built-in instead of manual duplication
+```ts
+type User = {
+  id: string;
+  name: string;
+  email: string;
+  passwordHash: string;
+  createdAt: Date;
+};
+
+// ✅ Remove sensitive fields for API response
+type PublicUser = Omit<User, "passwordHash">;
+
+// ✅ All fields are optional — for PATCH requests
+type UpdateUserDto = Partial<Omit<User, "id" | "createdAt">>;
+
+// ✅ Only essential fields — for a form
+type LoginForm = Pick<User, "email"> & { password: string };
+
+// ✅ Read-only fields — for immutable objects
+type FrozenUser = Readonly<User>;
+
+// ✅ Dictionary by id
+type UserMap = Record<string, User>;
+```
+
+### ✅ DO: ReturnType / Parameters for type inference
+```ts
+// ✅ Type is taken from the implementation — doesn't diverge on refactoring
+async function fetchUser(id: string) {
+  return db.users.findUnique({ where: { id } });
+}
+
+type UserFromDB = Awaited<ReturnType<typeof fetchUser>>; // User | null
+
+// ✅ Type of function parameters
+type FetchUserArgs = Parameters<typeof fetchUser>; // [string]
+```
+
+### ✅ DO: Mapped Types for transformations
+```ts
+// ✅ All fields become nullable
+type Nullable<T> = { [K in keyof T]: T[K] | null };
+
+// ✅ All fields become promises
+type Promised<T> = { [K in keyof T]: Promise<T[K]> };
+
+// ✅ Only numeric fields
+type NumericFields<T> = {
+  [K in keyof T as T[K] extends number ? K : never]: T[K];
+};
+
+type Stats = { clicks: number; views: number; label: string };
+type NumericStats = NumericFields<Stats>; // { clicks: number; views: number }
+```
+
+---
+
+## 3. Discriminated Unions
+
+### ✅ DO: model states explicitly — not with boolean flags
+```ts
+// ❌ Bad: flags can be in invalid combinations
+type RequestBad = {
+  isLoading: boolean;
+  data: User | null;
+  error: string | null;
+  // What does isLoading=true AND data!=null mean? Undefined.
+};
+
+// ✅ Good: each state is a separate type, invalid combinations are impossible
+type RequestState<T> =
+  | { status: "idle" }
+  | { status: "loading" }
+  | { status: "success"; data: T }
+  | { status: "error"; error: string };
+
+// ✅ TypeScript narrows the type in each branch
+function renderUser(state: RequestState<User>) {
+  switch (state.status) {
+    case "loading": return <Spinner />;
+    case "error":   return <Alert>{state.error}</Alert>;  // state.error is accessible
+    case "success": return <Profile user={state.data} />; // state.data is accessible
+    case "idle":    return null;
+  }
+}
+```
+
+### ✅ DO: exhaustive check — TS complains if a branch is forgotten
+```ts
+function assertNever(x: never): never {
+  throw new Error(`Unhandled case: ${JSON.stringify(x)}`);
+}
+
+function renderState(state: RequestState<User>) {
+  switch (state.status) {
+    case "idle":    return null;
+    case "loading": return <Spinner />;
+    case "success": return <Profile user={state.data} />;
+    case "error":   return <Alert>{state.error}</Alert>;
+    default:        return assertNever(state); // ❌ compilation error if branch is forgotten
+  }
+}
+```
+
+### ✅ DO: Result type instead of throw
+```ts
+type Result<T, E = string> =
+  | { ok: true;  value: T }
+  | { ok: false; error: E };
+
+async function parseConfig(raw: string): Promise<Result<Config>> {
+  try {
+    return { ok: true, value: JSON.parse(raw) as Config };
+  } catch {
+    return { ok: false, error: "Invalid JSON" };
+  }
+}
+
+// Usage — explicit handling of both cases
+const result = await parseConfig(input);
+if (!result.ok) {
+  console.error(result.error);
+  return;
+}
+console.log(result.value); // Config — narrowed automatically
+```
+
+---
+
+## 4. Type Guards
+
+### ✅ DO: user-defined type guard instead of as
+```ts
+// ❌ Bad: as — forced cast, bypasses the type checker
+function processResponse(data: unknown) {
+  const user = data as User; // TS trusts you — but might explode in runtime
+  console.log(user.name);
+}
+
+// ✅ Good: guard checks the structure in runtime
+function isUser(value: unknown): value is User {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "id"    in value && typeof (value as any).id    === "string" &&
+    "name"  in value && typeof (value as any).name  === "string" &&
+    "email" in value && typeof (value as any).email === "string"
+  );
+}
+
+function processResponse(data: unknown) {
+  if (!isUser(data)) throw new Error("Invalid user shape");
+  console.log(data.name); // ✅ type User is guaranteed
+}
+```
+
+### ✅ DO: Zod as a type guard on steroids (see section 7)
+```ts
+// ✅ Zod generates both the type and the runtime validation from a single source
+const UserSchema = z.object({ id: z.string(), name: z.string() });
+type User = z.infer<typeof UserSchema>; // type is inferred automatically
+
+const result = UserSchema.safeParse(data);
+if (!result.success) throw new Error("Invalid");
+const user = result.data; // User — verified at runtime
+```
+
+### ✅ DO: narrowing via `in` and `instanceof`
+```ts
+type Cat = { meow: () => void };
+type Dog = { bark: () => void };
+
+function makeSound(animal: Cat | Dog) {
+  if ("meow" in animal) {
+    animal.meow(); // Cat
+  } else {
+    animal.bark(); // Dog
+  }
+}
+
+function handleError(err: unknown) {
+  if (err instanceof Error) {
+    console.error(err.message); // Error — narrowed
+  } else {
+    console.error("Unknown error", err);
+  }
+}
+```
+
+---
+
+## 5. Branded Types
+
+### ✅ DO: branded types for semantically different strings/numbers
+```ts
+// ❌ Bad: UserId and OrderId — both are string, easy to confuse
+function getOrder(userId: string, orderId: string) { /* ... */ }
+getOrder(orderId, userId); // TS is silent, runtime breaks
+
+// ✅ Good: branded type makes types incompatible
+type Brand<T, B> = T & { readonly __brand: B };
+
+type UserId  = Brand<string, "UserId">;
+type OrderId = Brand<string, "OrderId">;
+
+function getOrder(userId: UserId, orderId: OrderId) { /* ... */ }
+
+// Creation via constructor/parser
+function toUserId(raw: string): UserId {
+  if (!raw.startsWith("usr_")) throw new Error("Invalid UserId");
+  return raw as UserId; // the only legitimate place for as
+}
+
+const uid = toUserId("usr_123");
+const oid = "ord_456" as OrderId;
+
+getOrder(uid, oid);   // ✅
+getOrder(oid, uid);   // ❌ compilation error — swapped arguments
+```
+
+---
+
+## 6. Generics
+
+### ✅ DO: generics with constraints — not just `<T>`
+```ts
+// ✅ T is constrained — doesn't accept just anything
+function getField<T extends object, K extends keyof T>(obj: T, key: K): T[K] {
+  return obj[key];
+}
+
+const name = getField({ name: "Alice", age: 30 }, "name"); // string
+// getField({ name: "Alice" }, "missing"); // ❌ compilation error
+
+// ✅ Generic with a default
+type ApiResponse<T = unknown> = {
+  data: T;
+  meta: { page: number; total: number };
+};
+```
+
+### ✅ DO: conditional types for smart utilities
+```ts
+// ✅ Type depends on the value of another type
+type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+
+type A = UnwrapPromise<Promise<string>>; // string
+type B = UnwrapPromise<number>;          // number
+
+// ✅ Flatten array
+type Flatten<T> = T extends Array<infer U> ? U : T;
+
+type C = Flatten<string[]>; // string
+type D = Flatten<number>;   // number
+```
+
+### ❌ DON'T: over-engineering generics
+```ts
+// ❌ Bad: generic for the sake of generic — adds complexity, doesn't add safety
+function identity<T>(x: T): T { return x; } // if used once — just write the type
+
+// ✅ Generics are needed when the type is used in >1 place in the signature
+function first<T>(arr: T[]): T | undefined { return arr[0]; }
+```
+
+---
+
+## 7. Zod
+
+### ✅ DO: single source of truth for type and validation
+```ts
+import { z } from "zod";
+
+// ✅ Schema = type + runtime validation from one place
+const CreateUserSchema = z.object({
+  email:    z.string().email(),
+  name:     z.string().min(1).max(100),
+  role:     z.enum(["admin", "user"]).default("user"),
+  age:      z.number().int().min(18).optional(),
+});
+
+type CreateUserDto = z.infer<typeof CreateUserSchema>; // type automatically
+
+// ✅ Validation at the boundary (HTTP controller)
+export async function createUser(req: Request, res: Response, next: NextFunction) {
+  const result = CreateUserSchema.safeParse(req.body);
+  if (!result.success) {
+    return next(AppError.validation(result.error.flatten()));
+  }
+  const dto = result.data; // CreateUserDto — type-safe
+  const user = await usersService.create(dto);
+  res.status(201).json({ id: user.id });
+}
+```
+
+### ✅ DO: transformations and refines in the schema
+```ts
+const DateRangeSchema = z.object({
+  from: z.string().datetime(),
+  to:   z.string().datetime(),
+}).refine(
+  data => new Date(data.from) <= new Date(data.to),
+  { message: "from must be before to", path: ["from"] }
+);
+
+// ✅ transform — parsing right into the needed type
+const NumericIdSchema = z.string().regex(/^\d+$/).transform(Number);
+type NumericId = z.infer<typeof NumericIdSchema>; // number
+```
+
+### ✅ DO: reusing schemas via extend/merge/pick
+```ts
+const UserBaseSchema = z.object({
+  name:  z.string(),
+  email: z.string().email(),
+});
+
+// ✅ Extends UserBaseSchema, adding a password
+const CreateUserSchema = UserBaseSchema.extend({
+  password: z.string().min(8),
+});
+
+const UpdateUserSchema = UserBaseSchema.partial(); // all fields are optional
+
+const PublicUserSchema = UserBaseSchema.pick({ name: true }); // only name
+```
+
+---
+
+## 8. Bans
+
+### ❌ DON'T: `any` — full disablement of the type checker
+```ts
+// ❌ any infects the whole type graph around it
+function process(data: any) {
+  data.foo.bar.baz; // TS is silent, runtime explodes
+}
+
+// ✅ unknown — safer alternative: requires narrowing before use
+function process(data: unknown) {
+  if (typeof data !== "object" || data === null) throw new Error("Expected object");
+  // now data: object — can be narrowed further
+}
+```
+
+### ❌ DON'T: `as` to "silence" errors
+```ts
+// ❌ as — silent promise to the compiler that you might not keep
+const user = response.data as User; // what if there's null? or another type?
+
+// ✅ Check via Zod or a type guard
+const result = UserSchema.safeParse(response.data);
+if (!result.success) throw new Error("Unexpected API shape");
+const user = result.data; // User — actually verified
+```
+
+### ❌ DON'T: `!` non-null assertion without a guarantee
+```ts
+// ❌ ! tells TS "trust me, it's not null" — dangerous
+const el = document.getElementById("app")!;
+el.innerHTML = "Hello"; // if there's no element — explosion
+
+// ✅ Explicit check
+const el = document.getElementById("app");
+if (!el) throw new Error("#app element not found");
+el.innerHTML = "Hello";
+```
+
+### When `as` and `!` are acceptable
+```ts
+// ✅ as — only in constructors of branded types (the only legitimate place)
+return raw as UserId;
+
+// ✅ ! — only when you 100% control the presence of the element (tests, seeding)
+const btn = screen.getByRole("button")!; // testing-library guarantees presence
+```
+
+---
+
+## See also
+- `dev_reference_snippets` → section 3 (Zod validation in controller)
+- `es2025_beast_practices` → destructuring, nullish coalescing

package/locales/en/.agents/skills/ui_a11y_smoke_review/SKILL.md

@@ -0,0 +1,195 @@
+---
+name: ui_a11y_smoke_review
+description: Quick UI/a11y smoke review by a designer — loading/empty/error states, focus, keyboard, aria/labels, compliance with UX Spec. Executed BEFORE handoff to QA.
+---
+
+# Skill: UI & A11y Smoke Review (Designer-Level)
+
+Quick designer-level check of UI for compliance with UX Spec + a11y baseline **before handoff to QA**.
+
+> **Difference from `$qa_ui_a11y_smoke`:** This skill is a designer's quick check (5-10 min, against UX Spec).
+> `$qa_ui_a11y_smoke` is a formal QA test (25 WCAG checks, tools, report).
+
+**Sections:**
+1. [Workflow](#1-workflow)
+2. [Checklist](#2-checklist)
+3. [UX Spec Compliance](#3-ux-compliance)
+4. [Quick A11y Scan](#4-a11y-scan)
+5. [Output Template](#5-output)
+
+---
+
+## 1. Workflow
+
+```
+1. Input:
+   ├── Implemented UI (browser / screenshots)
+   ├── UX Spec (from $ux_spec) — source of truth
+   └── A11y Baseline (from $a11y_baseline) — requirements
+
+2. Visual walkthrough per screen:
+   a. Does layout match UX Spec?
+   b. Are all components/sections present?
+   c. Are all 4 states implemented (loading/empty/error/success)?
+   d. Quick keyboard pass (Tab through interactive elements)
+
+3. Classify issues:
+   ├── P0: Missing critical states, broken flow, inaccessible
+   ├── P1: Wrong component, missing state, inconsistency
+   └── P2: Polish, spacing, cosmetic
+
+4. Report → DEV fixes before formal QA
+
+Note: This is a QUICK check. For formal testing → $qa_ui_a11y_smoke
+```
+
+---
+
+## 2. Checklist
+
+### 2.1 Visual & Layout
+
+| # | Check | UX Spec ref | Severity | Status |
+|---|-------|------------|----------|--------|
+| UI-01 | Layout matches UX Spec (columns, sections, order) | Screen Spec → Layout | 🟠 P1 | ☐ |
+| UI-02 | All sections present (no missing panels/cards) | Screen Spec → Sections | 🟠 P1 | ☐ |
+| UI-03 | Primary CTA visible and correctly styled | Screen Spec → Actions | 🔴 P0 | ☐ |
+| UI-04 | Typography hierarchy matches (h1 > h2 > body) | UI Inventory → Tokens | 🟡 P2 | ☐ |
+| UI-05 | Colors match design tokens | Design Rules → DR-xx | 🟠 P1 | ☐ |
+
+### 2.2 UI States
+
+| # | Check | Against | Severity | Status |
+|---|-------|---------|----------|--------|
+| UI-06 | **Loading** state present (skeleton or spinner per UX Spec) | Screen Spec → States | 🟠 P1 | ☐ |
+| UI-07 | **Empty** state present (illustration + text + CTA) | Screen Spec → States | 🟠 P1 | ☐ |
+| UI-08 | **Error** state present (message + retry/action) | Screen Spec → States | 🔴 P0 | ☐ |
+| UI-09 | **Success** feedback (toast/message after action) | Screen Spec → Notifications | 🟠 P1 | ☐ |
+| UI-10 | **Disabled** state clear (visual + non-clickable) | Screen Spec → States | 🟡 P2 | ☐ |
+| UI-11 | **Saving/In-flight** state (button spinner, disabled) | Screen Spec → Actions | 🟠 P1 | ☐ |
+
+### 2.3 Forms
+
+| # | Check | Against | Severity | Status |
+|---|-------|---------|----------|--------|
+| UI-12 | All form fields have visible labels | A11y Baseline A-10 | 🔴 P0 | ☐ |
+| UI-13 | Required fields marked (asterisk or text) | A11y Baseline A-11 | 🟠 P1 | ☐ |
+| UI-14 | Error messages visible and descriptive | Screen Spec → Validation | 🟠 P1 | ☐ |
+| UI-15 | Submit button feedback (loading/disabled during save) | Screen Spec → Actions | 🟠 P1 | ☐ |
+
+### 2.4 Quick A11y
+
+| # | Check | Against | Severity | Status |
+|---|-------|---------|----------|--------|
+| UI-16 | Can Tab to all interactive elements | A11y Baseline A-01 | 🔴 P0 | ☐ |
+| UI-17 | Focus ring visible on focused elements | A11y Baseline A-05 | 🔴 P0 | ☐ |
+| UI-18 | Modal traps focus + Escape closes | A11y Baseline A-07 | 🟠 P1 | ☐ |
+| UI-19 | No obvious contrast issues (text readable) | A11y Baseline A-19 | 🟠 P1 | ☐ |
+| UI-20 | Content/buttons not cut off or overlapping | — | 🟠 P1 | ☐ |
+
+---
+
+## 3. UX Spec Compliance
+
+### Per-screen verification
+
+For each screen in UX Spec, verify implementation matches:
+
+```markdown
+### Screen: <Name>
+
+| UX Spec Element | Expected | Implemented? | Notes |
+|----------------|----------|:------------:|-------|
+| Layout: 2-column 60/40 | Config + Preview | ✅ | — |
+| Tab: General | Title, Subtitle, CTA fields | ✅ | — |
+| Tab: Design | ColorPicker × 4, FontSelect | ⚠️ | Missing overlay picker |
+| Tab: Timer | Switch + NumberInputs | ✅ | — |
+| State: Loading | Skeleton | ❌ | Shows blank page |
+| State: Error (save) | Toast + inline errors | ⚠️ | Toast only, no inline |
+| Notification: Save success | Toast, 3s auto-dismiss | ✅ | — |
+```
+
+---
+
+## 4. Quick A11y Scan
+
+### 60-second keyboard test
+
+| Step | Action | Expected | Status |
+|------|--------|----------|:------:|
+| 1 | Press Tab from page top | Focus on first interactive element | ☐ |
+| 2 | Tab through all controls | Each gets visible focus ring | ☐ |
+| 3 | Enter on buttons | Action fires | ☐ |
+| 4 | Open modal/dropdown | Focus moves inside | ☐ |
+| 5 | Escape on modal | Modal closes, focus returns | ☐ |
+
+### Quick visual checks
+
+| Check | How | Expected |
+|-------|-----|---------|
+| Contrast | Squint test — can you read all text? | All text readable |
+| Hierarchy | Scan page — is structure clear? | Clear h1 > h2 > body |
+| CTA | Is the primary action obvious? | One clear primary button |
+| Errors | Trigger an error — is it clear? | Visible, descriptive, near the field |
+
+---
+
+## 5. Output Template
+
+```markdown
+# UI & A11y Smoke Review
+
+**Date:** YYYY-MM-DD
+**Reviewer:** UX/UI Designer Agent
+**Screen(s):** <list>
+**UX Spec:** <reference>
+
+## Checklist Results
+| Section | Pass | Fail | Total |
+|---------|:----:|:----:|:-----:|
+| Visual & Layout (UI-01..05) | 4 | 1 | 5 |
+| UI States (UI-06..11) | 4 | 2 | 6 |
+| Forms (UI-12..15) | 3 | 1 | 4 |
+| Quick A11y (UI-16..20) | 4 | 1 | 5 |
+| **Total** | **15** | **5** | **20** |
+
+## UX Spec Compliance
+| Screen | Elements checked | Match | Mismatch |
+|--------|:---------------:|:-----:|:--------:|
+| Settings | 7 | 5 | 2 |
+| Items | 5 | 5 | 0 |
+
+## Findings
+| # | Severity | Check | Screen | Finding | Fix |
+|---|----------|-------|--------|---------|-----|
+| 1 | 🔴 P0 | UI-08 | Settings | No error state for failed save | Add error toast + inline errors |
+| 2 | 🟠 P1 | UI-06 | Settings | Blank page instead of skeleton | Add skeleton loader |
+| 3 | 🟠 P1 | UI-05 | Design tab | Missing overlay color picker | Add 4th ColorPicker |
+| 4 | 🟡 P2 | UI-04 | Settings | Section titles not bold enough | Increase font-weight |
+
+## Keyboard Test
+| Step | Status |
+|------|:------:|
+| Tab navigation | ✅ |
+| Focus visible | ✅ |
+| Enter activates | ✅ |
+| Modal focus trap | ⚠️ Focus escapes |
+| Escape closes | ✅ |
+
+## Verdict
+- ✅ **READY FOR QA** — no P0, minor issues tracked
+- ⚠️ **FIX FIRST** — P0/P1 issues must be fixed before QA
+- ❌ **NOT READY** — critical UX/a11y issues block QA
+
+## Next
+- If READY → pass to $qa_ui_a11y_smoke for formal testing
+- If FIX FIRST → create DEV-xx tasks, re-review after fix
+```
+
+---
+
+## See also
+- `$qa_ui_a11y_smoke` — formal QA a11y testing (25 WCAG checks)
+- `$ux_spec` — UX Spec (source of truth)
+- `$a11y_baseline` — a11y requirements
+- `$design_parity_review` — full design comparison

package/locales/en/.agents/skills/ui_a11y_smoke_review/agents/claude.json

@@ -0,0 +1,20 @@
+{
+  "name": "ui_a11y_smoke_review",
+  "display_name": "UI & Accessibility Smoke Review",
+  "description": "Run a quick UI and accessibility smoke review - loading, empty and error states, focus, keyboard support, aria or labels, and UX Spec compliance.",
+  "default_prompt": "Use $ui_a11y_smoke_review when the task matches the \"UI & Accessibility Smoke Review\" skill.",
+  "triggers": [
+    "ui_a11y_smoke_review",
+    "ui a11y smoke review",
+    "UI & Accessibility Smoke Review",
+    "Run a quick UI and accessibility smoke review - loading, empty and error states, focus, keyboard support, aria or labels, and UX Spec compliance"
+  ],
+  "capabilities": [
+    "ui",
+    "a11y",
+    "smoke",
+    "review"
+  ],
+  "tools": [],
+  "implicit_invocation": true
+}

package/locales/en/.agents/skills/ui_a11y_smoke_review/agents/copilot.json

@@ -0,0 +1,20 @@
+{
+  "name": "ui_a11y_smoke_review",
+  "display_name": "UI & Accessibility Smoke Review",
+  "description": "Run a quick UI and accessibility smoke review - loading, empty and error states, focus, keyboard support, aria or labels, and UX Spec compliance.",
+  "default_prompt": "Use $ui_a11y_smoke_review when the task matches the \"UI & Accessibility Smoke Review\" skill.",
+  "triggers": [
+    "ui_a11y_smoke_review",
+    "ui a11y smoke review",
+    "UI & Accessibility Smoke Review",
+    "Run a quick UI and accessibility smoke review - loading, empty and error states, focus, keyboard support, aria or labels, and UX Spec compliance"
+  ],
+  "capabilities": [
+    "ui",
+    "a11y",
+    "smoke",
+    "review"
+  ],
+  "tools": [],
+  "implicit_invocation": true
+}

package/locales/en/.agents/skills/ui_a11y_smoke_review/agents/gemini.json

@@ -0,0 +1,20 @@
+{
+  "name": "ui_a11y_smoke_review",
+  "display_name": "UI & Accessibility Smoke Review",
+  "description": "Run a quick UI and accessibility smoke review - loading, empty and error states, focus, keyboard support, aria or labels, and UX Spec compliance.",
+  "default_prompt": "Use $ui_a11y_smoke_review when the task matches the \"UI & Accessibility Smoke Review\" skill.",
+  "triggers": [
+    "ui_a11y_smoke_review",
+    "ui a11y smoke review",
+    "UI & Accessibility Smoke Review",
+    "Run a quick UI and accessibility smoke review - loading, empty and error states, focus, keyboard support, aria or labels, and UX Spec compliance"
+  ],
+  "capabilities": [
+    "ui",
+    "a11y",
+    "smoke",
+    "review"
+  ],
+  "tools": [],
+  "implicit_invocation": true
+}

package/locales/en/.agents/skills/ui_a11y_smoke_review/agents/openai.yaml

@@ -0,0 +1,8 @@
+interface:
+  display_name: "UI & Accessibility Smoke Review"
+  short_description: "Run a quick UI and accessibility smoke review - loading, empty and error states, focus, keyboar…"
+  default_prompt: "Use $ui_a11y_smoke_review when the task matches the \"UI & Accessibility Smoke Review\" skill."
+dependencies:
+  tools: []
+policy:
+  allow_implicit_invocation: true