coding-os 0.3.2__py3-none-any.whl

templates/svelte-sveltekit/scaffold/src/frontend/src/routes/health/+server.ts

@@ -0,0 +1,7 @@
+import { json } from "@sveltejs/kit";
+import type { RequestHandler } from "./$types";
+
+// Liveness probe for {{PROJECT_NAME}} — GET /health → { status: "ok" }.
+export const GET: RequestHandler = () => {
+  return json({ status: "ok" });
+};

templates/svelte-sveltekit/scaffold/src/frontend/svelte.config.js

@@ -0,0 +1,10 @@
+// Minimal SvelteKit config — extend as the app grows ({{PROJECT_NAME}}).
+import adapter from "@sveltejs/adapter-auto";
+
+/** @type {import('@sveltejs/kit').Config} */
+export default {
+  kit: {
+    // $lib resolves to src/lib by default; routes live under src/routes.
+    adapter: adapter(),
+  },
+};

templates/svelte-sveltekit/scaffold/src/frontend/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./.svelte-kit/tsconfig.json",
+  "compilerOptions": {
+    "strict": true,
+    "moduleResolution": "bundler"
+  }
+}

templates/svelte-sveltekit/scaffold/src/frontend/vite.config.ts

@@ -0,0 +1,7 @@
+// Vite config for {{PROJECT_NAME}} — SvelteKit plugin only; extend as needed.
+import { sveltekit } from "@sveltejs/kit/vite";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  plugins: [sveltekit()],
+});

templates/svelte-sveltekit/scaffold/src/frontend/vitest.config.ts

@@ -0,0 +1,11 @@
+// Vitest config for {{PROJECT_NAME}} unit tests — kept separate from
+// vite.config.ts so the SvelteKit plugin (which needs the generated
+// .svelte-kit/ dir) is not loaded for pure unit runs.
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    include: ["src/**/*.{test,spec}.ts"],
+  },
+});

templates/svelte-sveltekit/scaffold-boundary.yaml

@@ -0,0 +1,29 @@
+# Scaffold boundary for the svelte-sveltekit stack.
+# Schema: docs/governance/scaffold-boundary-contract.md
+
+version: 1
+stack: svelte-sveltekit
+
+roots:
+  - src/frontend/
+
+file_patterns:
+  - "src/frontend/**/*.svelte"
+  - "src/frontend/**/*.ts"
+  - "src/frontend/**/*.js"
+  - "src/frontend/**/*.json"
+  - "src/frontend/**/*.html"
+
+imports_from:
+  - src/shared/
+  - src/shared/types/
+  - src/shared/contracts/
+
+forbids_writing_in:
+  - src/backend/
+  - src/mobile/
+
+notes:
+  - "Routes own navigation; load functions own data; components stay presentational."
+  - "Secrets live only in +page.server.ts / +server.ts / hooks.server.ts — anything a +page.svelte imports ships to the client."
+  - "hooks.server.ts handleError is the only error-response shaper."

