@bonesofspring/ai-rules 0.2.13 → 0.2.15

package/presets/claude/nuxt/hooks/examples/README.md

@@ -0,0 +1,18 @@
+# Hooks cookbook (examples)
+
+Optional scripts under `hooks/examples/`. **Not** referenced from default `hooks.json` (only `guard-shell-command.sh` + `chain-team-phases.sh`).
+
+| Script | Purpose |
+|--------|---------|
+| `secret-guard.example.sh` | Fail if staged diff looks like secrets |
+| `format-edited.example.sh` | Stack formatter / linter on edited files |
+| `test-on-save.example.sh` | Scoped tests for the stack |
+
+## Wiring (Cursor)
+
+1. Copy an example into `hooks/` (drop `.example` suffix), e.g. `cp hooks/examples/secret-guard.example.sh hooks/secret-guard.sh`.
+2. `chmod +x hooks/secret-guard.sh`.
+3. Add a hook entry in `.cursor/hooks.json` (e.g. `beforeShellExecution` or `afterFileEdit` — see Cursor hooks docs).
+4. Keep cookbook scripts **out** of the default preset `hooks.json` when contributing back upstream.
+
+Stack: **nuxt** — recipes must stay stack-safe (no cross-stack lint/test commands).

package/presets/claude/nuxt/hooks/examples/format-edited.example.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+# Optional: format/lint edited JS/TS under app/ after save.
+# NOT in default hooks.json. Requires yarn scripts in app/.
+set -euo pipefail
+ROOT="${CURSOR_PROJECT_DIR:-.}"
+cd "$ROOT/app" 2>/dev/null || cd "$ROOT"
+# Prefer project scripts; adjust names to match package.json
+if command -v yarn >/dev/null 2>&1; then
+  yarn lint:js --fix 2>/dev/null || yarn eslint --fix . 2>/dev/null || true
+fi
+exit 0

package/presets/claude/nuxt/hooks/examples/secret-guard.example.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+# Optional cookbook: block committing likely secrets in staged diffs.
+# NOT wired in default hooks.json — copy to hooks/ and register manually.
+set -euo pipefail
+PATTERN='(AKIA[0-9A-Z]{16}|-----BEGIN (RSA |OPENSSH )?PRIVATE KEY-----|api[_-]?key\s*[:=]\s*['\''\"][^'\''\"]{12,})'
+if git diff --cached -U0 2>/dev/null | grep -Eiq "$PATTERN"; then
+  echo "secret-guard: possible secret in staged diff — review before commit" >&2
+  exit 1
+fi
+exit 0

package/presets/claude/nuxt/hooks/examples/test-on-save.example.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+# Optional: scoped unit tests for changed files under app/src.
+# NOT in default hooks.json. No Playwright here.
+set -euo pipefail
+ROOT="${CURSOR_PROJECT_DIR:-.}"
+cd "$ROOT/app" 2>/dev/null || exit 0
+yarn test --findRelatedTests --passWithNoTests 2>/dev/null || yarn test --passWithNoTests 2>/dev/null || true
+exit 0

package/presets/claude/nuxt/hooks/guard-shell-command.sh

