@nurix/etna 0.18.10 → 0.18.12

package/data/harnesses/mobile/rules/general.md

@@ -0,0 +1,86 @@
+# General Standards
+
+## Runtime Versions
+
+- **Node.js:** 22 LTS (latest)
+- **Package manager:** detect from lockfile (`pnpm-lock.yaml` → pnpm, `yarn.lock` → yarn, `package-lock.json` → npm). Don't hardcode one.
+- **PostgreSQL:** 17 · **Redis:** 7.x (latest)
+
+## Recommended Packages
+
+No alternatives. Just use these.
+
+| Package                  | Version   | Use                    | Don't use                  |
+| ------------------------ | --------- | ---------------------- | -------------------------- |
+| react                    | ^19.2.3   | UI components          | -                          |
+| vite                     | ^8.0.0    | Build tool, dev server | webpack, CRA               |
+| tailwindcss              | ^4.1.18   | Styling                | styled-components          |
+| @vitejs/plugin-react-swc | ^4.2.2    | JSX compilation        | @vitejs/plugin-react       |
+| react-router-dom         | ^7.11.0   | Routing                | -                          |
+| @reduxjs/toolkit         | ^2.11.2   | State management       | zustand, jotai             |
+| react-redux              | ^9.2.0    | Redux React bindings   | -                          |
+| axios                    | ^1.13.2   | HTTP requests          | fetch                      |
+| date-fns                 | ^4.1.0    | Date formatting        | moment, dayjs              |
+| @dnd-kit/core            | ^6.3.1    | Drag and drop          | react-beautiful-dnd        |
+| motion                   | ^12.23.26 | Animations             | react-spring               |
+| sonner                   | ^2.0.7    | Toast notifications    | react-toastify             |
+| react-window             | ^2.2.3    | List virtualization    | react-virtualized          |
+| nanoid                   | ^5.1.6    | ID generation          | uuid                       |
+| express                  | ^5.2.1    | HTTP server            | fastify, koa               |
+| drizzle-orm              | latest    | Database ORM           | prisma, sequelize, typeorm |
+| drizzle-kit              | latest    | Schema tooling         | -                          |
+| zod                      | ^4.2.1    | Schema validation      | yup, joi                   |
+| jose                     | ^6.1.3    | JWT handling           | jsonwebtoken               |
+| microdiff                | ^1.5.0    | JSON object diffing    | deep-diff, just-diff       |
+| react18-json-view        | ^0.2.9    | JSON tree view         | react-json-view            |
+| @tiptap/react            | ^3.11.1   | Rich text editor       | slate, quill, draft-js     |
+| shiki                    | ^3.22.0   | Syntax highlighting    | prism, highlight.js        |
+| lucide-react             | ^0.562.0  | Icons                  | react-icons, heroicons     |
+| @pdfme/generator         | ^5.5.8    | PDF generation         | jspdf, pdfkit              |
+| cmdk                     | ^1.1.1    | Command palette        | kbar, ninja-keys           |
+| @monaco-editor/react     | ^4.7.0    | Code editor            | codemirror, ace            |
+| localforage              | ^1.10.0   | Client-side storage    | idb, dexie                 |
+| react-markdown           | ^10.1.0   | Markdown rendering     | marked, markdown-it        |
+| fast-deep-equal          | ^3.1.3    | Deep equality checks   | lodash.isEqual             |
+| @ngneat/falso            | latest    | Fake data generation   | @faker-js/faker, chance    |
+| pino                     | ^10.1.0   | Logging                | winston                    |
+
+## Frontend
+
+Tailwind v4 + shadcn-based UI; conventions below.
+
+- **Build every UI through the `frontend-design` skill** — route the brief through it instead of hand-rolling layouts; it owns the archetype, personality tokens, and `@nurix/components` wiring.
+- **Light mode is the default** — design for the light theme as the default; dark mode is opt-in, never the default.
+- **@nurix/\* are restricted-scope npm packages** — installed from the npm registry, auto-authed by a read token in `~/.npmrc`. Just attempt the install; the token authenticates you automatically. Don't pre-empt or second-guess it. If the install actually fails, flag it to the user — never reach for alternatives, a substitute package, or `npm login`.
+- **@nurix/components** — the UI component library (restricted-scope npm package, pre-built); import by subpath, e.g. `@nurix/components/button`.
+- No components.json / shadcn CLI scaffold (.tsx, not .jsx) — consume the prebuilt library; never `npx shadcn add`.
+- Vite: `@tailwindcss/vite` + `@vitejs/plugin-react-swc`. Pin react / react-dom / react/jsx-runtime / react/jsx-dev-runtime to the app's single copy via `resolve.alias` (@nurix/\* ship nested react — keep one hook dispatcher).
+- Tailwind v4, CSS-only (no tailwind.config.js, no PostCSS): styling runs through the `@tailwindcss/vite` plugin.
+- CSS entry `globals.css`, imports in order — `@import "./personality.css"` (token source) → `@import "tailwindcss"` → the library's `styles.css` — then `@theme inline {…}` mapping vars to tokens.
+- Tokens: CSS vars in `:root, :root[data-theme="light"]` + the archetype selector `[data-style="…"]` (personality.css), consumed as semantic Tailwind tokens (bg-card, text-foreground). Honor the archetype's radius/theme decisions (e.g. re-assert `--radius-*` to 0 for a flat archetype; add `@custom-variant dark` only if the project opts into dark mode, and keep light as the default). The library bundles class-variance-authority, clsx, tailwind-merge.
+- Plus general styling rules (spacing in 2/4/6/8, object-cover, truncate, motion, color tokens — never hardcoded hex in components).
+
+## Express 5.x
+
+```javascript
+app.use(cors({ origin: process.env.FRONTEND_URL }));
+app.use(compression());
+app.use(express.json({ limit: '10mb' }));
+app.use(rateLimit({ windowMs: 15 * 60 * 1000, max: 100 }));
+```
+
+- Middleware order: body parsers → custom middleware → routes → error handlers (centralized, last). Auth via middleware. Use Express Router for modular routes.
+
+## API Response Format
+
+```json
+{
+  "status": 1,
+  "message": "Message sent successfully",
+  "data": { "delivered": [{ "user@example.com": 2 }] }
+}
+```
+
+Error: `{ "status": 0, "message": "Error description", "data": null }`
+
+HTTP codes: `200`, `201` (created), `400`, `401` (not authenticated), `403` (not authorized), `404`, `500`