templates/svelte-sveltekit/skills/svelte/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: svelte
+tier: stack
+domain: [frontend]
+description: Use when creating or modifying Svelte/TypeScript files under src/frontend/ in a SvelteKit app — routes (+page/+layout), load functions, .svelte components, $lib stores, and server endpoints (+server.ts). Triggers on any .svelte or .ts change under src/frontend/. Covers file-based routing, universal vs server load, the $lib stores hierarchy, the single hooks.server.ts error shaper, and the client/server publish boundary. Generic frontend principles live in the core frontend-fundamentals skill.
+globs: "src/frontend/**/*.{svelte,ts}"
+depends_on:
+  - clean-code
+  - frontend-fundamentals
+  - state-management
+last_reviewed: "2026-06-14"
+---
+
+REQUIRED BACKGROUND: You MUST also follow the core `frontend-fundamentals` and `clean-code` skills. This skill adds SvelteKit-specific conventions on top.
+
+# svelte
+
+## Layer contract (matches `structure.tree`)
+
+| Layer | May import | Never |
+|---|---|---|
+| `+page.svelte` / components | `$lib` components + stores, `load` data via props | `fetch` in setup, server-only modules, secrets |
+| `+page.ts` / `+layout.ts` (universal) | the injected `fetch`, public env | `$env/static/private`, db clients, secrets |
+| `+page.server.ts` / `+server.ts` (server) | db clients, private env, secrets | DOM, browser-only APIs |
+| `$lib/stores/*.ts` | `svelte/store` primitives | route modules, `load` results |
+| `hooks.server.ts` | private env, the logger | per-route business logic |
+
+Components stay presentational — data arrives as props from a `load` function —
+so a fetch swap is a `load`-layer-only change and the component is unit-testable
+without a network.
+
+## Routing & layout
+
+- File-based routing only — a route is a directory under `routes/` with a
+  `+page.svelte`; never hand-wire a client router. Dynamic segments: `routes/users/[id]/+page.svelte`.
+- `+layout.svelte` owns shared shell (nav, error boundary) and renders the page
+  via `{@render children()}`; keep it a shell, not a logic host.
+
+## Load functions (data ownership)
+
+- `+page.ts` / `+layout.ts` (universal) run on server then client — use the
+  injected `fetch`, never the bare global (it double-fetches on hydration and
+  skips SvelteKit's relative-URL + cookie handling).
+- `+page.server.ts` / `+layout.server.ts` run server-only — the place for db
+  clients, `$env/static/private`, and any secret. Their return value is
+  serialized to the client, so never return a secret from a server `load`.
+- A component never fetches in its `<script>` body; data flows in through the
+  `load` result as `data` props.
+
+## Stores & state
+
+- Local component state first (`$state` / plain `let`); cross-component state in
+  `$lib/stores` as `writable`/`derived`, one store per file, per the
+  state-management skill hierarchy — no module-level mutable singletons.
+- Subscribe with the `$store` auto-subscription in components; never manually
+  `.subscribe()` without unsubscribing.
+- Do not mutate a store from inside a `load` function — `load` returns data,
+  stores hold client state.
+
+## Client/server split (the publish boundary)
+
+- Anything a `+page.svelte` imports ships to the browser. Secrets, privileged
+  clients, and `$env/static/private` live only in `+page.server.ts`,
+  `+server.ts`, and `hooks.server.ts`.
+- A `+page.svelte` import of a server-only module is a publish-boundary leak and
+  a review-blocking finding.
+
+## Error handling
+
+- ONE central shaper: `hooks.server.ts::handleError` shapes every unexpected
+  server error (RFC-9457-style shape per `docs/api-contracts/error-format.md`).
+  Log full detail server-side with a reference id; return only a safe message.
+- Endpoints (`+server.ts`) and actions throw `error(status, ...)` /
+  `fail(status, ...)`; never hand-build an error response body.
+
+## Accessibility
+
+- Interactive elements keyboard-reachable with a visible focus ring; use native
+  elements (`<button>`, `<a>`) over `div` + handlers. Provide a skip link and a
+  single `<main>` landmark in `+layout.svelte`. The `a11y` core skill is the
+  checklist SSOT.
+
+## Testing
+
+- `load` functions: pure unit tests — call the exported `load` with a mocked
+  event, assert the returned data; no network.
+- Components: @testing-library/svelte, minimal mounting, assert behavior not
+  markup; one happy + one error/empty state minimum.
+- Server endpoints: invoke the `GET`/`POST` handler directly with a mocked
+  request event; never bind a real port in tests.

templates/svelte-sveltekit/skills/svelte/references/anatomy.md

@@ -0,0 +1,62 @@
+<!-- domain:SVELTESVELTEKIT | layer:reference | ssot:true | updated:2026-06-27 -->
+# Svelte + SvelteKit Anatomy
+
+> P: Canonical file map + entity recipes for the SvelteKit (file-routing, load functions) stack.
+> R: Adding any `.svelte`/`.ts` under `src/frontend/`, or routing a frontend task.
+> S: Reading backend / mobile code — wrong stack.
+> N: [SKILL.md](../SKILL.md), [scaffold-boundary.yaml](../../../scaffold-boundary.yaml)
+
+> Nav: [Skill](../SKILL.md)
+
+---
+
+## 1. Boundary
+
+SSOT: `src/templates/svelte-sveltekit/scaffold-boundary.yaml`.
+
+## 2. Layout map
+
+| Pattern | Location | Naming | Imports from | Description |
+|---|---|---|---|---|
+| Page | `src/routes/<path>/+page.svelte` | `+page.svelte` | `$lib` | Presentational route component |
+| Universal load | `src/routes/<path>/+page.ts` | `+page.ts` | `$lib` | Runs client + server; owns page data |
+| Server load | `src/routes/<path>/+page.server.ts` | `+page.server.ts` | db, secrets | Server-only data (secrets live here) |
+| Component | `src/lib/components/<Name>.svelte` | `<Name>.svelte` | — | Reusable presentational UI |
+| Store | `src/lib/stores/<name>.ts` | `<name>.ts` | — | One writable/derived store per file |
+| Error shaper | `src/hooks.server.ts` | `hooks.server.ts` | none | `handleError` — the ONLY error shaper |
+| Test | `<file>.test.ts` | `<file>.test.ts` | source under test | Vitest / Playwright |
+
+## 3. Entity recipes
+
+### Add a new component
+- **Trigger:** "add a `<Name>` UI block".
+- **Files emitted:** `src/lib/components/<Name>.svelte` (+ test).
+- **Steps:**
+  1. Props in, events out; no data fetching in a component.
+
+### Add a new route
+- **Trigger:** "add a `/<path>` page".
+- **Files emitted:**
+  1. `src/routes/<path>/+page.svelte`
+  2. `src/routes/<path>/+page.ts` (or `+page.server.ts` for secrets)
+- **Steps:**
+  1. `load` returns data; the page renders it. Secrets only in `+page.server.ts`.
+
+### Add a new test
+- **Trigger:** any new component / load.
+- **Files emitted:** `<file>.test.ts` next to source.
+- **Steps:**
+  1. Vitest for units; Playwright for route flows.
+
+## 4. Conventions
+
+#### Naming
+- Components: `PascalCase.svelte`. Routes: `kebab-case` dirs with `+page`/`+layout` files.
+
+#### Test colocation
+- Colocated: `<file>.test.ts` next to source.
+
+#### Dependency rules
+- ✓ page → load → `$lib` (stores/components).
+- ✗ secrets never leave `+page.server.ts` / `+server.ts` / `hooks.server.ts`.
+- ✗ `src/frontend/` never imports from `src/backend/` / `src/mobile/` — share via `src/shared/`.

templates/svelte-sveltekit/stack.yaml

@@ -0,0 +1,70 @@
+version: 1
+id: svelte-sveltekit
+language: typescript
+label: "Svelte 5 + SvelteKit + TypeScript"
+category: frontend
+
+structure:
+  root: src/frontend
+  tree: |
+    src/frontend/
+    ├── svelte.config.js
+    ├── vite.config.ts
+    ├── package.json
+    └── src/
+        ├── app.html             # document shell only
+        ├── hooks.server.ts      # the ONLY central error/response shaper (handleError)
+        ├── lib/                 # $lib alias — components, stores, helpers
+        │   ├── components/      # reusable .svelte UI, PascalCase
+        │   └── stores/          # writable/derived state, one store per file
+        └── routes/              # file-based routing
+            ├── +layout.svelte   # root shell, nav, error boundary
+            ├── +page.svelte     # a page component (presentational)
+            ├── +page.ts         # universal load (runs client + server)
+            └── +page.server.ts  # server-only load (secrets, db)
+  notes: "file-based routing under routes/; load functions own data, components stay presentational; hooks.server.ts handleError is the only error-response shaper; secrets live only in +page.server.ts / +server.ts / hooks.server.ts"
+primary_skill: svelte
+skills: [svelte]
+
+substitutions:
+  DOMAIN_ROUTES: "Frontend→`docs/playbooks/svelte-sveltekit-app.md`"
+  SKILL_ROUTES: "Frontend→`svelte`"
+  ENGINEERING_RULE_ROUTING: "Frontend→`docs/engineering/svelte-sveltekit-rules.md`, a11y→`a11y` skill"
+  TOOL_ROUTING_IMPL: "`lint-frontend`, `test-frontend`, `build-frontend`"
+  VERIFY_FRONTEND_GLOB: "`src/frontend/`"
+  VERIFY_FRONTEND_SUITES: "lint-frontend + test-frontend"
+  VERIFY_FRONTEND: "`cd src/frontend && npm run lint && npm test`"
+  QUICK_ROUTING: |-
+    - SvelteKit route / +page task → [SvelteKit App Playbook](./playbooks/svelte-sveltekit-app.md)
+    - Component / store / load work → [SvelteKit App Playbook](./playbooks/svelte-sveltekit-app.md)
+  STACK_REF_CODES: |-
+    - `REF:PLAYBOOK-SVELTEKIT` → `./playbooks/svelte-sveltekit-app.md`
+    - `REF:SVELTEKIT-RULES` → `./engineering/svelte-sveltekit-rules.md`
+
+ref_codes:
+  - {code: "REF:PLAYBOOK-SVELTEKIT", path: "./playbooks/svelte-sveltekit-app.md",      desc: "SvelteKit app playbook"}
+  - {code: "REF:SVELTEKIT-RULES",    path: "./engineering/svelte-sveltekit-rules.md",  desc: "SvelteKit engineering rules"}
+
+routing_entries:
+  - "SvelteKit route / +page task → [SvelteKit App Playbook](./playbooks/svelte-sveltekit-app.md)"
+
+rules:
+  - {file: rules/frontend.md, globs: ["src/frontend/**/*.{svelte,ts}"]}
+
+makefile_targets:
+  - {name: lint-frontend,  cmd: "npx --yes eslint . && cd src/frontend && npm run lint"}
+  - {name: test-frontend,  cmd: "cd src/frontend && npm test"}
+  - {name: build-frontend, cmd: "cd src/frontend && npm run build"}
+
+verify:
+  - {glob: "src/frontend/**/*.{svelte,ts}", suites: "lint-frontend + test-frontend", cmd: "npx --yes eslint . && cd src/frontend && npm run lint && npm test"}
+
+dimensions:
+  - {name: "Svelte component",  read_files: ["docs/playbooks/svelte-sveltekit-app.md", "docs/engineering/svelte-sveltekit-rules.md"]}
+  - {name: "Route / +page",     read_files: ["docs/playbooks/svelte-sveltekit-app.md", "docs/engineering/svelte-sveltekit-rules.md"]}
+  - {name: "Store / state",     read_files: ["docs/engineering/svelte-sveltekit-rules.md"]}
+  - {name: "Accessibility",     read_files: ["docs/engineering/svelte-sveltekit-rules.md"]}
+
+skill_enforcement:
+  - {globs: ["src/frontend/**/*.{svelte,ts}"], primary: svelte, secondary: [clean-code, frontend-fundamentals, frontend-design, a11y, performance, testing-strategy]}
+  - {globs: ["src/frontend/**/lib/stores/**/*.ts", "src/frontend/**/stores/**/*.ts"], primary: svelte, secondary: [state-management, clean-code, frontend-fundamentals]}

templates/typescript-plain/scaffold/src/index.ts

@@ -0,0 +1,3 @@
+export function greet(name: string): string {
+  return `{{PROJECT_NAME}} greets ${name} — scaffolded by coding-os (typescript-plain)`;
+}

templates/typescript-plain/scaffold/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*.ts"]
+}

