exonous 0.0.0-stage → 2.10.4

package/assets/techne/skills/services/reference/nestjs.md

@@ -0,0 +1,96 @@
+# NestJS patterns
+
+## Layout
+
+```
+src/
+  main.ts
+  app.module.ts
+  common/          # filters, guards, interceptors, pipes
+  config/
+  modules/<feature>/
+    *.module.ts
+    *.controller.ts
+    *.service.ts
+    dto/
+    entities/ or repositories/
+```
+
+Feature modules own domain code; export only providers other modules need.
+
+## Bootstrap
+
+```ts
+const app = await NestFactory.create(AppModule, { bufferLogs: true });
+app.useGlobalPipes(new ValidationPipe({
+  whitelist: true,
+  forbidNonWhitelisted: true,
+  transform: true,
+  transformOptions: { enableImplicitConversion: true },
+}));
+app.useGlobalFilters(new HttpExceptionFilter());
+await app.listen(process.env.PORT ?? 3000);
+```
+
+Validate environment at startup via `ConfigModule` + schema (`validate` function).
+
+## Controllers and services
+
+Controllers: parse params/body, delegate, return response DTOs. Services hold rules and coordinate repos. Use `ParseUUIDPipe` and similar built-ins at the edge.
+
+## DTOs
+
+Request DTOs with `class-validator`; separate response DTOs / `@SerializeOptions` — never return entities with password hashes or internal columns.
+
+## Auth
+
+Module-local strategies/guards unless shared. Guards for coarse roles; services for row-level checks (`order.ownerId === user.id`).
+
+## Errors
+
+Global filter maps `HttpException` and unknown errors to one JSON shape; expected client faults use `BadRequestException`, `NotFoundException`, etc.
+
+## Persistence
+
+Repository providers wrap Prisma/TypeORM; multi-step writes live in a service method with explicit transaction API.
+
+## Tests
+
+```ts
+const moduleRef = await Test.createTestingModule({ imports: [UsersModule] }).compile();
+app = moduleRef.createNestApplication();
+app.useGlobalPipes(new ValidationPipe({ whitelist: true, transform: true }));
+await app.init();
+```
+
+Mirror production pipes/filters in tests. Unit-test services with mocked ports; e2e-test HTTP with supertest or project pattern.
+
+## Production defaults
+
+Structured logging + request id; fail boot on bad config; health checks for DB; rate limit and audit on public routes; background consumers in dedicated modules, not inside controllers.
+
+## Exception filter (consistent envelope)
+
+```ts
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  catch(err: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const res = ctx.getResponse<Response>();
+    if (err instanceof HttpException) {
+      const payload = err.getResponse();
+      return res.status(err.getStatus()).json({
+        error: typeof payload === 'string' ? { code: 'http_error', message: payload } : payload,
+      });
+    }
+    this.logger.error(err);
+    return res.status(500).json({ error: { code: 'internal_error', message: 'Internal server error' } });
+  }
+}
+```
+
+Align `code` values with `reference/api-contracts.md` so web and mobile clients share one catalog.
+
+## Module boundaries vs hexagonal
+
+Nest modules often mirror features (`UsersModule`). Treat `UsersService` as application layer only if it avoids importing `Request`/`Response`. When logic sprawls, extract plain use-case classes and keep Nest providers as adapters that delegate — see `reference/hexagonal-boundaries.md`.