@@ -0,0 +1,77 @@
+#!/usr/bin/env bash
+# Lightweight shell guard for Claude projects using this preset.
+
+set -euo pipefail
+
+input=$(cat)
+
+INPUT="$input" node <<'NODE'
+const fs = require('fs');
+
+const raw = process.env.INPUT || '';
+let event;
+try {
+  event = JSON.parse(raw);
+} catch {
+  process.stdout.write('{ "permission": "allow" }');
+  process.exit(0);
+}
+
+const command = String(event.command || event.input?.command || '');
+if (!command.trim()) {
+  process.stdout.write('{ "permission": "allow" }');
+  process.exit(0);
+}
+
+function out(permission, userMessage, agentMessage) {
+  process.stdout.write(JSON.stringify({
+    permission,
+    user_message: userMessage,
+    agent_message: agentMessage || userMessage,
+  }));
+}
+
+const dangerousGit = /\bgit\s+(reset\s+--hard|clean\s+-[^\n]*f|push\s+--force|push\s+-f|checkout\s+--\s+)/;
+if (dangerousGit.test(command)) {
+  out(
+    'ask',
+    'This command looks destructive for git state. Review it before continuing.',
+    'A project hook flagged a destructive git command. Ask the user before running it.',
+  );
+  process.exit(0);
+}
+
+const managerByFile = [
+  ['yarn.lock', 'yarn'],
+  ['pnpm-lock.yaml', 'pnpm'],
+  ['package-lock.json', 'npm'],
+].find(([file]) => fs.existsSync(file));
+
+let expected = managerByFile?.[1];
+if (!expected && fs.existsSync('package.json')) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+    const pm = typeof pkg.packageManager === 'string' ? pkg.packageManager : '';
+    expected = pm.split('@')[0] || undefined;
+  } catch {
+    // Ignore invalid package.json in the hook; the agent can diagnose it later.
+  }
+}
+
+if (!expected) {
+  process.stdout.write('{ "permission": "allow" }');
+  process.exit(0);
+}
+
+const used = command.match(/(^|[;&|]\s*)(npm|yarn|pnpm)\s+/)?.[2];
+if (used && used !== expected) {
+  out(
+    'ask',
+    `This repository appears to use ${expected}, but the command uses ${used}. Confirm before continuing.`,
+    `Use ${expected} for package scripts and installs unless the user explicitly approves ${used}.`,
+  );
+  process.exit(0);
+}
+
+process.stdout.write('{ "permission": "allow" }');
+NODE

package/presets/claude/nuxt/mcp.json

@@ -0,0 +1,20 @@
+{
+  "mcpServers": {
+    "context7": {
+      "command": "npx",
+      "args": ["-y", "@upstash/context7-mcp"]
+    },
+    "playwright-test": {
+      "command": "npx",
+      "args": ["-y", "@playwright/mcp@latest"]
+    },
+    "chrome-devtools": {
+      "command": "npx",
+      "args": ["-y", "chrome-devtools-mcp@latest"]
+    },
+    "figma": {
+      "type": "http",
+      "url": "https://mcp.figma.com/mcp"
+    }
+  }
+}

package/presets/claude/nuxt/rules/README.md