templates/typescript-plain/scaffold-boundary.yaml

@@ -0,0 +1,22 @@
+# Scaffold boundary for the typescript-plain stack (library / CLI).
+# Schema: docs/governance/scaffold-boundary-contract.md
+
+version: 1
+stack: typescript-plain
+
+roots:
+  - src/
+
+file_patterns:
+  - "src/**/*.ts"
+  - "tsconfig.json"
+
+imports_from:
+  - src/shared/
+  - src/shared/contracts/
+
+forbids_writing_in:
+  - src/mobile/
+
+notes:
+  - "Plain TypeScript library layout — src/index.ts entry, strict tsconfig. Framework stacks (nextjs, react-native) replace this layout."

templates/typescript-plain/stack.yaml

@@ -0,0 +1,44 @@
+version: 1
+id: typescript-plain
+language: typescript
+label: "TypeScript (plain — library / CLI, no framework)"
+category: library
+primary_skill: null
+skills: []
+
+structure:
+  root: src
+  tree: |
+    src/index.ts         # public entry
+    tsconfig.json        # strict, NodeNext
+  notes: "library layout; framework stacks (nextjs, react-native) replace it"
+
+# Plain-language stack (template-authoring.md § Language layer): picked when
+# the user chooses "typescript" without a framework. Ships a strict tsconfig
+# skeleton; framework stacks (nextjs, react-native) carry their own layouts.
+
+substitutions:
+  DOMAIN_ROUTES: "TypeScript module / CLI task → AGENTS.md critical rules"
+  SKILL_ROUTES: "TypeScript → `typescript` + `clean-code` (core skills)"
+  ENGINEERING_RULE_ROUTING: "TypeScript → AGENTS.md critical rules + `docs/governance/`"
+  TOOL_ROUTING_IMPL: "`lint-ts` (tsc --noEmit)"
+  QUICK_ROUTING: |-
+    - TypeScript module / package task → see AGENTS.md critical rules
+  STACK_REF_CODES: ""
+
+ref_codes: []
+
+routing_entries:
+  - "TypeScript module / CLI task → see AGENTS.md critical rules"
+
+rules: []
+
+makefile_targets:
+  - {name: lint-ts, cmd: "npx --yes eslint . && npx --yes tsc --noEmit"}
+
+verify:
+  - {glob: "src/**/*.ts", suites: "lint-ts", cmd: "npx --yes eslint . && npx --yes tsc --noEmit"}
+
+dimensions: []
+
+skill_enforcement: []

