@violetflux/kerros 0.1.3 → 0.1.5

package/README.de.md

@@ -21,14 +21,12 @@ Kerros lässt React-State dort, wo er natürlich hingehört: in Hooks und unter
 - Stores lassen sich über einseitige Abhängigkeiten komponieren
 - Unterstützt React 17, 18 und 19
 
-## Installation
+> [!TIP]
+> **Mit Codex installieren**: Füge diesen Satz in Codex ein, um Abhängigkeit und Projekt-Skill gemeinsam zu installieren.
 
-| Paketmanager | Befehl |
-| --- | --- |
-| npm | `npm install @violetflux/kerros` |
-| pnpm | `pnpm add @violetflux/kerros` |
-| Yarn | `yarn add @violetflux/kerros` |
-| Bun | `bun add @violetflux/kerros` |
+```text
+Installiere @violetflux/kerros mit dem Paketmanager dieses Projekts und führe danach npx skills add violetflux/kerros --skill kerros --agent codex -y aus.
+```
 
 ## Store erstellen
 
@@ -62,6 +60,15 @@ function App() {
 
 Der Selektor darf inline stehen. Änderungen an nicht ausgewählten Feldern rendern `Counter` nicht neu.
 
+## Installation
+
+| Paketmanager | Befehl |
+| --- | --- |
+| npm | `npm install @violetflux/kerros` |
+| pnpm | `pnpm add @violetflux/kerros` |
+| Yarn | `yarn add @violetflux/kerros` |
+| Bun | `bun add @violetflux/kerros` |
+
 ## Funktionsweise
 
 Der Provider führt den Store Hook aus und gibt über Context nur einen stabilen Abonnement-Container weiter. Bestätigte Snapshots werden mit `subscribe/getSnapshot` veröffentlicht. Eine Komponente rendert nur neu, wenn sich ihre Auswahl ändert.

package/README.es.md

@@ -21,14 +21,12 @@ Kerros mantiene el estado de React donde pertenece de forma natural: dentro de H
 - Los Stores se componen mediante dependencias unidireccionales
 - Compatible con React 17, 18 y 19
 
-## Instalación
+> [!TIP]
+> **Instalar con Codex**: pega esta frase en Codex para instalar la dependencia y el Skill del proyecto a la vez.
 
-| Gestor | Comando |
-| --- | --- |
-| npm | `npm install @violetflux/kerros` |
-| pnpm | `pnpm add @violetflux/kerros` |
-| Yarn | `yarn add @violetflux/kerros` |
-| Bun | `bun add @violetflux/kerros` |
+```text
+Instala @violetflux/kerros con el gestor de paquetes del proyecto y después ejecuta npx skills add violetflux/kerros --skill kerros --agent codex -y.
+```
 
 ## Crear un Store
 
@@ -62,6 +60,15 @@ function App() {
 
 El selector puede escribirse en línea. Cambiar un campo no seleccionado no vuelve a renderizar `Counter`.
 
+## Instalación
+
+| Gestor | Comando |
+| --- | --- |
+| npm | `npm install @violetflux/kerros` |
+| pnpm | `pnpm add @violetflux/kerros` |
+| Yarn | `yarn add @violetflux/kerros` |
+| Bun | `bun add @violetflux/kerros` |
+
 ## Cómo funciona
 
 El Provider ejecuta el Hook del Store y Context solo transporta un contenedor de suscripción estable. Los snapshots confirmados se publican mediante `subscribe/getSnapshot`. Cada componente se renderiza de nuevo únicamente cuando cambia su selección.

package/README.fr.md

@@ -21,14 +21,12 @@ Kerros conserve l'état React là où il se trouve naturellement : dans les Hook
 - Les Stores se composent grâce à des dépendances unidirectionnelles
 - Compatible avec React 17, 18 et 19
 
-## Installation
+> [!TIP]
+> **Installer avec Codex** : collez cette phrase dans Codex pour installer à la fois la dépendance et le Skill du projet.
 
-| Gestionnaire | Commande |
-| --- | --- |
-| npm | `npm install @violetflux/kerros` |
-| pnpm | `pnpm add @violetflux/kerros` |
-| Yarn | `yarn add @violetflux/kerros` |
-| Bun | `bun add @violetflux/kerros` |
+```text
+Installe @violetflux/kerros avec le gestionnaire de paquets du projet, puis exécute npx skills add violetflux/kerros --skill kerros --agent codex -y.
+```
 
 ## Créer un Store
 
@@ -62,6 +60,15 @@ function App() {
 
 Le sélecteur peut rester en ligne. La modification d'un champ non sélectionné ne provoque pas un nouveau rendu de `Counter`.
 
+## Installation
+
+| Gestionnaire | Commande |
+| --- | --- |
+| npm | `npm install @violetflux/kerros` |
+| pnpm | `pnpm add @violetflux/kerros` |
+| Yarn | `yarn add @violetflux/kerros` |
+| Bun | `bun add @violetflux/kerros` |
+
 ## Fonctionnement
 
 Le Provider exécute le Hook du Store et Context ne transporte qu'un conteneur d'abonnement stable. Les snapshots validés sont publiés via `subscribe/getSnapshot`. Un composant n'est rendu à nouveau que lorsque sa sélection change.

package/README.ja.md

@@ -21,14 +21,12 @@ Kerros は React の状態を Hook の中、Provider の下という自然な場
 - 一方向の依存関係で Store を合成可能
 - React 17、18、19 をサポート
 
-## インストール
+> [!TIP]
+> **Codex でインストール**：次の一文を Codex に貼り付けると、依存関係とプロジェクト Skill をまとめてインストールできます。
 
-| パッケージマネージャー | コマンド |
-| --- | --- |
-| npm | `npm install @violetflux/kerros` |
-| pnpm | `pnpm add @violetflux/kerros` |
-| Yarn | `yarn add @violetflux/kerros` |
-| Bun | `bun add @violetflux/kerros` |
+```text
+このプロジェクトのパッケージマネージャーで @violetflux/kerros をインストールし、npx skills add violetflux/kerros --skill kerros --agent codex -y を実行してください。
+```
 
 ## Store を作成する
 
@@ -63,6 +61,15 @@ function App() {
 
 selector はインラインで記述できます。選択していないフィールドの変更では `Counter` は再レンダーされません。
 
+## インストール
+
+| パッケージマネージャー | コマンド |
+| --- | --- |
+| npm | `npm install @violetflux/kerros` |
+| pnpm | `pnpm add @violetflux/kerros` |
+| Yarn | `yarn add @violetflux/kerros` |
+| Bun | `bun add @violetflux/kerros` |
+
 ## 仕組み
 
 Provider は Store Hook を実行し、Context には安定した購読コンテナだけを渡します。コミット済みスナップショットは `subscribe/getSnapshot` で公開され、各コンポーネントは選択結果が変わったときだけ再レンダーされます。

package/README.ko.md

@@ -21,14 +21,12 @@ Kerros는 React 상태를 Hook 안과 Provider 아래라는 자연스러운 위
 - 단방향 의존성을 통한 Store 조합
 - React 17, 18, 19 지원
 
-## 설치
+> [!TIP]
+> **Codex로 설치**: 아래 문장을 Codex에 붙여넣으면 의존성과 프로젝트 Skill을 함께 설치합니다.
 
-| 패키지 매니저 | 명령 |
-| --- | --- |
-| npm | `npm install @violetflux/kerros` |
-| pnpm | `pnpm add @violetflux/kerros` |
-| Yarn | `yarn add @violetflux/kerros` |
-| Bun | `bun add @violetflux/kerros` |
+```text
+현재 프로젝트의 패키지 매니저로 @violetflux/kerros를 설치한 다음 npx skills add violetflux/kerros --skill kerros --agent codex -y를 실행하세요.
+```
 
 ## Store 만들기
 
@@ -63,6 +61,15 @@ function App() {
 
 selector는 인라인으로 작성할 수 있습니다. 선택하지 않은 필드가 바뀌어도 `Counter`는 다시 렌더링되지 않습니다.
 
+## 설치
+
+| 패키지 매니저 | 명령 |
+| --- | --- |
+| npm | `npm install @violetflux/kerros` |
+| pnpm | `pnpm add @violetflux/kerros` |
+| Yarn | `yarn add @violetflux/kerros` |
+| Bun | `bun add @violetflux/kerros` |
+
 ## 작동 방식
 
 Provider는 Store Hook을 실행하고 Context에는 안정적인 구독 컨테이너만 전달합니다. 커밋된 스냅샷은 `subscribe/getSnapshot`으로 게시되며 컴포넌트는 선택 결과가 바뀔 때만 다시 렌더링됩니다.

package/README.md

@@ -18,6 +18,7 @@
   <a href="https://www.npmjs.com/package/@violetflux/kerros"><img src="https://img.shields.io/npm/v/@violetflux/kerros?color=7c3aed" alt="npm version" /></a>
   <a href="https://github.com/violetflux/kerros/actions/workflows/ci.yml"><img src="https://github.com/violetflux/kerros/actions/workflows/ci.yml/badge.svg" alt="CI" /></a>
   <a href="https://bundlephobia.com/package/@violetflux/kerros"><img src="https://img.shields.io/bundlephobia/minzip/@violetflux/kerros?label=gzip&color=2563eb" alt="minified gzip size" /></a>
+  <a href="https://skills.sh/violetflux/kerros"><img src="https://skills.sh/b/violetflux/kerros" alt="Install Kerros Skill" /></a>
   <a href="https://github.com/violetflux/kerros/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/@violetflux/kerros" alt="MIT license" /></a>
 </p>
 
@@ -25,36 +26,12 @@ Kerros is a lightweight way to share state between React components.
 
 Write a Store the same way you write a custom Hook. When local state needs to be shared, pass it to `createStore`, mount its Provider, and let each component select what it needs.
 
-## Install
-
-| Package manager | Command |
-| --- | --- |
-| npm | `npm install @violetflux/kerros` |
-| pnpm | `pnpm add @violetflux/kerros` |
-| Yarn | `yarn add @violetflux/kerros` |
-| Bun | `bun add @violetflux/kerros` |
+> [!TIP]
+> **Install with Codex** — copy and paste this sentence into Codex to install both the dependency and the project Skill:
 
-React 17, React 18, and React 19 are supported.
-
-## Why Kerros?
-
-- **Almost nothing new to learn** — reuse the React knowledge you already have; if you can write a custom Hook, you can write a Store
-- **Designed for flexible refactoring** — Stores and components use the same Hook API, so local state can become shared state with very little work
-- **Local and application-wide state** — Provider placement determines the Store scope, balancing flexibility with simplicity
-- **Avoid Context-wide rerenders** — Context carries a stable container and components rerender only when their selector result changes
-- **TypeScript support** — Store and selector types are inferred without duplicate declarations
-
-## From state management to state sharing
-
-Libraries such as Redux, Zustand, and Recoil can all share data, but their central job is still to organize state, update it, and define how data flows. “State management” is the right name for them.
-
-Kerros focuses on a smaller and more direct problem. It does not invent a new data model or prescribe how async logic should work. It answers one question: **how can a piece of Hook state be shared between React components?**
-
-Passing `value` and `onChange` through layer after layer damages component boundaries. Moving everything into one global Store does not automatically make an application scalable or maintainable either.
-
-Sharing frequently changing state through React Context directly also causes repeated work: every Context value change rerenders all consumers. Kerros keeps Provider scoping and multiple instances, but Context carries only a stable container. Components subscribe through selectors and rerender only when their selected result changes.
-
-Kerros stays simple, lightweight, and reliable. Write local state as an ordinary Hook, share it only when necessary, use a Provider to set its scope, and use selectors to choose what each component observes.
+```text
+Install @violetflux/kerros with this project's package manager, then run npx skills add violetflux/kerros --skill kerros --agent codex -y.
+```
 
 ## Quick start
 
@@ -131,6 +108,37 @@ function TaskList() {
 
 Kerros shallowly compares the selector object's top-level fields. When those selected fields stay equal, other Store updates do not rerender `TaskList`. The selector can stay inline and does not need `useCallback`.
 
+## Install
+
+| Package manager | Command |
+| --- | --- |
+| npm | `npm install @violetflux/kerros` |
+| pnpm | `pnpm add @violetflux/kerros` |
+| Yarn | `yarn add @violetflux/kerros` |
+| Bun | `bun add @violetflux/kerros` |
+
+React 17, React 18, and React 19 are supported.
+
+## Why Kerros?
+
+- **Almost nothing new to learn** — reuse the React knowledge you already have; if you can write a custom Hook, you can write a Store
+- **Designed for flexible refactoring** — Stores and components use the same Hook API, so local state can become shared state with very little work
+- **Local and application-wide state** — Provider placement determines the Store scope, balancing flexibility with simplicity
+- **Avoid Context-wide rerenders** — Context carries a stable container and components rerender only when their selector result changes
+- **TypeScript support** — Store and selector types are inferred without duplicate declarations
+
+## From state management to state sharing
+
+Libraries such as Redux, Zustand, and Recoil can all share data, but their central job is still to organize state, update it, and define how data flows. “State management” is the right name for them.
+
+Kerros focuses on a smaller and more direct problem. It does not invent a new data model or prescribe how async logic should work. It answers one question: **how can a piece of Hook state be shared between React components?**
+
+Passing `value` and `onChange` through layer after layer damages component boundaries. Moving everything into one global Store does not automatically make an application scalable or maintainable either.
+
+Sharing frequently changing state through React Context directly also causes repeated work: every Context value change rerenders all consumers. Kerros keeps Provider scoping and multiple instances, but Context carries only a stable container. Components subscribe through selectors and rerender only when their selected result changes.
+
+Kerros stays simple, lightweight, and reliable. Write local state as an ordinary Hook, share it only when necessary, use a Provider to set its scope, and use selectors to choose what each component observes.
+
 ## Multiple instances
 
 Each `TaskProvider` owns independent state:

package/README.zh-CN.md

@@ -18,36 +18,12 @@ Kerros 是一个在 React 组件间共享状态的轻量方案。
 
 你怎么写 custom Hook，就可以怎么写 Store。只有当局部状态需要被多个组件使用时，再交给 `createStore`，用 Provider 决定共享范围，用 selector 选择组件真正需要的数据。
 
-## 安装
-
-| 包管理器 | 命令 |
-| --- | --- |
-| npm | `npm install @violetflux/kerros` |
-| pnpm | `pnpm add @violetflux/kerros` |
-| Yarn | `yarn add @violetflux/kerros` |
-| Bun | `bun add @violetflux/kerros` |
+> [!TIP]
+> **使用 Codex 安装**：复制下面这句话并粘贴给 Codex，它会同时安装依赖和当前项目的 Skill：
 
-支持 React 17、React 18 和 React 19。
-
-## 为什么要用 Kerros？
-
-- **几乎没有学习成本**：直接复用已有的 React 知识，你怎么写 custom Hook，就可以怎么写 Store
-- **为灵活重构而设计**：Store 和组件使用同一套 Hook API，可以近乎零成本地把组件局部状态转换成组件间共享状态
-- **同时支持局部状态和全局状态**：Provider 决定 Store 的作用域，在灵活和简单之间取得平衡
-- **解决 Context 的重复渲染问题**：Context 只传递稳定容器，selector 选择结果不变的组件不会重渲染
-- **优秀的 TypeScript 支持**：Store 和 selector 类型自动推断，不需要重复声明
-
-## 从状态管理到状态共享
-
-Redux、Zustand、Recoil 这些状态管理库当然也能解决数据共享问题，但它们最核心的能力仍然是组织数据、操作数据和约束数据流，因此它们应该被称为“状态管理”工具。
-
-Kerros 想解决的问题更小，也更直接。它不发明新的数据结构，不规定异步和数据流应该怎么写，只聚焦一个痛点：**如何在多个 React 组件间共享一段 Hook 状态。**
-
-层层传递 `value`、`onChange` 会逐渐破坏组件边界；粗暴地把数据全部塞进一个全局 Store，也不会自动让应用获得更好的扩展性和可维护性。
-
-直接用 React Context 共享变化频繁的状态也会带来重复渲染：Context value 每次变化，所有消费者都会更新。Kerros 保留 Provider 的作用域和多实例能力，但 Context 只传递稳定容器；组件通过 selector 订阅数据，只有选择结果变化时才重渲染。
-
-Kerros 简单、轻量、可靠。先把状态写成普通 Hook，需要共享时再交给 `createStore`；Provider 决定状态共享到哪里，selector 决定每个组件订阅什么。
+```text
+使用当前项目的包管理器安装 @violetflux/kerros，然后运行 npx skills add violetflux/kerros --skill kerros --agent codex -y。
+```
 
 ## 快速上手
 
@@ -124,6 +100,37 @@ function TaskList() {
 
 Kerros 会浅比较 selector 返回对象的顶层字段。只要这些选中字段保持不变，Store 的其他更新就不会让 `TaskList` 重渲染。selector 可以直接写在调用位置，不需要 `useCallback`。
 
+## 安装
+
+| 包管理器 | 命令 |
+| --- | --- |
+| npm | `npm install @violetflux/kerros` |
+| pnpm | `pnpm add @violetflux/kerros` |
+| Yarn | `yarn add @violetflux/kerros` |
+| Bun | `bun add @violetflux/kerros` |
+
+支持 React 17、React 18 和 React 19。
+
+## 为什么要用 Kerros？
+
+- **几乎没有学习成本**：直接复用已有的 React 知识，你怎么写 custom Hook，就可以怎么写 Store
+- **为灵活重构而设计**：Store 和组件使用同一套 Hook API，可以近乎零成本地把组件局部状态转换成组件间共享状态
+- **同时支持局部状态和全局状态**：Provider 决定 Store 的作用域，在灵活和简单之间取得平衡
+- **解决 Context 的重复渲染问题**：Context 只传递稳定容器，selector 选择结果不变的组件不会重渲染
+- **优秀的 TypeScript 支持**：Store 和 selector 类型自动推断，不需要重复声明
+
+## 从状态管理到状态共享
+
+Redux、Zustand、Recoil 这些状态管理库当然也能解决数据共享问题，但它们最核心的能力仍然是组织数据、操作数据和约束数据流，因此它们应该被称为“状态管理”工具。
+
+Kerros 想解决的问题更小，也更直接。它不发明新的数据结构，不规定异步和数据流应该怎么写，只聚焦一个痛点：**如何在多个 React 组件间共享一段 Hook 状态。**
+
+层层传递 `value`、`onChange` 会逐渐破坏组件边界；粗暴地把数据全部塞进一个全局 Store，也不会自动让应用获得更好的扩展性和可维护性。
+
+直接用 React Context 共享变化频繁的状态也会带来重复渲染：Context value 每次变化，所有消费者都会更新。Kerros 保留 Provider 的作用域和多实例能力，但 Context 只传递稳定容器；组件通过 selector 订阅数据，只有选择结果变化时才重渲染。
+
+Kerros 简单、轻量、可靠。先把状态写成普通 Hook，需要共享时再交给 `createStore`；Provider 决定状态共享到哪里，selector 决定每个组件订阅什么。
+
 ## 多个实例
 
 每个 `TaskProvider` 都拥有独立状态：

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@violetflux/kerros",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Hook-native state sharing for React with focused selector subscriptions.",
   "keywords": [
     "react",
@@ -10,7 +10,9 @@
     "store",
     "selector",
     "external-store",
-    "use-sync-external-store"
+    "use-sync-external-store",
+    "agent-skills",
+    "codex"
   ],
   "homepage": "https://violetflux.github.io/kerros/",
   "bugs": {
@@ -25,7 +27,8 @@
   "type": "module",
   "sideEffects": false,
   "files": [
-    "dist"
+    "dist",
+    "skills"
   ],
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",

package/skills/kerros/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: kerros
+description: Implement, refactor, review, or test shared React state with @violetflux/kerros. Use for createStore, Provider scoping, selector subscriptions, cross-Store composition, migrating from Hox or frequently changing React Context, preventing Context-wide rerenders, and React 17–19 compatibility.
+---
+
+# Kerros
+
+Build shared state from ordinary React Hooks. Keep Provider scope and multiple instances while selectors prevent unrelated consumers from rerendering.
+
+## Workflow
+
+1. Inspect the project package manager, React version, existing state owner, Provider tree, and naming conventions.
+2. Keep state local when only one component needs it. Create a Kerros Store only when several components need the same Hook state.
+3. Group state by domain and identify one authoritative owner for every mutable value.
+4. Create the Store, mount its Provider at the narrowest shared ancestor, and migrate consumers to focused selectors.
+5. Order composed Providers from dependency to dependent and reject circular Store dependencies.
+6. Run the project's typecheck, tests, lint, and the narrowest useful render test.
+
+## Install
+
+Use the package manager already present in the project:
+
+```sh
+npm install @violetflux/kerros
+pnpm add @violetflux/kerros
+yarn add @violetflux/kerros
+bun add @violetflux/kerros
+```
+
+Kerros supports React 17, 18, and 19. Do not change package managers or create an additional lockfile.
+
+## Core pattern
+
+Write the Store as an ordinary Hook directly inside `createStore`. Name the public pair after the domain; do not repeat `Store` unless the codebase already requires it.
+
+```tsx
+import { createStore } from '@violetflux/kerros'
+import { useState } from 'react'
+
+export const [useCounter, CounterProvider] = createStore(() => {
+  const [count, setCount] = useState(0)
+  const increment = () => setCount(v => v + 1)
+
+  return { count, increment }
+})
+```
+
+Mount the Provider at the narrowest ancestor shared by all consumers:
+
+```tsx
+function App() {
+  return (
+    <CounterProvider>
+      <Counter />
+    </CounterProvider>
+  )
+}
+```
+
+Select an object containing only the fields the component reads. Keep the selector inline and use `s` as its parameter:
+
+```tsx
+function Counter() {
+  const { count, increment } = useCounter(s => ({
+    count: s.count,
+    increment: s.increment,
+  }))
+
+  return <button onClick={increment}>{count}</button>
+}
+```
+
+Kerros shallowly compares the selected object's top-level fields with `Object.is`. An update to an unselected field must not rerender this component.
+
+## Provider props
+
+Accept initialization or scope-specific inputs as Store Hook props. Pass them to the generated Provider instead of reading mutable module globals.
+
+```tsx
+const [useGreeting, GreetingProvider] = createStore((props: { initialName: string }) => {
+  const [name, setName] = useState(props.initialName)
+  return { name, setName }
+})
+
+<GreetingProvider initialName="Ada">
+  <Profile />
+</GreetingProvider>
+```
+
+## Compose Stores
+
+An inner Store may call an outer Store Hook. Mount the dependency first and keep the graph one-way.
+
+```tsx
+const [useSession, SessionProvider] = createStore(() => {
+  const [userId, setUserId] = useState<string>()
+  return { userId, setUserId }
+})
+
+const [usePermissions, PermissionsProvider] = createStore(() => {
+  const { userId } = useSession(s => ({ userId: s.userId }))
+  return { canEdit: Boolean(userId) }
+})
+
+function Providers({ children }: PropsWithChildren) {
+  return (
+    <SessionProvider>
+      <PermissionsProvider>{children}</PermissionsProvider>
+    </SessionProvider>
+  )
+}
+```
+
+## Guardrails
+
+- Require every Store read to use an object selector. Do not use array selectors.
+- Select concrete fields and actions. Do not expose or select a changing aggregate Store snapshot.
+- Do not wrap inline selectors with `useCallback`; Kerros handles selector identity.
+- Keep public actions as ordinary functions. In React 19, use `useEffectEvent` only for events called from Effects, never as a public Store action.
+- Do not mirror the same mutable state across Stores. Read it from its authoritative Store or move ownership.
+- Do not create circular Store dependencies. Split ownership or invert the Provider order.
+- Do not call a Store Hook outside its matching Provider; Kerros intentionally throws a clear error.
+- Do not replace scoped Providers with a hidden module singleton. Put an application-wide Provider at the root only when the state is truly application-wide.
+- Preserve SDK caches, subscriptions, and streams under a single owning Store when duplicating the Hook would duplicate external work.
+- Respect the project's React version. Avoid React 19-only APIs when the consuming project still supports React 17 or 18.
+
+## Migrate existing state
+
+- From React Context: keep the Provider boundary, move the changing value into `createStore`, and replace broad `useContext` reads with focused selectors.
+- From Hox: replace the factory with `createStore`, add the explicit Provider, remove compatibility exports, and migrate every consumer to an object selector.
+- From a global Store: split by domain only when ownership and dependencies stay clear; do not split merely by field count.
+
+## Verify
+
+- Confirm all consumers are below the correct Provider and multiple Provider instances stay isolated.
+- Test Provider props, Strict Mode, subscription cleanup, and the outside-Provider error when changing Store infrastructure.
+- Add a render-count test showing that changing an unselected field does not rerender the consumer.
+- Search for broad Store selections, array selectors, duplicate subscriptions, and dependency cycles.
+- Run the consuming project's existing validation commands without introducing a new package manager.

package/skills/kerros/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Kerros"
+  short_description: "Build selector-based shared React state with Kerros"
+  default_prompt: "Use $kerros to implement shared React state with createStore, Providers, and focused selectors."