package/assets/techne/skills/swift/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: swift
+description: SwiftUI engineering on Apple platforms — Observation-based state, NavigationStack routing, render performance, and Swift 6.2 approachable concurrency (@MainActor, @concurrent, isolated conformances). Use for Swift/SwiftUI features, view models, navigation, concurrency migration, or data-race fixes.
+---
+
+Engineering guidance for declarative Apple UI and modern Swift concurrency. Covers architecture and performance; platform visuals, HIG, and motion belong in the **native-ui** skill.
+
+## Non-negotiable rules
+
+1. **Observation first** — New code uses `@Observable` classes, not `ObservableObject` / `@Published` / `@StateObject` / `@EnvironmentObject`.
+2. **Minimal wrappers** — `@State` for view-owned values; `@Binding` for parent two-way links; `@Bindable` for observable two-way fields; `@Environment(Type.self)` for injected services.
+3. **Small view structs** — Extract subviews so invalidation stays local; avoid `AnyView`; prefer `@ViewBuilder` / `Group` for conditionals.
+4. **No work in `body`** — Network, disk, and heavy CPU stay out of `body` and `init`; load with `.task` (auto-cancel on disappear) or explicit async entry points.
+5. **Type-safe navigation** — `NavigationStack` + `NavigationPath` (or bound path) with `Hashable` destinations and `.navigationDestination(for:)`.
+6. **List performance** — `LazyVStack` / lazy stacks in scroll views; `ForEach` with stable IDs, never raw indices; limit shadows/blur/mask in scrolling content.
+7. **Swift 6.2 default** — `async` stays on the **calling actor** unless you explicitly offload; do not assume background execution.
+8. **`@concurrent` sparingly** — Only after Instruments shows CPU-bound hotspots; mark container `nonisolated`, function `@concurrent`, callers `await`.
+9. **MainActor for UI domain** — View models, shared singletons, and global mutable app state belong on `@MainActor` (or MainActor default inference for app targets).
+10. **Isolated conformances** — Prefer `@MainActor` protocol conformances over `nonisolated` hacks or unsafe type erasure when UI types implement shared protocols.
+11. **Sendable at boundaries** — Data crossing actors/tasks must satisfy isolation rules; treat compiler data-race diagnostics as real bugs.
+12. **Previews with fakes** — `#Preview` variants with injected mock repositories/services for empty, loading, and populated states.
+13. **Design vs engineering** — Layout polish, SF Symbols usage, platform chrome → **native-ui**; structural code → **atlas** MCP; API docs → **biblos** MCP.
+
+## References
+
+| File | Load when |
+|------|-----------|
+| [reference/swiftui.md](reference/swiftui.md) | Composing views, state wiring, navigation router, list/chart performance, preview setup |
+| [reference/concurrency.md](reference/concurrency.md) | Migrating to Swift 6.2, fixing isolation errors, `@concurrent` offload, globals and protocol conformances |

package/assets/techne/skills/swift/reference/concurrency.md

@@ -0,0 +1,83 @@
+# Swift 6.2 concurrency
+
+Approachable Concurrency keeps most code on one actor until you opt into parallelism. Enable features incrementally in Xcode build settings or SPM `SwiftSettings` (MainActor default inference, nonisolated-nonsending-by-default).
+
+## Calling actor stays put
+
+Earlier runtimes could hop threads implicitly inside `async` work on `@MainActor` types, surfacing false-positive send errors. Swift 6.2 keeps continuation on the caller’s executor unless you mark otherwise:
+
+```swift
+@MainActor
+final class ImportModel {
+    let pipeline = ImagePipeline()
+
+    func buildSticker(from pickerItem: PhotosPickerItem) async throws -> Sticker? {
+        guard let payload = try await pickerItem.loadTransferable(type: Data.self) else { return nil }
+        return await pipeline.renderSticker(payload, id: pickerItem.itemIdentifier)
+    }
+}
+```
+
+## Isolated protocol conformances
+
+UI-bound types can conform without erasing isolation:
+
+```swift
+protocol Exporting { func exportPNG() }
+
+extension ImportModel: @MainActor Exporting {
+    func exportPNG() { pipeline.flushPNG() }
+}
+```
+
+Using that conformance from a nonisolated store fails at compile time — intentional.
+
+## Globals and shared caches
+
+Annotate process-wide mutable singletons with `@MainActor`:
+
+```swift
+@MainActor
+final class AssetCache {
+    static let shared = AssetCache()
+}
+```
+
+With **MainActor default inference** (recommended for app executables), class members inherit main-actor isolation without repeating annotations.
+
+## Explicit background work
+
+Requirements: approachable-concurrency flags enabled (otherwise the sample below races).
+
+```swift
+nonisolated final class ImagePipeline {
+    private var memo: [String: Sticker] = [:]
+
+    func renderSticker(_ data: Data, id: String?) async -> Sticker {
+        if let id, let hit = memo[id] { return hit }
+        let sticker = await Self.segmentSubject(from: data)
+        if let id { memo[id] = sticker }
+        return sticker
+    }
+
+    @concurrent
+    static func segmentSubject(from data: Data) async -> Sticker { /* CPU work */ }
+}
+```
+
+Steps to offload: container `nonisolated`, hot function `@concurrent` + `async`, call sites `await`.
+
+## Migration checklist
+
+1. Turn on Swift 6 language mode concurrency checks.
+2. Enable MainActor inference for app targets first.
+3. Fix globals and protocol conformances with isolation, not suppression.
+4. Profile, then add `@concurrent` on proven CPU bottlenecks (decode, compression, layout solvers).
+5. Re-run tests — many races become build failures instead of heisenbugs.
+
+## Avoid
+
+- Sprinkling `@concurrent` on every `async` function.
+- `nonisolated` solely to silence diagnostics.
+- Legacy `DispatchQueue` patterns where actors express the same contract more clearly.
+- Assuming all `async` calls run off the main thread.