templates/vue-nuxt/rules/frontend.md

@@ -0,0 +1,19 @@
+---
+globs: ["src/frontend/**/*.{vue,ts}"]
+alwaysApply: false
+---
+
+# Nuxt Frontend Rules (auto-loaded on src/frontend/**/*.{vue,ts})
+
+When editing any Vue or TypeScript file under `src/frontend/` in a Nuxt project, follow these standards:
+
+- **SSR-safe fetching** — `useFetch`/`useAsyncData` in setup; a bare `$fetch` in setup double-fetches across server and client.
+- **Auto-import discipline** — no manual imports for Vue/Nuxt APIs, composables, or components; rely on Nuxt auto-import so the bundle stays consistent.
+- **State hierarchy** — local `ref` → composable → Pinia store; no module-level mutable singletons (they leak between requests under SSR).
+- **Client/server split** — secrets and privileged clients live under `server/`; never ship them in a component or a public runtime config key.
+- **Strict TypeScript** — `npm run lint` (vue-tsc) gates merges; `any` needs a written justification.
+- **A11y is not optional** — interactive elements are keyboard-reachable with visible focus and a correct accessible name.
+
+Canonical policy: `docs/engineering/nuxt-rules.md`
+Playbook: `docs/playbooks/nuxt-app.md`
+Primary skill: `vue-nuxt`