@@ -0,0 +1,90 @@
+# `.claude/rules` (preset nuxt)
+
+In Claude Code all `.md` files under `rules/` are **discovered recursively**. Bodies are **derived** from Cursor SoT; indexes are not a second SoT.
+
+## SoT sync
+
+| Principle | Detail |
+|-----------|--------|
+| **SoT** | `presets/cursor/nuxt/rules/*.mdc` — edit here first |
+| **Derive** | Claude topic `.md` = body + `paths:` (from Cursor `globs:` / requestable triggers) |
+| **Drop** | Cursor-only keys (`alwaysApply`); keep short `description` |
+| **Checklist** | change Cursor → update Claude twin **same PR** (**FAIL** if missing — includes `nuxt`; see `preset-twin-sync` / build-verifier) |
+| **Shared core** | `presets/_shared/core/**` — see `<!-- shared-core: … -->` markers; taxonomy in `_shared/README.md` |
+
+## Loading strategy
+
+- **Session start (no `paths:`):** exactly **3** — `nuxt-app-core`, `package-manager`, `code-quality`
+- **On-demand (`paths:` or via commands):** `post-change-lint`, `security-nuxt`, architecture, UI, tests, `vue-nuxt-anti-hallucination`, **preset-*** meta, …
+- **Skills:** `feature-delivery`, `vue-performance`, `code-review`, …
+
+## Cursor → Claude mapping
+
+| Cursor `.mdc` (SoT) | Claude topic |
+|---------------------|--------------|
+| `nuxt-app-core.mdc` | `stack/nuxt-app-core.md` |
+| `package-manager.mdc` | `tooling-and-review/package-manager.md` |
+| `code-quality-and-refactoring.mdc` | `tooling-and-review/code-quality.md` |
+| `anti-sycophancy-discipline.mdc` | `tooling-and-review/anti-sycophancy-discipline.md` |
+| `vue-nuxt-anti-hallucination.mdc` | `anti-hallucination/vue-nuxt-anti-hallucination.md` |
+| `design-guidance.mdc` | `tooling-and-review/design-guidance.md` |
+| `nuxt-pages-routing.mdc` | `stack/nuxt-pages-routing.md` |
+| `script-setup-conventions.mdc` | `stack/script-setup-conventions.md` |
+| `types-jsdoc.mdc` | `stack/types-jsdoc.md` |
+| `no-type-assertion-as-import-export.mdc` | `stack/no-type-assertion.md` |
+| `navigation-router-stack.mdc` | `stack/navigation-router.md` |
+| `navigation-router-ui.mdc` | `stack/navigation-router-ui.md` |
+| `architecture-boundaries.mdc` | `architecture/architecture-boundaries.md` |
+| `architecture-boundaries-ui.mdc` | `architecture/architecture-boundaries-ui.md` |
+| `feature-delivery-workflow.mdc` | `architecture/feature-delivery-workflow.md` |
+| `reference-features.mdc` | `architecture/reference-features.md` |
+| `public-imports.mdc` | `architecture/public-imports.md` |
+| `layer-barrel-exports.mdc` | `architecture/layer-barrel-exports.md` |
+| `api-services.mdc` | `api-and-data/api-services.md` |
+| `http-client.mdc` | `api-and-data/http-client.md` |
+| `store-pinia.mdc` | `api-and-data/store-pinia.md` |
+| `vue-ui.mdc` | `ui-and-accessibility/vue-ui.md` |
+| `vue-a11y-coding.mdc` | `ui-and-accessibility/vue-a11y-coding.md` |
+| `no-v-bind-spread.mdc` | `ui-and-accessibility/no-v-bind-spread.md` |
+| `css-property-order-stylelint.mdc` | `ui-and-accessibility/css-property-order.md` |
+| `tests-unit.mdc` | `testing/tests-unit.md` |
+| `tests-e2e-structure.mdc` | `testing/tests-e2e-structure.md` |
+| `playwright-agents.mdc` | `testing/playwright-agents.md` |
+| `post-change-lint.mdc` | `tooling-and-review/post-change-lint.md` |
+| `code-review-mr.mdc` | `tooling-and-review/code-review-mr.md` |
+| `security-nuxt.mdc` | `tooling-and-review/security-nuxt.md` |
+| `agent-team-intake.mdc` | `tooling-and-review/agent-team-intake.md` |
+| `agent-team-orchestrator.mdc` | `tooling-and-review/agent-team-orchestrator.md` |
+| `technical-retro.mdc` | `tooling-and-review/technical-retro.md` |
+| `preset-layering.mdc` | `tooling-and-review/preset-layering.md` |
+| `preset-twin-sync.mdc` | `tooling-and-review/preset-twin-sync.md` |
+| `preset-token-budget.mdc` | `tooling-and-review/preset-token-budget.md` |
+| `preset-pr-checklist.mdc` | `tooling-and-review/preset-pr-checklist.md` |
+| `preset-no-cross-stack-leakage.mdc` | `tooling-and-review/preset-no-cross-stack-leakage.md` |
+
+## Core → stack mapping
+
+| Shared core | Cursor adapter | Notes |
+|-------------|----------------|-------|
+| `quality/code-quality-and-refactoring.md` | `code-quality-and-refactoring.mdc` / `code-quality.md` | + Stack notes (ESLint/Vue/CSS) |
+| `quality/anti-sycophancy-discipline.md` | `anti-sycophancy-discipline.mdc` | requestable |
+| `quality/design-guidance.md` | `design-guidance.mdc` | requestable |
+| `agent-team/agent-team-orchestrator.md` | `agent-team-orchestrator.mdc` | Roles in Stack notes |
+| `agent-team/agent-team-intake.md` | `agent-team-intake.mdc` | thin alias |
+| `architecture/feature-delivery-workflow.md` | `feature-delivery-workflow.mdc` | Nuxt layer checklist |
+| `architecture/reference-features.template.md` | `reference-features.mdc` | path table |
+| `review/code-review-mr.md` | `code-review-mr.mdc` | Nuxt checklist refs |
+| `review/technical-retro.md` | `technical-retro.mdc` | thin alias |
+| `meta/preset-*.md` | `preset-*.mdc` | author globs only |
+
+## Folders
+
+| Folder | About |
+|--------|--------|
+| `stack/` | Nuxt core, pages routing, conventions |
+| `architecture/` | Boundaries, feature-delivery, imports |
+| `api-and-data/` | HTTP, services, Pinia |
+| `anti-hallucination/` | Vue/Nuxt/Pinia banlists |
+| `testing/` | Unit, e2e, Playwright |
+| `ui-and-accessibility/` | Vue UI, a11y, props |
+| `tooling-and-review/` | Quality, review, lint, agent-team, **preset meta** |