package/assets/techne/skills/swift/reference/swiftui.md

@@ -0,0 +1,139 @@
+# SwiftUI structure and performance
+
+## State and view models
+
+Track mutations at property granularity with `@Observable`:
+
+```swift
+@Observable
+final class CatalogModel {
+    private(set) var entries: [Entry] = []
+    private(set) var busy = false
+    var filter = ""
+    private let gateway: any CatalogGateway
+
+    init(gateway: any CatalogGateway = LiveCatalogGateway()) {
+        self.gateway = gateway
+    }
+
+    func refresh() async {
+        busy = true
+        defer { busy = false }
+        entries = (try? await gateway.load()) ?? []
+    }
+}
+```
+
+Host owned models with `@State` on the root screen:
+
+```swift
+struct CatalogScreen: View {
+    @State private var model: CatalogModel
+
+    init(model: CatalogModel = CatalogModel()) {
+        _model = State(initialValue: model)
+    }
+
+    var body: some View {
+        List(model.entries) { row in EntryRow(entry: row) }
+            .searchable(text: $model.filter)
+            .overlay { if model.busy { ProgressView() } }
+            .task { await model.refresh() }
+    }
+}
+```
+
+Inject shared services via environment:
+
+```swift
+RootTabs()
+    .environment(sessionCoordinator)
+
+struct AccountPane: View {
+    @Environment(SessionCoordinator.self) private var session
+    var body: some View { Text(session.displayName ?? "Signed out") }
+}
+```
+
+## Composition
+
+Pass only the data each child reads:
+
+```swift
+struct CheckoutScreen: View {
+    @State private var model = CheckoutModel()
+    var body: some View {
+        VStack {
+            CheckoutHeader(title: model.title)
+            LineItemStack(items: model.lines)
+            CheckoutFooter(total: model.grandTotal)
+        }
+    }
+}
+```
+
+Reusable chrome via modifiers:
+
+```swift
+struct PanelChrome: ViewModifier {
+    func body(content: Content) -> some View {
+        content.padding().background(.regularMaterial)
+            .clipShape(RoundedRectangle(cornerRadius: 12))
+    }
+}
+extension View { func panelChrome() -> some View { modifier(PanelChrome()) } }
+```
+
+## Navigation
+
+Centralize path mutations:
+
+```swift
+@Observable
+final class AppRouter {
+    var stack = NavigationPath()
+    func open(_ target: Screen) { stack.append(target) }
+    func reset() { stack = NavigationPath() }
+}
+
+enum Screen: Hashable {
+    case detail(UUID)
+    case preferences
+}
+
+struct ShellView: View {
+    @State private var router = AppRouter()
+    var body: some View {
+        NavigationStack(path: $router.stack) {
+            HubView()
+                .navigationDestination(for: Screen.self) { screen in
+                    switch screen {
+                    case .detail(let id): DetailPane(id: id)
+                    case .preferences: PreferencesPane()
+                    }
+                }
+        }
+        .environment(router)
+    }
+}
+```
+
+## Performance tactics
+
+- Lazy stacks inside `ScrollView` for long content.
+- `Equatable` on expensive leaf views when inputs are equatable — compare only fields that affect rendering.
+- Avoid expensive effects in cells; prefer `.geometryGroup()` and haptics outside fast scroll regions when needed.
+
+```swift
+ScrollView {
+    LazyVStack(spacing: 8) {
+        ForEach(rows, id: \.persistentKey) { row in RowView(row: row) }
+    }
+}
+```
+
+## Avoid
+
+- Child-owned `@State` view models for data the parent already owns — pass the model down.
+- Legacy observation wrappers in greenfield code.
+- Async side effects directly inside `body`.