templates/vue-nuxt/scaffold/docs/engineering/nuxt-rules.md

@@ -0,0 +1,30 @@
+<!-- domain:FRONTEND | layer:rules | ssot:true | updated:{{DATE}} -->
+# Nuxt Engineering Rules
+
+Purpose: Non-negotiable conventions for the {{PROJECT_NAME}} Nuxt frontend.
+Read when: Editing anything under `src/frontend/`.
+Skip when: Backend/mobile work.
+Read next: [Nuxt App Playbook](../playbooks/nuxt-app.md)
+
+> Nav: [Master Index](../00-index.md)
+
+## Hard rules
+
+1. **SSR-safe fetching** — `useFetch`/`useAsyncData` in setup; bare `$fetch`
+   only in event handlers and server routes (hydration double-fetch is a
+   review-blocking finding).
+2. **Auto-import discipline** — no manual imports for Vue/Nuxt APIs,
+   `components/`, or `composables/`; composables are `useThing()`, one per file.
+3. **State hierarchy** — local `ref` → composable → Pinia store; no module-
+   level mutable singletons.
+4. **Client/server split** — secrets and privileged clients live under
+   `server/`; a page import boundary is a publish boundary.
+5. **Strict TypeScript** — `npm run lint` (vue-tsc) gates merges; `any` needs
+   a written justification.
+6. **A11y is not optional** — interactive elements keyboard-reachable with
+   visible focus; the `a11y` core skill is the checklist SSOT.
+
+## Testing bar
+
+Composables unit-tested; components behavior-tested (no snapshot-only
+suites); server routes invoked directly with mocked events.