package/presets/claude/nuxt/rules/anti-hallucination/vue-nuxt-anti-hallucination.md

@@ -0,0 +1,72 @@
+---
+description: Vue/Nuxt/Pinia anti-hallucination banlist — phantom imports, deprecated APIs, store phantoms
+paths:
+  - "**/*.{vue,ts,js}"
+  - pages/**/*
+  - components/**/*
+  - composables/**/*
+  - stores/**/*
+  - server/**/*
+---
+# Vue / Nuxt / Pinia anti-hallucination
+
+These rows **OVERRIDE** generation for the listed patterns. Before inventing an import, composable, or store helper: verify against `package.json` (installed majors), `nuxt.config.*`, and sibling files. If unsure, mark `// VERIFY: lib.symbol @ version` and surface the uncertainty — do not silently stub.
+
+Routing-specific rows stay in **`nuxt-pages-routing`**. This rule covers broader Vue / Nuxt / Pinia phantoms across the app tree.
+
+## 1. Phantom / wrong Nuxt imports
+
+| ❌ Avoid | ✅ Prefer |
+|---------|----------|
+| `import { useRouter } from 'next/navigation'` / `next/router` | Nuxt auto-import `useRouter` / `useRoute` / `navigateTo` |
+| `import Link from 'next/link'` / `<Link>` from Next | `<NuxtLink>` |
+| `import Image from 'next/image'` | `<NuxtImg>` / project image helper (check `@nuxt/image`) |
+| Invented: `nuxt/app/router`, `nuxt/server-only`, `nuxt/auth` | Real `#app` / `#imports` / documented Nuxt APIs for **installed** major |
+| `defineNuxtConfig` options copied from blogs without checking major | Match installed Nuxt + existing `nuxt.config.*` |
+| Pages Router Next APIs (`getServerSideProps`) in Nuxt | `useAsyncData` / `useFetch` / server routes / Pinia — mirror siblings |
+
+## 2. SSR / client boundary
+
+| ❌ Avoid | ✅ Prefer |
+|---------|----------|
+| Reading secrets via `useRuntimeConfig().apiSecret` in client-only UI blindly | Private keys under `runtimeConfig` (server); public under `runtimeConfig.public` |
+| Using `window` / `document` in setup without client guards | `onMounted`, `import.meta.client`, `<ClientOnly>` |
+| Pinia stores that assume browser storage during SSR without pattern | Persist plugins / cookie patterns already in repo; guard client APIs |
+| Importing Node-only modules into universal SFC setup | Keep in `server/**` or server-only utils |
+
+## 3. Vue patterns
+
+| ❌ Avoid | ✅ Prefer |
+|---------|----------|
+| React hooks in Vue SFCs (`useState`/`useEffect` from `react`) | `ref` / `reactive` / `computed` / `watch` / lifecycle (`onMounted`, …) |
+| `import { useEffectEvent } from 'vue'` (phantom) | Real Vue APIs for installed major; else local pattern + `VERIFY` |
+| Options API churn in a `<script setup>` codebase | Follow neighbor SFCs (`script-setup-conventions`) |
+| Phantom packages: `@vue/nonexistent`, invented `~/composables/useServerQuery` | Only lockfile packages + composables that exist |
+
+## 4. Pinia phantoms
+
+| ❌ Avoid | ✅ Prefer |
+|---------|----------|
+| RTK APIs: `createSlice`, `createAsyncThunk`, `useDispatch` | `defineStore` + actions (`store-pinia`) |
+| Invented helpers: `definePiniaApi`, `store.injectEndpoints` | Documented Pinia + patterns from existing `stores/**` |
+| Deep imports breaking public API: `~/stores/foo/internal` | Public store module / naming used by siblings |
+| Storing raw transport DTOs in state | Domain models from `~/types` after mapper in `api/**` |
+
+## 5. Navigation / data / fetch
+
+| ❌ Avoid | ✅ Prefer |
+|---------|----------|
+| Raw `$fetch` / `fetch` from SFC bypassing `~/api` | Services via `~/api` / `@/api` (`api-services`, `http-client`) |
+| Invented `useFetch` option names siblings never use | Copy from sibling; verify Nuxt data-fetching docs for installed major |
+| Axios error shapes when the client is ofetch/`$fetch` | Transport errors from project types / ofetch patterns |
+| Assuming `baseURL` without checking Nitro / runtimeConfig | Match `lib/clients` / existing client wrapper |
+
+## 6. Version drift / auto-imports
+
+| ❌ Avoid | ✅ Prefer |
+|---------|----------|
+| Bleeding-edge Nuxt/Vue APIs without checking `package.json` | Confirm majors; copy a compiling sibling |
+| Inventing `#imports` symbols that are not generated | Check `.nuxt/imports` / docs; explicit import if missing |
+| Mixing Vue 2 Options-only APIs into Vue 3 Nuxt 3 apps | Vue 3 idioms used in repo |
+
+When a row conflicts with a verified sibling pattern in this repo, **the sibling wins** — update this banlist in a preset PR rather than inventing a third path.