package/assets/techne/skills/vue/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: vue
+description: Vue 3 Composition API, Pinia, Vue Router, Nuxt 4 SSR/hydration, and screenshot-to-Vue conversion flows. Use for `.vue` SFCs, composables, Nuxt data fetching, route rules, or batch UI imports (Vant, Element Plus, Ant Design Vue).
+---
+
+Vue 3 with `<script setup>`: feature-oriented folders, composables over mixins, Pinia for shared state, and Nuxt-aware SSR. **techne:web** covers Vite/Bun/SEO shared ground; **ui-design** for a11y polish; **biblos** for API details; **techne:quality** for Playwright E2E.
+
+## Non-negotiable rules
+
+1. **`<script setup lang="ts">` for new code** — ordered blocks: imports → props/emits → composables → state → computed → methods → watchers → lifecycle.
+2. **Composables start with `use`**, accept `MaybeRef` inputs, return refs/computed, and tear down in `onUnmounted` / watcher cleanup.
+3. **Never mutate props** — emit events or use `defineModel()` / `v-model`.
+4. **Stable `:key` on `v-for`** — entity ids, not array index; filter lists in computed, not `v-if` + `v-for` on one node.
+5. **Pinia setup stores** — async actions expose loading/error; prefer actions over scattered `$patch` for business rules.
+6. **Lazy routes** via dynamic `import()` for non-critical pages; `v-show` for frequent toggles, `v-if` for rare mounts.
+7. **Nuxt: `await useFetch` / `useAsyncData` for SSR page data** — not bare top-level `$fetch`; stable cache keys; side-effect-free fetch handlers.
+8. **Hydration-safe first paint** — no `Date.now()`, random, or `localStorage` in SSR templates; use `ClientOnly`, `.client.vue`, or `onMounted`.
+9. **Use `useRoute()` from Nuxt in Nuxt apps** — not vue-router's import; avoid `route.fullPath` driving SSR markup (fragments are client-only).
+10. **`routeRules` per segment** — prerender marketing, SWR/ISR catalogs, `ssr: false` only for true client-only areas.
+11. **Sanitize before `v-html`** — user HTML is XSS risk; prefer text bindings.
+12. **Screenshot conversion sends images to external APIs** — get permission, pin tool version, never commit keys or customer assets; review generated code before merge.
+
+## References
+
+| File | Load when |
+|------|-----------|
+| [reference/vue-patterns.md](reference/vue-patterns.md) | Project layout, SFC architecture, Pinia, router, Vue 3.5 APIs, testing |
+| [reference/nuxt4-patterns.md](reference/nuxt4-patterns.md) | Hydration, `useFetch`, route rules, lazy components and hydration |
+| [reference/ui-to-vue.md](reference/ui-to-vue.md) | Batch design screenshot → Vue with component libraries |

package/assets/techne/skills/vue/reference/nuxt4-patterns.md

@@ -0,0 +1,90 @@
+# Nuxt 4 SSR & routing
+
+Build/debug Nuxt 4 with hybrid rendering, payload discipline, and hydration-safe UI.
+
+## Hydration safety
+
+First server and client render must match.
+
+- No `Date.now()`, `Math.random()`, `window`, or storage reads in SSR template state.
+- Defer browser-only work: `onMounted`, `import.meta.client`, `<ClientOnly>`, `*.client.vue`.
+- In Nuxt apps use **`useRoute()` from `#app`**, not a direct `vue-router` import.
+- Do not drive SSR markup from `route.fullPath` (hash is client-only).
+- `ssr: false` route rule is last resort for truly client-only surfaces—not a default mismatch fix.
+
+## Data fetching
+
+| API | When |
+|-----|------|
+| `await useFetch(url)` | Standard SSR read; hydrates from payload |
+| `await useAsyncData(key, fn)` | Custom fetcher, composed sources, explicit cache key |
+| `$fetch` in handlers | User actions, mutations, client-only reads |
+| `lazy: true` / `useLazyFetch` | Non-blocking; show `pending` UI |
+| `server: false` | Data not needed for SEO/first paint |
+
+Handlers must be side-effect free (run on server + hydration). Trim payload with `pick`; avoid deep reactivity when unnecessary.
+
+```typescript
+const route = useRoute()
+
+const { data: article, status, refresh } = await useAsyncData(
+  () => `article:${route.params.slug}`,
+  () => $fetch(`/api/articles/${route.params.slug}`),
+)
+
+const { data: comments } = await useFetch(
+  `/api/articles/${route.params.slug}/comments`,
+  { lazy: true, server: false },
+)
+```
+
+## routeRules
+
+Configure in `nuxt.config.ts` by path pattern:
+
+```typescript
+export default defineNuxtConfig({
+  routeRules: {
+    '/': { prerender: true },
+    '/products/**': { swr: 3600 },
+    '/blog/**': { isr: true },
+    '/admin/**': { ssr: false },
+    '/api/**': { cache: { maxAge: 3600 } },
+  },
+})
+```
+
+| Rule | Effect |
+|------|--------|
+| `prerender` | Static HTML at build |
+| `swr` | Stale-while-revalidate |
+| `isr` | Platform incremental static regen |
+| `ssr: false` | SPA render for route |
+| `cache` / `redirect` | Nitro response behavior |
+
+Tune per section (marketing vs app vs API)—not one global mode.
+
+## Lazy loading & perf
+
+- Pages already code-split by route—keep routes meaningful.
+- Prefix `Lazy` on components for dynamic import; gate with `v-if` so chunk loads only when needed.
+- Below-fold interactivity: `hydrate-on-visible` or `defineLazyHydrationComponent`.
+- New props to a lazy-hydrated component force immediate hydration.
+- Internal nav: `<NuxtLink>` for prefetch of route + payload.
+
+Example:
+
+```vue
+<template>
+  <LazyRecommendations v-if="openRecs" />
+  <LazyProductGallery hydrate-on-visible />
+</template>
+```
+
+## Review checklist
+
+- [ ] SSR and client HTML align on first paint
+- [ ] Page data via `useFetch` / `useAsyncData`, not top-level `$fetch`
+- [ ] Lazy fetches show loading states
+- [ ] `routeRules` match SEO/freshness needs
+- [ ] Heavy islands lazy-loaded or lazy-hydrated