templates/vue-nuxt/scaffold/docs/playbooks/nuxt-app.md

@@ -0,0 +1,29 @@
+<!-- domain:FRONTEND | layer:playbook | ssot:true | updated:{{DATE}} -->
+# Nuxt App Playbook
+
+Purpose: The recipe for adding pages, components, composables and server routes to {{PROJECT_NAME}}.
+Read when: Any frontend feature or fix in src/frontend/.
+Skip when: Backend/mobile work.
+Read next: [Nuxt Engineering Rules](../engineering/nuxt-rules.md)
+
+> Nav: [Master Index](../00-index.md)
+
+## Add a page
+
+1. Create `src/frontend/pages/<route>.vue` (`[param].vue` for dynamic segments).
+2. Fetch SSR data with `useFetch`/`useAsyncData` — never bare `$fetch` in setup.
+3. Cross-page state goes to a Pinia store; page-local state stays `ref`/`computed`.
+4. Accessibility pass per the `a11y` core skill checklist.
+5. Test: component behavior via @vue/test-utils; composables as units.
+6. Verify: `cd src/frontend && npm run lint && npm test`.
+
+## Add a server route
+
+`server/api/<name>.<method>.ts` with `defineEventHandler`; validate input
+fail-closed; errors via `createError` in the shared problem shape.
+
+## Anti-patterns
+
+- Manual vue-router wiring — file-based routing is the contract.
+- Redundant `import { ref } from 'vue'` — auto-imports own that.
+- Secrets in any file a page imports — server-only code lives in `server/`.

templates/vue-nuxt/scaffold/src/frontend/app.vue

@@ -0,0 +1,3 @@
+<template>
+  <NuxtPage />
+</template>

templates/vue-nuxt/scaffold/src/frontend/nuxt.config.ts

@@ -0,0 +1,11 @@
+// Minimal Nuxt 3 config — extend as the app grows ({{PROJECT_NAME}}).
+export default defineNuxtConfig({
+  devtools: { enabled: true },
+});
+
+// Pre-install ambient declaration so editors/tsc don't error before
+// `npm install` generates .nuxt/tsconfig (real types shadow this).
+declare global {
+  function defineNuxtConfig(config: Record<string, unknown>): Record<string, unknown>;
+}
+export {};

templates/vue-nuxt/scaffold/src/frontend/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "{{PROJECT_NAME}}-frontend",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "nuxt dev",
+    "build": "nuxt build",
+    "lint": "nuxt typecheck",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^5.0.0",
+    "@vue/test-utils": "^2.4.0",
+    "jsdom": "^24.0.0",
+    "nuxt": "^3.11.0",
+    "typescript": "^5.4.0",
+    "vitest": "^3.0.0",
+    "vue-tsc": "^2.0.0"
+  }
+}

templates/vue-nuxt/scaffold/src/frontend/pages/index.test.ts

@@ -0,0 +1,19 @@
+// {{PROJECT_NAME}} — sample page test (scaffolded {{DATE}}); see docs/playbooks/nuxt-app.md.
+import { describe, expect, it } from "vitest";
+import { mount } from "@vue/test-utils";
+
+import IndexPage from "./index.vue";
+
+describe("pages/index.vue", () => {
+  it("renders the project title in the page heading", () => {
+    const wrapper = mount(IndexPage);
+
+    expect(wrapper.find("h1").text()).toBe("{{PROJECT_NAME}}");
+  });
+
+  it("renders a single landing main region", () => {
+    const wrapper = mount(IndexPage);
+
+    expect(wrapper.findAll("main")).toHaveLength(1);
+  });
+});

templates/vue-nuxt/scaffold/src/frontend/pages/index.vue