package/data/harnesses/mobile/rules/nomenclature.md

@@ -0,0 +1,41 @@
+# Nomenclature Guidelines
+
+## Naming Guidelines
+
+- Use descriptive names that reveal intent, purpose, and usage
+- Names should explain why something exists and how it's used
+- Favor clarity over brevity
+- Maintain consistency within the codebase
+- Avoid abbreviations unless they're universally understood
+
+## Naming Styles
+
+- Variables : Use nouns or noun phrases. Examples: `userData`, `firstName`, `paymentStatus`, `configOptions`
+- Functions & Methods : Use verbs or verb phrases that describe the action. Examples: `calculateTotal`, `getUserInfo`, `validateInput`, `sendNotification`
+- Boolean Variables : Prefix with is**, has**, can**, or should**. Examples: `isValid`, `hasPermission`, `canEdit`, `shouldRefresh`
+- Arrays : Use plural nouns. Examples: `users`, `productList`, `errorMessages`, `activeConnections`
+- Classes & Components : Use singular nouns or noun phrases. Examples: `RequestHandler`, `UserProfile`, `PaymentProcessor`, `DataValidator`
+- Constants : Use uppercase with meaningful names. Examples: `DEFAULT_TIMEOUT`, `API_BASE_URL`, `MAX_RETRY_COUNT`, `COLOR_PRIMARY`
+- Event Handlers : Use Prefix with handle or on. Examples: `handleSubmit`, `onUserLogin`, `handleInputChange`, `onPageLoad`
+- Interfaces & Types : Use Consider prefixing with I for interfaces (if preferred). Examples: `IUserData`, `IConfigOptions`, `AuthResponse`, `RequestParams`
+- Promises & Async Functions : Use Consider using future tense or suffixes like Async. Examples: `fetchUserData`, `getUserProfileAsync`, `loadConfigAsync`, `processPayment`
+- File & Folder Structure : Use lowercase with descriptive names. Group by feature or function type. Example: `auth/login_service.js`
+
+## Casing Styles
+
+- camelCase : Used in Variables, function names, method names, property names. Examples: `userData`, `calculateTotal`, `firstName`, `isValidEmail`
+- PascalCase : Used in Class names, component names, type definitions. Examples: `UserProfile`, `DataService`, `AuthProvider`, `RequestHandler`
+- snake_case : Used in File names, folder names. Examples: `user_service`, `api_utils`, `auth_middleware`, `data_models`
+- UPPER_SNAKE_CASE : Used in Constants, environment variables. Examples: `MAX_RETRY_COUNT`, `API_KEY`, `DEFAULT_TIMEOUT`, `COLOR_PRIMARY`
+- kebab-case : Used in URLs, CSS class names, HTML IDs. Examples: `nav-container`, `user-profile`, `button-primary`, `form-wrapper`
+
+## Database
+
+Naming for D1 tables, columns, indexes, and their Drizzle mirrors. (For column **types** — PK shape, timestamp columns — see the Cloudflare D1 Schema rule, not here; this section governs names only.)
+
+- **Tables** : snake_case. Entity / hub tables use the plural noun for the thing they hold. Examples: `users`, `apps`, `devices`, `services`.
+- **Junction (M:N) tables** : name a many-to-many join `<entityA>_<entityB>_map` — **always**, even when the join carries its own columns (a `role`, a secret, a status). The `_map` suffix is the signal that a row is a relationship, not an entity; extra attributes on the join do **not** earn it a standalone noun. Use the **singular** stem of each side, owning/anchor entity first (mirror the existing tables — `app_*`). Examples: `app_user_map` (apps ⨯ users), `app_device_map` (apps ⨯ devices), `app_service_map` (apps ⨯ services).
+  - ❌ Don't invent a "nice" noun for a junction — no `members`, `installs`, `memberships`, `enrolments`. A reviewer should read the table name and know both sides and that it's a join.
+- **Columns** : snake_case. Foreign keys are `<entity>_id` (`user_id`, `app_id`, `device_id`, `service_id`). Booleans follow the boolean rule (`is_*`/`has_*`); timestamps are `created_at` / `updated_at`.
+- **Indexes** : `<table>_<col(s)>_idx`; unique indexes `<table>_<col(s)>_unique`. The composite unique on a junction reads `<table>_<colA>_<colB>_unique` — e.g. `app_user_map_app_user_unique`, `app_device_map_device_app_unique`.
+- **Drizzle mirror** : the exported table object is the camelCase of the snake_case table name (`app_user_map` → `appUserMap`); column TS properties are the camelCase of the column (`created_at` → `createdAt`, `service_key` → `serviceKey`). The snake_case string passed to `sqliteTable("…")` and every index name must match `seed/init.sql` exactly (the G1 schema-parity boundary).