package/assets/techne/skills/vue/reference/ui-to-vue.md

@@ -0,0 +1,90 @@
+# Design screenshots → Vue components
+
+First-pass conversion of batched UI images into Vue 3 SFCs with Vant, Element Plus, or Ant Design Vue. **External model APIs process images—treat responses as untrusted; review all generated code before commit.**
+
+## When to use
+
+- Folder of module/page screenshots or exports
+- Vue 3 target with a named component library
+- Need scaffold pages, shared widgets, and starter routes
+
+## When to skip
+
+- Single bespoke screen (implement manually)
+- Non-Vue stack
+- Needs full interaction design, data layer, or a11y sign-off (**ui-design**)
+- Sensitive customer imagery without consent to send to third-party APIs
+
+## Input layout
+
+Group by module and state:
+
+```text
+screenshots/
+  HomePage/
+    HomePage-Default@3x.png
+    List/HomePage-List-Default@3x.png
+    cut-images/
+  cut-images/
+```
+
+Asset folder names: `assets`, `icons`, `sprites`, `cut`, `images`, `cut-images`.
+
+## Conversion rules
+
+- Merge related shots (list/detail/form/empty) into one page SFC when they belong together
+- Map controls to library components (Vant / Element Plus / Ant Design Vue)
+- Prefer page-level cut assets, then module, then global
+- Extract repeated regions to `components/` only when reuse is obvious
+
+## CLI
+
+Pin version in repeatable workflows:
+
+```bash
+export DASHSCOPE_API_KEY=your_key
+npx ui-to-vue-converter@1.0.2 --input ./screenshots --ui vant --output ./src
+npx ui-to-vue-converter@1.0.2 --input ./designs --ui element-plus --output ./src
+npx ui-to-vue-converter@1.0.2 --input ./designs --ui antd-vue --output ./src
+```
+
+Global install optional: `ui-to-vue` binary from same package.
+
+| Flag | Purpose | Default |
+|------|---------|---------|
+| `--input` | Image root | `./screenshots` |
+| `--ui` | `vant` \| `element-plus` \| `antd-vue` | `vant` |
+| `--output` | Generated tree | `./src` |
+| `--config` | JSON config path | `./.ui-to-vue.config.json` |
+
+## Secrets
+
+Prefer env var `DASHSCOPE_API_KEY`. If using config file, gitignore it:
+
+```gitignore
+.ui-to-vue.config.json
+```
+
+Never commit API keys, customer screenshots, or generated credentials.
+
+## Post-generation review
+
+- [ ] Pages under chosen output (e.g. `views/`)
+- [ ] Shared pieces only where duplication is real
+- [ ] Router matches project style (Vue Router vs Nuxt pages)
+- [ ] Library imports consistent with `--ui`
+- [ ] CSS units match design baseline
+- [ ] Formatter, linter, `vue-tsc`, and build pass
+- [ ] Placeholder copy and mock data replaced
+
+## Troubleshooting
+
+| Symptom | Check |
+|---------|--------|
+| 401 | `DASHSCOPE_API_KEY` in shell running CLI |
+| Command missing | Use `npx ui-to-vue-converter@1.0.2` |
+| Assets skipped | Supported folder name under correct page/module |
+| Wrong library | Explicit `--ui`; inspect imports |
+| Layout scale off | Screenshot width vs library baseline |
+
+npm package name: `ui-to-vue-converter`.