package/presets/claude/nuxt/rules/api-and-data/README.md

@@ -0,0 +1,9 @@
+# API and data
+
+HTTP transport, services, Pinia store.
+
+| File | Contents | `paths:` |
+|------|----------|----------|
+| `http-client.md` | Shared HTTP client, errors, store link | `lib/clients/**`, `api/clients/**` |
+| `api-services.md` | Services, mappers, DTO → domain | `api/services/**` |
+| `store-pinia.md` | Pinia, actions, typing | `stores/**` |

package/presets/claude/nuxt/rules/api-and-data/api-services.md

@@ -0,0 +1,77 @@
+---
+description: API services and mapper conventions
+paths: api/services/**/*.ts
+---
+
+# Role of the API layer
+
+- Encapsulate everything related to:
+  - HTTP requests through **application API client instances** in `api/clients/**`, built on the **shared implementation** from `lib/clients/**` (as in existing code); details — **`http-client.mdc`**; layer placement in the **ports and adapters** scheme — `architecture-boundaries.mdc`;
+  - URLs/paths,
+  - headers and response codes,
+  - backend DTOs.
+- Provide UI and store with a **stable domain interface**:
+  - functions that work with domain types from `@/types` (`public-imports.mdc`).
+  - mappers between DTOs and domain types.
+
+# Module structure
+
+- For each domain area (for example, orders, billing, account settings):
+  - a separate directory in `api/services/<ServiceName or feature>/**` following repository convention.
+- Inside a module:
+  - files with API calls (`index.ts` or `*.service.ts`);
+  - mapper files (`*responseMappers.ts`);
+  - request/response-specific types (if not moved to `types/**` with export through the `@/types` barrel).
+  - when needed — local `index.ts` / barrel inside the module for structure **within** `api/**`; **outside** this layer UI, store, and other code import only from the root barrel `api/index.ts` (`import … from '@/api'`, **`public-imports.mdc`**).
+
+# Mappers and types
+
+- For each request/endpoint:
+  - describe the **response type (DTO)** that exactly matches the backend contract;
+  - define the **target domain type** in `types/**` that the application will use (including computed/aggregated fields).
+- Mappers (for example, `*responseMappers.ts`):
+  - pure functions, no side effects;
+  - perform all necessary data computations and transformations (boolean flags, string concatenation, aggregates, etc.) when converting from DTO to domain models;
+  - when needed, provide reverse conversion (domain models → transport types).
+- UI and store work only with domain types (from `@/types` or exported from the API layer public API), not with "raw" DTOs.
+- **Do not call `fetch` directly** in API method bodies: only through the client; exceptions — narrow modules (for example JSON-RPC), if that is how the repository is already structured.
+
+# Error handling
+
+- The API layer:
+  - must not "swallow" errors without a trace;
+  - either throws domain/unified errors;
+  - or returns a result in a `Result<T, E>`-like form (if that pattern is adopted in the project).
+- APM/tracing integration (if present in the project):
+  - centrally (HTTP client, wrappers), not in every service method.
+
+# Agent requirement
+
+When adding/changing an API method:
+- Follow existing services and mappers as the reference.
+- Complete the barrel-export checklist (**`layer-barrel-exports.mdc`**): local `index.ts` → layer facade → root barrel.
+- Do not mix the API layer and UI/store:
+  - components must not depend on DTOs;
+  - store must not assemble URLs/endpoint codes itself or bypass services; **transport response type** and **error contract** from `@/types` (as with the application client) are acceptable in **Pinia actions** when parsing `catch`/payload, if the service is structured that way (see `store-pinia.mdc`, `http-client.mdc`).
+- When using API services in UI, store, and utilities **outside** `api/**`, import **only** from `@/api` (root barrel), see **`public-imports.mdc`**; inside the API layer — via relative paths or `@/api/services/**` / `@/api/clients/**`, without duplicating the public contract around the root barrel for external consumers.
+## Incorrect
+
+```ts
+// Returning raw DTO to store/UI without mapping
+export const getCard = async (id: string) => {
+  const { data } = await cardsClient.get(`/cards/${id}`)
+  return data // backend DTO leaked upward
+}
+```
+
+## Correct
+
+```ts
+import type { TCard } from '@/types'
+import { mapCardResponse } from './cardResponseMappers'
+
+export const getCard = async (id: string): Promise<TCard> => {
+  const { data } = await cardsClient.get(`/cards/${id}`)
+  return mapCardResponse(data)
+}
+```