@@ -0,0 +1,11 @@
+<script setup lang="ts">
+// {{PROJECT_NAME}} landing page — replace with the real entry.
+const title = "{{PROJECT_NAME}}";
+</script>
+
+<template>
+  <main>
+    <h1>{{ title }}</h1>
+    <p>Scaffolded by coding-os — see docs/playbooks/nuxt-app.md to add pages.</p>
+  </main>
+</template>

templates/vue-nuxt/scaffold/src/frontend/vitest.config.ts

@@ -0,0 +1,12 @@
+import vue from "@vitejs/plugin-vue";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  plugins: [vue()],
+  test: {
+    globals: true,
+    environment: "jsdom",
+    include: ["**/*.{test,spec}.{ts,tsx}"],
+    exclude: ["node_modules", ".nuxt", ".output", "dist", "build"],
+  },
+});

templates/vue-nuxt/scaffold-boundary.yaml

@@ -0,0 +1,26 @@
+# Scaffold boundary for the vue-nuxt stack.
+# Schema: docs/governance/scaffold-boundary-contract.md
+
+version: 1
+stack: vue-nuxt
+
+roots:
+  - src/frontend/
+
+file_patterns:
+  - "src/frontend/**/*.vue"
+  - "src/frontend/**/*.ts"
+  - "src/frontend/**/*.json"
+
+imports_from:
+  - src/shared/
+  - src/shared/types/
+  - src/shared/contracts/
+
+forbids_writing_in:
+  - src/backend/
+  - src/mobile/
+
+notes:
+  - "Pages own routing; composables own logic; server/api owns server-only code."
+  - "Anything imported by a page ships to the client — secrets live in server/."

templates/vue-nuxt/skills/vue-nuxt/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: vue-nuxt
+tier: stack
+domain: [frontend]
+description: Use when creating or modifying Vue/TypeScript files under src/frontend/ in a Nuxt 3 app — pages, components, composables, Pinia stores, and Nitro server routes. Triggers on any .vue or .ts change under src/frontend/. Covers file-based routing, auto-imports, SSR-safe data fetching, and composable conventions. Generic frontend principles live in the core frontend-fundamentals skill.
+globs: "src/frontend/**/*.{vue,ts}"
+depends_on:
+  - clean-code
+  - frontend-fundamentals
+  - state-management
+last_reviewed: "2026-06-11"
+---
+
+REQUIRED BACKGROUND: You MUST also follow the core `frontend-fundamentals` and `clean-code` skills. This skill adds Nuxt-3-specific conventions on top.
+
+# vue-nuxt
+
+## Routing & layout
+
+- File-based routing only — a page is a file under `pages/`; never hand-wire
+  vue-router. Dynamic segments: `pages/users/[id].vue`.
+- `app.vue` stays a shell (`<NuxtLayout><NuxtPage/></NuxtLayout>`); layouts
+  live in `layouts/`.
+
+## Auto-imports (use them, don't fight them)
+
+Components (`components/`), composables (`composables/`) and Vue/Nuxt APIs
+auto-import. NO manual `import { ref } from 'vue'` — the linter treats a
+redundant import as noise. Composables are named `useThing()` and live one
+per file.
+
+## Data fetching (SSR-safe)
+
+- `useFetch`/`useAsyncData` in pages and components — never bare `$fetch` in
+  setup (double-fetches on hydration).
+- Bare `$fetch` is correct inside event handlers and server routes.
+- Server-only secrets stay in `server/` — anything imported by a page ships
+  to the client.
+
+## State
+
+Component-local `ref`/`computed` first; cross-page state in Pinia stores
+(`stores/`, `useXStore` naming) per the state-management skill hierarchy —
+no global reactive bags.
+
+## Server routes
+
+`server/api/<name>.<method>.ts` exporting `defineEventHandler`. Validate
+input fail-closed; error responses use the shared problem shape
+(`docs/api-contracts/error-format.md`) via `createError`.
+
+## Testing
+
+- Composables: unit tests, pure functions extracted where possible.
+- Components: @vue/test-utils with minimal mounting; assert behavior, not
+  markup details.
+- Server routes: direct handler invocation with a mocked event.