package/data/harnesses/mobile/rules/react-native.md

@@ -0,0 +1,132 @@
+# React Native + Expo
+
+How mobile apps are built. Distilled from a hand-crafted reference app — the gold standard for *style*. This rule is **scale-aware**: a few-screen app uses the small-app form, a feature/auth-heavy app grows into the full form. Where a section offers both, the trigger to graduate is stated.
+
+## 1. Stack & packages
+
+- **Expo SDK** managed workflow, **config-as-code** (`app.config.ts`, never `app.json`), **expo-router** for navigation, **TypeScript strict**.
+- New Architecture **on** by default; turn it **off** only for a legacy native module that breaks under it — document *why* at the top of `app.config.ts`.
+- `react` / `react-dom` versions must match. Run `npx expo install <pkg>` (not a bare add) for any native/Expo module so the SDK-compatible version is picked.
+
+| Need | Use | Not |
+| --- | --- | --- |
+| HTTP | native `fetch` wrapped in a `request<T>()` util | axios |
+| Navigation | `expo-router` (file-based) | bare React Navigation at the root |
+| Storage (sensitive) | `expo-secure-store` | AsyncStorage |
+| Storage (prefs/cache) | `@react-native-async-storage/async-storage` | secure-store |
+| State (non-trivial) | `@reduxjs/toolkit` + `react-redux` | zustand, jotai |
+| Styling | `StyleSheet.create` + token object | nativewind, tamagui, styled |
+| Toasts | `react-native-toast-message` | custom |
+| Haptics | `expo-haptics` behind one dispatcher | scattered call sites |
+
+## 2. Structure & naming
+
+- **Path alias `@/*` → `./src/*`** (in `tsconfig.json`). Import via `@/...`, never deep-relative (`../../..`). Sibling/child relative imports are fine.
+- **Every file starts with a path + one-line purpose comment.** One-line comment above each function.
+- **No barrel/index re-export files.** Import the source directly: `import { ThemedButton } from "@/components/ThemedButton"`.
+- **Naming:** components & screens `PascalCase.tsx`; hooks `useXxx.ts`; services/utils/reducers/types `camelCase.ts`; route files follow expo-router (`index.tsx`, `[id].tsx`, `_layout.tsx`).
+
+**Directory layout** — `app/` is routes only; everything else under `src/`:
+
+```
+app/                      # expo-router routes (screens) ONLY — see §3
+src/
+  components/             # presentational primitives + shared UI (PascalCase)
+  hooks/                  # useXxx
+  services/               # api client, auth storage, background tasks, notifications
+  state/  | reducers/+store/   # see §4 (scale decides)
+  types/                 # shared TS contracts
+  utils/                 # pure helpers (haptics, deepLink, schemas, ...)
+  constants/             # Colors.ts, routes.ts, toast_config.tsx
+  navigation/            # custom navigators / BackButton (only if you outgrow Stack/Tabs)
+```
+
+> **Lean form:** for a handful of screens, group by domain instead of by type — e.g. `src/{data,player,state,ui}` — keeping `app/` routes-only. Graduate to the by-type layout above once you have >~3 cross-cutting concerns (auth + tabs + notifications + ...).
+
+## 3. Expo Router & navigation
+
+- **Routes live in `app/`** and contain screen logic; **presentational components live in `src/components/`**. A route file may hold its own data/business logic — strict container/presentational split is not required, but pure UI primitives stay pure.
+- `experiments.typedRoutes: true`. Navigate with `router.push()` / `router.replace()` (use `replace` for auth/redirect transitions); reserve `<Link>` for static in-content links. Read params with `useLocalSearchParams()`.
+- **Route groups** `(auth)` / `(tabs)` to partition without affecting the URL. `index.tsx` may be pure redirect logic, not a screen.
+- **Root `_layout.tsx` is the provider tree**, composed outside-in in this order (include only what the app needs):
+
+  ```
+  ErrorBoundary → Redux Provider → HydrationGate → GestureHandlerRootView
+    → SafeAreaProvider → StatusBar → <Stack/Tabs> → Toast
+  ```
+
+  A lean app collapses this to `StatusBar → Stack` plus a one-time `useEffect` bootstrap.
+- Header styling via `screenOptions` on the `Stack`; per-screen title via `<Stack.Screen options={{ title }}>`.
+- For a bottom-tab app needing a custom header/drawer, `createBottomTabNavigator` inside a `(tabs)/_layout.tsx` is acceptable over expo-router `Tabs` when you need fine layout control.
+
+## 4. State
+
+**Scale rule:**
+
+- **Trivial** (no auth, few screens) — **plain TS modules** under `src/state/`: a module owns one concern, exposes async get/set functions, persists to AsyncStorage with swallowed try/catch, and may cache in a module-level variable.
+- **Non-trivial** (auth, preloaded config, cross-screen data) — **Redux Toolkit**:
+  - Slices in `src/reducers/`, store in `src/store/`. Combine slices in one root reducer.
+  - **Persist with listener middleware** (debounced ~300ms), **not** `redux-persist`.
+  - **Dual storage:** sensitive state (tokens) → `expo-secure-store`; UI prefs → AsyncStorage.
+  - **Hydrate before first render:** async hydrate thunks dispatched by a `HydrationGate` that shows a spinner until rehydrated — prevents a flash of unauthenticated UI.
+  - Store absolute expiries (`accessExpiresAt`), computed at login from the `expiresIn` the server returns.
+
+## 5. Data fetching / networking
+
+- **Native `fetch`**, wrapped once: a `request<T>(method, endpoint, body?, opts?)` util in `src/services/api.ts`, and a `useRequest<T>()` hook returning `{ loading, response, error, makeRequest }`.
+- Base URL and auth token are read **at call time** (from Redux state or the settings module), not baked into a client instance. Inject `Authorization: Bearer <token>` only when `authorized: true`.
+- Per-call `onSuccess` / `onFail` callbacks; no global interceptor. Surface failures as toasts or inline error UI.
+- **Every fetched surface renders three states: loading, empty, error** (with a Retry affordance). Caching is in-memory at the data-module level for a lean app; Redux slices serve as the cache for the full app.
+- Types: a `RequestMethod` union and a generic `ApiResponse<T>`; endpoint-specific call wrappers live next to their screen (`app/<feature>/api.ts`).
+
+## 6. Styling & theming
+
+- `StyleSheet.create` for static styles; inline only for dynamic (theme) values. **No** utility-CSS or styled-components libs.
+- **Color tokens in one place** (`src/constants/Colors.ts`) — components reference tokens, never raw hex.
+- **Theming is a hook, not a Context provider.** `useTheme()` returns `{ colors, colorScheme, isDark }`, resolving **user preference → device `useColorScheme()` → light fallback**. The preference lives in state (e.g. `customize.theme`: `"light" | "dark" | "system"`), so theme survives restart and there's no provider to thread.
+
+  > **Lean form:** a flat single-mode token object is fine until dark mode is a requirement; adopt the light/dark `Colors` + `useTheme()` shape when it is.
+
+## 7. Native modules & permissions
+
+- **Wrap each `expo-*` module behind a typed helper** — never sprinkle raw calls. Canonical example: one `triggerHaptic(type)` dispatcher with named exports (`triggerSuccessHaptic`, `triggerTabChangeHaptic`, ...) over `expo-haptics`.
+- **Platform-specific code via filename suffixes** — `Foo.native.tsx` / `Foo.web.tsx` / `Foo.tsx` — preferred over imperative `Platform.select()`. Use `Platform.OS` checks for small inline branches only.
+- Declare Android/iOS permissions and usage strings in `app.config.ts`. Request at point-of-use with a clear pre-prompt where the platform allows.
+- Background work (location, audio) runs through a registered task (`expo-task-manager` / a playback service) so it survives the UI being unmounted — register it in the **app entry** before the router mounts.
+
+## 8. Reusable primitives
+
+- **`Themed{View,Text,Button}`** as the base layer: extend the native props and add `lightColor?` / `darkColor?`; `ThemedText` takes `type?: "default" | "title" | "subtitle" | "link"`; `ThemedButton` takes `variant?: "contained" | "outlined" | "text"`, `size?`, `fullWidth?`.
+- **`EdgeToEdgeScreen` / `EdgeToEdgeTabScreen` / `EdgeToEdgeTabBar`** own safe-area inset handling so screens never compute insets inline.
+- Loading/feedback primitives (`DotLoader`, `CircularProgress`, `PullToRefreshHint`) are shared, not re-implemented per screen.
+
+## 9. TypeScript
+
+- **`interface`** for external contracts (API shapes, component props); **`type`** for unions and aliases (`type RequestMethod = "get" | ...`).
+- Shared domain types in `src/types/`; component prop types extend native prop types (`TextProps & { ... }`).
+- **Never weaken `strict` or `noUncheckedIndexedAccess`.** A framework base (`expo/tsconfig.base`) may be extended but not relaxed. Generics for `request<T>` / `useRequest<T>`; no implicit `any` on external data. (See the `typescript` rule for the workspace-wide policy.)
+
+## 10. Config & environment
+
+- `app.config.ts` (TS) is the single source: scheme, deep-link intent filters, permissions, plugins, `userInterfaceStyle: "automatic"`, `experiments.typedRoutes: true`, splash/icon.
+- Client-readable env via **`EXPO_PUBLIC_*`** only, read through `expo-constants` or `process.env`. **Never commit `.env`**; ship `.env.example`. Secrets/keystore creds stay out of git.
+- Build profiles in `eas.json` (`development` / `preview` / `production`). Local config plugins (`./plugins/withXxx.js`) for native edits the SDK doesn't expose (e.g. Android Auto).
+
+## 11. Errors, loading & UX
+
+- **`ErrorBoundary` class component wraps the whole app.** On crash it logs, clears *session* state but **preserves user preferences**, and shows an apology + recover affordance.
+- **Toasts** via `react-native-toast-message` with a custom `toast_config.tsx` (success/error/warning variants, `topOffset` below the header). Fire inline: `Toast.show({ type, text1, text2 })`.
+- Gate first paint: hide the splash only after fonts load + state hydrates (`expo-splash-screen`).
+- **Lists:** `FlatList` typed with `ListRenderItemInfo<T>`, `ListEmptyComponent` for empty, `onEndReached` + pagination for infinite scroll, `refreshing`/`onRefresh` for pull-to-refresh.
+- Safe-area through the `EdgeToEdge*` wrappers (§8), not ad-hoc insets.
+
+## 12. Web target (`expo start --web`)
+
+- Web needs `react-dom`, `react-native-web`, `@expo/metro-runtime`. Add a `"web": "expo start --web"` script.
+- `react-native-track-player` runs on web only with its peer **`shaka-player`** installed; without it the bundle fails to resolve and the page is blank.
+- **Native-only features have no web equivalent** — background audio, lock-screen controls, Android Auto. Guard them behind `Platform.OS` so the web build renders, and treat web as a layout/navigation preview, not a playback/Auto test surface.
+
+## 13. Formatting
+
+- Prettier: `tabWidth: 4`, `singleQuote: false` (double quotes), `bracketSameLine: true`, `printWidth: 120`, trailing commas.
+- No commented-out code; comments explain *why*, not *what*.