package/presets/claude/nuxt/rules/api-and-data/http-client.md

@@ -0,0 +1,16 @@
+---
+description: HTTP client wrapper for Nuxt — $fetch/ofetch, one stack, error contracts
+paths:
+  - lib/clients/**/*.ts
+  - api/clients/**/*.ts
+  - api/**/*.ts
+---
+# HTTP client
+
+- One HTTP stack for the app: wrap **`$fetch` / ofetch** (or the client already used in `lib/clients/**`).
+- Do not mix ad-hoc `fetch`/`axios` in features if a shared client exists.
+- Services in `api/**` call the wrapper — UI/stores do not own transport.
+- Map responses to domain models in services/mappers before Pinia.
+- Errors: use project transport error types from `~/types` / `@/types`; narrow with `instanceof` when available.
+- Base URL / auth headers: from `runtimeConfig` / existing client factories — do not hardcode secrets.
+- Calling Nitro `/api/*` from the client is fine when that is the BFF pattern — still through services.

package/presets/claude/nuxt/rules/api-and-data/store-pinia.md

@@ -0,0 +1,68 @@
+---
+description: Pinia stores and client application state (Nuxt)
+paths:
+  - stores/**/*.ts
+  - stores/**/*.js
+---
+
+# General principles
+
+- Use **Pinia** (`defineStore`) — setup or options store, as neighbors do in the repo.
+- Module: `@pinia/nuxt` (or the installed equivalent) — check `package.json` / `nuxt.config`.
+- Store **domain models**, not raw API DTOs.
+- DTO → domain mapping — in `api/**` (or server mappers) **before** writing to the store.
+- Separate server state (API data) from local UI state (filters/flags) — UI-only may live in a composable/`ref` on the page if that is the repo convention.
+
+# Forbidden in this preset
+
+- RTK / Redux: `createSlice`, `createAsyncThunk`, RTK Query, `useDispatch` / `useSelector`, stem `store-rtk`.
+- Raw `$fetch` / `fetch` from the store bypassing `~/api` / `@/api` services (except narrow documented repo exceptions).
+
+# Structure
+
+- One domain module — its own file under `stores/**` (e.g. `stores/profile.ts`).
+- Export: `useXStore` via `defineStore('x', …)`.
+- State: explicit type; careful initialization.
+- Getters — derived from domain state; actions call services from `~/api` / `@/api` (`public-imports`).
+
+# Async
+
+```ts
+// Incorrect — raw HTTP + DTO in state
+export const useProfileStore = defineStore('profile', {
+  actions: {
+    async load() {
+      this.profile = await $fetch('/api/profile')
+    },
+  },
+})
+
+// Correct
+import { profileApi } from '~/api'
+
+export const useProfileStore = defineStore('profile', {
+  state: (): { profile: Profile | null } => ({ profile: null }),
+  actions: {
+    async load() {
+      this.profile = await profileApi.getProfile()
+    },
+  },
+})
+```
+
+# Typing and errors
+
+- Domain types from `~/types` / `@/types`.
+- Transport errors — contracts from `@/types` / the accepted client error class (`http-client`), not invented axios shapes.
+- In UI: `storeToRefs` for state; call actions directly on the store.
+
+# Testing
+
+- Cover important stores (init, transitions, actions with mocked API).
+- Unit: Vitest; mock `~/api` services.
+
+# Agent requirement
+
+- Do not put HTTP/transport in components.
+- Strictly type state/actions.
+- Follow neighboring store style.

package/presets/claude/nuxt/rules/architecture/README.md

@@ -0,0 +1,12 @@
+# Architecture rules
+
+| File | Purpose |
+|------|---------|
+| `public-imports.md` | Imports `@/types`, `@/types/enums`, `@/api` (outside `api/**`) |
+| `architecture-boundaries-ui.md` | Slim UI boundaries when editing components |
+| `architecture-boundaries.md` | Full UI / store / API map (api, store, types, lib) |
+| `layer-barrel-exports.md` | Two-level barrels for layers with a public API |
+| `feature-delivery-workflow.md` | End-to-end checklist for a new feature |
+| `reference-features.md` | Reference paths for UI/store/API/types |
+
+Deprecated stubs `types-public-imports.md` / `api-public-imports.md` **removed** — use `public-imports.md`.

package/presets/claude/nuxt/rules/architecture/architecture-boundaries-ui.md

@@ -0,0 +1,16 @@
+---
+description: UI layer boundaries — slim rule for component edits (without the full store/API map)
+paths:
+  - components/**/*.vue
+  - components/**/*.ts
+---
+
+# UI layer boundaries (slim)
+
+- **Imports:** `components/**`, `composables/**`, `stores/**` (public), types from `~/types` / `@/types`, API — only `from '~/api'` / `from '@/api'` (`public-imports`).
+- **Forbidden:** direct HTTP client (`$fetch` / ofetch outside `lib/clients`); DTO knowledge — domain types only.
+- **State:** write scenarios and multi-step coordination — via Pinia actions (`store-pinia`); narrow direct `~/api` reads — only as in neighboring features.
+- **Organization:** `~/` / `@/` aliases; no deep imports into other features; public API only.
+- **Barrel:** for new public symbols — re-export per `layer-barrel-exports` (rule loads on `index.ts`).
+
+Full layer map (store, API, ports/adapters): **`architecture-boundaries`** — when editing `api`, `stores`, `types`, `lib`.

package/presets/claude/nuxt/rules/architecture/architecture-boundaries.md