package/data/harnesses/mobile/rules/typescript.md

@@ -0,0 +1,40 @@
+# TypeScript
+
+TypeScript conventions. Compiles under `strict: true` and `noUncheckedIndexedAccess: true`.
+
+## Type Safety
+
+- Never `any` to silence the checker. Unknown value → type `unknown`, then narrow (type guard / `zod` parse).
+- Never weaken strictness. No `// @ts-nocheck`; `// @ts-expect-error` only with a same-line reason.
+- Infer locals & return types; annotate at boundaries (exports, props, contracts).
+
+## Generics
+
+Shared libraries (`@nurix/components`, etc.) are generic on purpose — that's what types `cell(row)`, checks `slug` against `keyof TData`, and ties `data`/`columns` together. Keep the safety; never widen to `any` to dodge it. State the row type **once per file**, then let inference carry it:
+
+- **Bind a repeated factory once** (preferred): `const col = defineColumn<BriefRow>;` → `col({...})`. No `<T>` per call; `row` stays typed. Canonical: `modules/briefs/BriefsListPage.tsx`.
+- **Infer JSX type args from props:** `<Table data={rows} columns={columns} />`, not `<Table<BriefRow> …>`.
+- **Anchor with a collection annotation** when nothing else can: `const columns: ColumnDefinition<BriefRow>[] = [...]`.
+
+Don't repeat `fn<Type>(…)` / `<Comp<Type>>` at every call site — cosmetic only (same safety, same emitted JS).
+
+> Monorepo TS policy (`tsconfig.base.json` + thin per-package `extends`, source-first internal packages, `peerDependencies`, pnpm `catalog:`) lives in [`nustack.md`](nustack.md) §2 — it travels with package boundaries and publishing.
+
+## Consuming `@nurix/*` packages
+
+`@nurix/*` packages publish to npm with **`restricted`** access — installing needs read rights to the `nurix` org. (Publishing one is [`nustack.md`](nustack.md) §3.)
+
+- **Auth** — `npm login` once (the npm user must be a `nurix` member), **or** drop a read token in `.npmrc` (the only CI option; with it you don't need `npm login`):
+  ```ini
+  @nurix:registry=https://registry.npmjs.org/
+  //registry.npmjs.org/:_authToken=${NPM_READ_TOKEN}
+  ```
+  A `403` on install means auth failed — check `npm whoami` (local) or the `NPM_READ_TOKEN` secret (CI). The read token only needs `Read` on the `nurix` scope.
+- **Install** — `npm install @nurix/<name>` (or `pnpm add` / `yarn add`).
+- **Import by subpath, never the barrel** — bundlers tree-shake subpaths reliably; root-barrel imports less so. Available subpaths are the package's `exports` keys.
+  ```tsx
+  import { Button } from "@nurix/components/button";
+  import { useMobile } from "@nurix/components/hooks/use-mobile";
+  ```
+- **Styles** — packages that ship CSS need their stylesheet imported **once** at the app entry: `import "@nurix/components/styles.css";`. Unstyled components are almost always a missing styles import. Tailwind v4 doesn't scan `node_modules`, but the shipped stylesheet is precompiled — no `@source` directive needed unless you consume the source via a workspace link.
+- **CLIs** ship a `bin` — run directly: `npx @nurix/etna@latest` (or `npm install -g`).

package/data/harnesses/mobile/skills/boundary/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: boundary
+description: Boundary diagnostic for implementation plans. Given a plan file, reads the source files the plan touches, identifies the application boundaries they participate in — the cross-cutting contracts (db schema, wire envelope, auth, events, env/config, …) where editing one side silently breaks the other — and reports whether the planned changes would violate any of them, severity-ranked, with suggested plan amendments. Read-only; the report lands in chat. Can also run against a diff or named code area instead of a plan. Triggers on "boundary check", "check this plan", "what could break", "impact analysis", "/boundary".
+---
+
+# Boundary Diagnostic
+
+You diagnose whether a plan's changes would break an application boundary.
+
+A boundary is a contract between two pieces of code (or code and infra) that share an assumption with **no compile-time link** between them: the column a raw SQL string names, the JSON envelope a client unwraps, the event string a dispatcher parses, the env var a deploy script writes. Changing one side ships green and breaks the other silently. Your job is to find those edges in the plan's path _before_ execution.
+
+[`references/boundary-taxonomy.md`](references/boundary-taxonomy.md) is the catalog of boundary types (~170 across persistence, wire/API, frontend, auth/tenancy, async/messaging, config/build, runtime/infra), with per-type severities and safe-change checklists. Read it first — it tells you what to look for; the code tells you what exists.
+
+## Run
+
+**Input:** a plan path (given, or the newest in `docs/history/plans/`) — or a diff / named code area for non-plan work. Everything below is identical either way; a diff's hunks stand in for the plan's steps.
+
+1. **Build the touch list.** Parse the plan's Proposed Changes: files to be created or modified, entities/state added or changed, API changes, anything the author flags as a cross-module contract. Note missing subsections.
+
+2. **Identify the boundaries in the touched code.** Read each touched file (and its immediate imports). Against the taxonomy, list the contracts this code participates in — the schema it queries, the envelope it emits, the events it publishes or parses, the auth checks it sits behind, the env it reads.
+
+3. **Trace the other side.** A boundary has two sides; the danger lives on the one the plan _doesn't_ mention. For each contract, grep the shared name or shape across the repo — the column name in other SQL strings, the response field in client unwrappers, the event kind in subscribers, the route in fetch calls and scripts, the env key in deploy tooling. Record consumers as `file:line`.
+
+4. **Judge each intersection.** Does the planned change alter a shape a traced consumer depends on, break an invariant the code establishes (append-only vocabularies, idempotency keys, fail-closed checks, ordering guarantees), or add a new cross-module edge? Severity:
+   - **CRITICAL** — can corrupt persisted data, or open an auth/money path.
+   - **HIGH** — silent cross-module breakage that would ship green.
+   - **MEDIUM** — drift-prone coupling (string-matched, duplicated constants).
+   - **LOW** — smell. Loud, immediately-visible breakage caps at HIGH.
+
+5. **Report in chat:**
+
+   ```
+   # Boundary check — {plan}
+
+   Touched files read: {N} · Boundaries identified: {N}
+   Violations: {N} ({critical}/{high}/{medium}/{low})
+
+   | # | Boundary | Planned change | Other side (file:line) | Severity |
+
+   ## Suggested plan amendments
+   ## Missing plan subsections
+   ```
+
+## Rules
+
+- **Read-only.** You never edit the plan, the code, or any doc. The user folds your amendments into the plan.
+- **Verify in source.** Never flag from plan text alone — read both sides of every boundary you report, and cite both as `file:line`.
+- **No consumer, no finding.** An intersection with no traced other side isn't a violation; at most note it as a new edge the plan introduces.
+- **A clean report is valid.** Zero violations means say so — don't pad.