@@ -0,0 +1,99 @@
+---
+description: Architectural boundaries and import rules
+paths:
+  - api/**/*
+  - stores/**/*
+  - types/**/*
+  - lib/**/*
+---
+
+# Layer boundaries
+
+- **UI (`pages/**`, `components/**`, `layouts/**`)**:
+  - May import: `components/**`, `composables/**`, `stores/**` (public), types from `~/types` / `@/types` and enums from `~/types/enums` / `@/types/enums` (**only as in `public-imports.mdc`**), API contract — **only** `import … from '~/api'` / `from '@/api'` (**`public-imports.mdc`**).
+  - Must not:
+    - call the HTTP client directly (`$fetch` / ofetch outside `lib/clients`);
+    - know backend DTO details — only domain types.
+- **Store (`stores/**`)** — Pinia `defineStore` only (`store-pinia.mdc`):
+  - May import: other `stores/**` (public), services and public API entities — **only** from `~/api` / `@/api` (**`public-imports.mdc`**), types from `~/types` / `@/types` and enums from `~/types/enums` / `@/types/enums` (**`public-imports.mdc`**).
+  - Must not:
+    - depend on specific UI components / pages;
+    - work with global/window API directly.
+  - Backend calls — only through services imported from `~/api` / `@/api`; **transport** response and error types (from `@/types`, same shape as the application HTTP client) in **Pinia actions** are acceptable if the API layer is structured that way (`http-client.mdc`, `store-pinia.mdc`).
+- **API (`api/**`)** — implementation in `services/**`, `clients/**`, re-export in `api/index.ts`:
+  - Inside the layer: types from `@/types` and enums from `@/types/enums` (**`public-imports.mdc`**); imports `@/api/services/**`, `@/api/clients/**`, relative paths between layer files (`http-client.mdc`, `api-services.mdc`).
+  - Must not:
+    - pull in UI or store;
+    - mix HTTP and domain layers — use mappers.
+
+## UI and API access (`~/api` / `@/api`)
+
+- By default, scenarios that **change server state** and coordinate multiple steps go through **Pinia actions** (`defineStore`, feature pattern in the repository).
+- Direct calls to service methods imported from **`~/api` / `@/api`** from UI are allowed only in **narrow cases**: mainly **reads** or actions **without needing the result in Pinia**; same **domain types** a store action would use; **do not** duplicate an existing store scenario and **do not** pass DTOs into components.
+- Prefer structuring such calls like **neighboring features** in the repository (composable facade, `use*`, etc.).
+
+## Ports and adapters (short map)
+
+- **Inbound adapter**: UI — user input, display; depends on store and domain types, not transport.
+- **Scenario orchestration**: store (Pinia actions) — calls services, puts **domain** models in state after mapping.
+- **Outbound port (backend contract)**: public API **`~/api` / `@/api`** (barrel `api/index.ts`; implementation — in `api/services/**`, etc., see `public-imports.mdc`).
+- **Outbound adapter**: shared HTTP implementation in **`lib/clients/**`** and instances in **`api/clients/**`** (wrap `$fetch` / ofetch).
+
+## Feature as a slice
+
+- For a complex feature, align names and terms (**ubiquitous language** of the domain) in types, getters/actions, services, and UI; folder structure — as in neighboring features in the repository.
+
+# Import rules
+
+- Always use the `~/` or `@/` alias for cross-layer imports (as established in the repo); respect `#imports`.
+- Within one module/feature, relative imports are OK, but **without climbing above the feature root** (avoid `../../../`).
+- When components, composables, utilities, and other modules reach into another layer or feature, use only **public API** (barrel/index files and explicitly exported entities); no deep imports into other features' internal files; for regulated layers — **`layer-barrel-exports.mdc`** and `public-imports.mdc`; for the API layer from outside `api/**` — **`public-imports.mdc`** (only `~/api` / `@/api`).
+- When adding new code, check:
+  - if the module is reusable — it should depend only on "lower" layers (types, utils, api), not on pages.
+
+# Feature organization
+
+- For complex features (for example, `OrderCheckout`):
+  - Page / route: `pages/**` and/or `components/pages/OrderCheckoutPage/**`.
+  - Local components: `components/**` subdirectories inside the page.
+  - Related store: `stores/orderCheckout.ts` (or the neighboring Pinia module scheme in the repo).
+  - API: `api/services/OrdersApi/OrderCheckout/**` (root service name from the project scheme).
+  - Types: `types/**` with export through barrel **`types/index.ts`** (`public-imports.mdc`).
+
+# Agent requirement
+
+When adding new functionality:
+- Place files in the **appropriate layers**.
+- Check existing features with similar structure and **repeat their organization**.
+- Do not "short-circuit" layers (for example, do not call API directly from a component just to simplify).
+- **Forbidden:** RTK / Redux (`createSlice`, `createAsyncThunk`, `useDispatch`, `stores/slices/**` as the canon).
+
+## Incorrect
+
+```ts
+// UI calling HTTP client / deep service path directly
+import { httpClient } from '@/lib/clients/HttpClient'
+import { fetchOrders } from '@/api/services/OrdersApi/orders.service'
+
+export const loadOrdersInPage = async () => {
+  // bypasses store and @/api barrel
+  await httpClient.get('/orders')
+}
+```
+
+## Correct
+
+```vue
+<script setup lang="ts">
+import { storeToRefs } from 'pinia'
+import { useOrdersStore } from '~/stores/orders'
+
+const ordersStore = useOrdersStore()
+const { orders } = storeToRefs(ordersStore)
+
+// UI → Pinia action → services from ~/api
+onMounted(() => {
+  void ordersStore.loadOrders()
+})
+</script>
+```