rsc-universal 0.1.1

package/skills/svelte/references/sveltekit-data.md

@@ -0,0 +1,156 @@
+# SvelteKit data loading, mutations, remote functions, and hooks
+
+Current as of June 2026: SvelteKit 2.61.x.
+
+## Universal vs server `load`
+
+| | Universal (`+page.ts`, `+layout.ts`) | Server (`+page.server.ts`, `+layout.server.ts`) |
+| --- | --- | --- |
+| Runs on | server during SSR **and** browser on client nav | server only |
+| Can touch | public APIs, `$env/static/public`, `fetch` | DB clients, secrets, `$env/static/private`, filesystem, cookies |
+| Return value | any JS value (functions, classes ok) | must be serializable (devalue: Dates, Maps, etc. — no functions/classes) |
+| Can stream | no | yes (top-level promises) |
+
+If both exist for the same route, the server `load` runs first and its data is passed to the universal `load` via the `data` argument.
+
+```ts
+// +layout.server.ts
+import type { LayoutServerLoad } from './$types';
+export const load: LayoutServerLoad = async ({ locals }) => ({ user: locals.user });
+```
+
+## `parent()` and dependency tracking
+
+```ts
+import type { PageLoad } from './$types';
+export const load: PageLoad = async ({ parent, fetch }) => {
+  const { user } = await parent();          // merge in ancestor load data
+  const res = await fetch(`/api/feed/${user.id}`);
+  return { feed: await res.json() };
+};
+```
+
+- `depends('app:feed')` registers a custom invalidation key; `depends` also auto-tracks any `fetch(url)` and accessed `params`/`url`.
+- Re-run: `invalidate('app:feed')` (custom key), `invalidate('/api/feed')` (URL), `invalidate(url => url.pathname.startsWith('/api'))` (predicate), or `invalidateAll()`.
+
+## Streaming
+
+Return a non-awaited promise at the top level of a **server** `load`; the page shell renders immediately and the data resolves later.
+
+```ts
+// +page.server.ts
+export const load = async () => ({
+  meta: await getMeta(),          // awaited — blocks the response
+  slowList: getSlowList(),        // promise — streamed
+});
+```
+
+```svelte
+{#await data.slowList}
+  <Spinner />
+{:then list}
+  …
+{:catch err}
+  <p>{err.message}</p>
+{/await}
+```
+
+## Form actions
+
+Live in `+page.server.ts`. The default action is `<form method="POST">`; named actions use `action="?/login"` and `export const actions = { login, logout }`.
+
+```ts
+import { fail, redirect } from '@sveltejs/kit';
+import type { Actions } from './$types';
+
+export const actions: Actions = {
+  default: async ({ request }) => {
+    const data = await request.formData();
+    const title = String(data.get('title') ?? '').trim();
+    if (!title) return fail(422, { title, error: 'Title required' }); // returned as `form`
+    await save({ title });
+    throw redirect(303, '/done');
+  },
+};
+```
+
+`fail(status, data)` returns serializable data to the page's `form` prop (keep the user's input so the form repopulates). `redirect` and `error` are thrown, not returned.
+
+### `use:enhance`
+
+Bare `use:enhance` gives no-reload submit + automatic `form`/`data` update + focus management. Customize without losing the defaults:
+
+```svelte
+<script lang="ts">
+  import { enhance } from '$app/forms';
+  let submitting = $state(false);
+</script>
+
+<form method="POST" use:enhance={() => {
+  submitting = true;
+  return async ({ update }) => {
+    await update();        // apply the default result handling
+    submitting = false;
+  };
+}}>
+  <button disabled={submitting}>Save</button>
+</form>
+```
+
+## Remote functions (EXPERIMENTAL)
+
+Available since SvelteKit 2.27, iterated through 2.61. API is subject to change. Opt in with **both** flags — `kit.experimental.remoteFunctions` enables the feature, and `compilerOptions.experimental.async` enables the top-level `await` it relies on. Omit either and remote functions stay off:
+
+```js
+// svelte.config.js
+export default {
+  kit: { experimental: { remoteFunctions: true } },
+  compilerOptions: { experimental: { async: true } },
+};
+```
+
+Functions live in `*.remote.ts`. Four kinds:
+
+```ts
+// data.remote.ts
+import { query, form, command, prerender } from '$app/server';
+
+export const getPosts = query(async () => db.post.all());          // cached server read
+export const getPost  = query('unchecked', async (id: string) => db.post.find(id)); // with arg
+
+export const createPost = form(async (data: FormData) => {          // progressive, parses FormData
+  const title = String(data.get('title') ?? '');
+  return db.post.create({ title });
+});
+
+export const like = command(async (id: string) => db.post.like(id)); // mutation, requires JS
+
+export const docs = prerender(async () => loadStaticDocs());        // build-time
+```
+
+In a component, `query`/`prerender` return an awaitable with reactive state (`getPosts().current`, `.loading`, `.error`); `form` exposes props to spread onto a `<form>`; `command` is called imperatively (no form, JS required). Prefer plain form actions unless you specifically need imperative mutations or co-located queries.
+
+## Hooks
+
+```ts
+// hooks.server.ts
+import type { Handle, HandleFetch } from '@sveltejs/kit';
+
+export const handle: Handle = async ({ event, resolve }) => {
+  event.locals.user = await getUser(event.cookies.get('session'));
+  return resolve(event);
+};
+
+export const handleFetch: HandleFetch = async ({ request, fetch }) => {
+  // rewrite/relabel outbound fetch (e.g. internal URL, auth header)
+  return fetch(request);
+};
+```
+
+`handle` wraps every request (auth, headers, `locals`). `handleFetch` intercepts `fetch` calls made inside `load`. `handleError` shapes uncaught errors before they reach `+error.svelte`.
+
+## Errors and redirects
+
+- `error(404, 'Not found')` (thrown) → renders the nearest `+error.svelte` with `page.error`.
+- `redirect(303, '/login')` (thrown) → HTTP redirect; use 303 after a POST.
+- A `load` that throws an unexpected error triggers `handleError` then `+error.svelte`.

package/skills/svelte/scripts/verify.sh

@@ -0,0 +1,128 @@
+#!/usr/bin/env bash
+# verify.sh — Svelte 5 / SvelteKit project gate.
+#
+# Usage:
+#   bash scripts/verify.sh            # run from the SvelteKit project root
+#
+# What it does (in order): svelte-check -> tsc --noEmit -> Vitest -> vite build.
+# Each tool is detected; if it is not installed/resolvable it is SKIPPED with a
+# yellow warning (NOT a failure). Exits non-zero only on a real tool failure, so
+# an empty or tooling-free directory exits 0.
+#
+# Side effects: svelte-check, tsc and the test run are read-only. The final
+# `vite build` WRITES the build output dir (`.svelte-kit/output`, `build/`) and
+# may write `.svelte-kit/` type stubs — it is NOT a pure read-only step. It does
+# no installs and no network mutations. Safe to re-run.
+#
+# Portability: targets stock macOS bash 3.2. No `mapfile`, no empty-array
+# expansion under `set -u`, graceful skip when a tool is missing. `set -e` is
+# intentionally NOT used (each check owns its exit code); `set -u` is on.
+
+set -u
+
+# --- colors (only when stdout is a TTY) -----------------------------------
+if [ -t 1 ] && command -v tput >/dev/null 2>&1; then
+  RED="$(tput setaf 1)"; GREEN="$(tput setaf 2)"; YELLOW="$(tput setaf 3)"; RESET="$(tput sgr0)"
+else
+  RED=""; GREEN=""; YELLOW=""; RESET=""
+fi
+
+failures=0
+# Space-separated list (portable to bash 3.2; avoids empty-array expansion under set -u).
+skips=""
+
+have() { command -v "$1" >/dev/null 2>&1; }
+warn() { printf '%s\n' "${YELLOW}SKIP: $1${RESET}"; skips="${skips}${skips:+ }$2"; return 0; }
+fail() { printf '%s\n' "${RED}FAIL: $1${RESET}"; failures=$((failures + 1)); }
+ok()   { printf '%s\n' "${GREEN}OK: $1${RESET}"; }
+
+# --- resolve a package runner from the lockfile ----------------------------
+RUN=""
+if [ -f pnpm-lock.yaml ] && have pnpm; then
+  RUN="pnpm exec"
+elif [ -f yarn.lock ] && have yarn; then
+  RUN="yarn"
+elif [ -f package-lock.json ] && have npm; then
+  RUN="npm exec --"
+elif have npx; then
+  RUN="npx --no-install"
+fi
+
+run_bin() {
+  # run_bin <bin-name> <args...> : true if the bin is resolvable and runs
+  bin="$1"; shift
+  if have "$bin"; then "$bin" "$@"; return $?; fi
+  if [ -x "node_modules/.bin/$bin" ]; then "node_modules/.bin/$bin" "$@"; return $?; fi
+  if [ -n "$RUN" ]; then $RUN "$bin" "$@"; return $?; fi
+  return 127
+}
+
+bin_available() {
+  bin="$1"
+  have "$bin" && return 0
+  [ -x "node_modules/.bin/$bin" ] && return 0
+  return 1
+}
+
+# --- 0. bail early on a non-SvelteKit / empty directory --------------------
+# No package.json at all → nothing to verify; succeed (don't false-fail an
+# empty or clean target).
+if [ ! -f package.json ]; then
+  printf '%s\n' "${YELLOW}no package.json here — nothing to verify${RESET}"
+  printf '%s\n' "${GREEN}verify.sh: all runnable checks passed${RESET}"
+  exit 0
+fi
+
+# --- 1. svelte-check (type + template diagnostics) -------------------------
+if bin_available svelte-check; then
+  printf '%s\n' "Running svelte-check..."
+  if run_bin svelte-check --threshold error; then ok "svelte-check"; else fail "svelte-check"; fi
+else
+  warn "svelte-check not resolvable — skipping template/type diagnostics" "svelte-check"
+fi
+
+# --- 2. TypeScript ---------------------------------------------------------
+if bin_available tsc && [ -f tsconfig.json ]; then
+  printf '%s\n' "Running tsc --noEmit..."
+  if run_bin tsc --noEmit; then ok "tsc --noEmit"; else fail "tsc --noEmit"; fi
+else
+  warn "tsc or tsconfig.json missing — skipping type check" "tsc"
+fi
+
+# --- 3. Vitest -------------------------------------------------------------
+# Treat the repo as having unit tests when a vitest config exists OR `*.test.*`
+# files exist. (SvelteKit scaffolds use Vitest for unit tests.)
+has_tests=false
+if ls vitest.config.* vitest.workspace.* >/dev/null 2>&1; then
+  has_tests=true
+elif find . \( -name node_modules -o -name .svelte-kit -o -name build -o -name dist \) -prune -o \
+       -name '*.test.*' -print 2>/dev/null | grep -q .; then
+  has_tests=true
+fi
+if bin_available vitest && [ "$has_tests" = true ]; then
+  printf '%s\n' "Running vitest run..."
+  if run_bin vitest run; then ok "vitest"; else fail "vitest"; fi
+else
+  warn "vitest or unit tests (vitest.config.* / *.test.*) not present — skipping unit tests" "vitest"
+fi
+
+# --- 4. vite build (slow; WRITES build output; run last) -------------------
+# SvelteKit builds through Vite. Skip (not fail) if vite is unresolvable.
+if bin_available vite; then
+  printf '%s\n' "Running vite build... (writes .svelte-kit/output and the adapter output dir)"
+  if run_bin vite build; then ok "vite build"; else fail "vite build"; fi
+else
+  warn "vite not resolvable — skipping build" "vite build"
+fi
+
+# --- summary ---------------------------------------------------------------
+printf '\n'
+if [ -n "$skips" ]; then
+  printf '%s\n' "${YELLOW}skipped: ${skips}${RESET}"
+fi
+if [ "$failures" -gt 0 ]; then
+  printf '%s\n' "${RED}verify.sh: $failures check(s) failed${RESET}"
+  exit 1
+fi
+printf '%s\n' "${GREEN}verify.sh: all runnable checks passed${RESET}"
+exit 0

package/skills/swift-ios/SKILL.md

@@ -0,0 +1,217 @@
+---
+name: swift-ios
+description: "Use when building native iOS / Apple-platform apps in Swift with SwiftUI and modern Swift concurrency — designing @Observable view models, fixing Swift 6 strict data-race diagnostics, modeling async/await + actors, persisting with SwiftData, navigating with NavigationStack, or testing with Swift Testing. Triggers: 'native iOS app in SwiftUI', 'non-Sendable type crosses actor boundary', 'main actor-isolated property cannot be referenced from a nonisolated context', 'should this be an actor or @MainActor', '@Observable vs ObservableObject', '#expect vs XCTAssert', 'SwiftData @Model @Query', 'app nativa de iOS con SwiftUI i concurrència', 'liquid glass iOS 26'. NOT cross-platform Dart (that is flutter), NOT React Native (that is react-native), NOT native Kotlin/Android (that is kotlin-android), NOT shared KMP code across both OSes (that is compose-multiplatform)."
+tags: [swift, swiftui, ios, swift-concurrency, swiftdata, swift-testing, apple]
+recommends: [kotlin-android, compose-multiplatform, flutter, react-native, expo, testing-web, github-actions, ship]
+profiles: []
+origin: risco
+---
+
+# swift-ios
+
+Native Apple-platform apps: the code is `.swift`, the UI is SwiftUI, and the compiler enforces actor isolation. If the answer is a `@MainActor`, `@Observable`, `async let`, `#expect`, `NavigationStack`, or `@Model`, you are in the right place.
+
+## First move: match the project before you write a line
+
+Mismatched language modes produce diagnostics you cannot reproduce and "fixes" that break the user's build. Pin the ground truth first.
+
+```bash
+swift --version                               # exact toolchain
+xcodebuild -version                           # Xcode version
+# In the .xcodeproj / Package.swift, read two settings per target:
+#   SWIFT_VERSION (Swift Language Version: 5 or 6)
+#   SWIFT_DEFAULT_ACTOR_ISOLATION (Default Actor Isolation: nonisolated or MainActor)
+```
+
+Assumed baseline: **Xcode 26 / Swift 6.2 / iOS 26 SDK** (current stable seen is Xcode 26.2 / Swift 6.2.3). Do not quote a version you have not confirmed in the user's project. Rule: **write for the target's actual language mode.** Swift 5-mode code dropped into a Swift 6 target (or vice-versa) is the most common source of "it compiles on my machine" failures.
+
+## State & view architecture
+
+For new code use `@Observable` (the Observation framework), never `ObservableObject` / `@Published`. Why: Observation tracks per-property — a view re-renders only when a property it actually reads changes, not on every object mutation.
+
+| Property wrapper | Use it when | One-line why |
+| --- | --- | --- |
+| `@State` | The view *owns* a value or an `@Observable` instance | Lifecycle tied to the view; survives re-renders |
+| `@Binding` | A child needs write access to a parent's value | Passes a mutable reference down, no ownership |
+| `@Bindable` | You need two-way bindings *into* an `@Observable` | Produces `$model.field` for `TextField` etc. |
+| `@Environment` | Dependency injection of a shared `@Observable` | One source of truth, no prop-drilling |
+
+`@Observable` gives you **zero** thread safety. Mutating an observed property off the main actor races the UI. Annotate UI models `@MainActor`.
+
+```swift
+// Bad — legacy pattern, whole-object invalidation, no isolation
+final class CounterModel: ObservableObject {
+    @Published var count = 0
+}
+
+// Good — per-property tracking, main-actor isolated
+@MainActor @Observable
+final class CounterModel {
+    var count = 0
+}
+
+struct CounterView: View {
+    @State private var model = CounterModel()      // view owns it
+    var body: some View {
+        Stepper("\(model.count)", value: $model.count)  // @State gives bindings to @Observable
+    }
+}
+```
+
+## Concurrency correctness (the core)
+
+The mental model: SwiftUI runs on the main actor. Anything that touches UI state is main-actor work. Background work hops off, then hops back to mutate.
+
+- **`@MainActor` class** for UI/view-model state — it *is* the UI thread.
+- **`actor`** for shared *non-UI* mutable state (a cache, a connection pool). Never model a SwiftUI view model as an `actor` — actors are reentrant and not main-bound, so your UI updates land off-main.
+- **`Task { }`** inherits the current actor + priority — use it to fire async work from a `Button`. **`Task.detached`** inherits nothing and is almost never what you want; reaching for it to silence a warning is a bug, not a fix.
+- **`async let` / `TaskGroup`** for structured parallelism (fan out, then `await` all).
+- **Cancellation is mandatory**: check `Task.isCancelled` or `try Task.checkCancellation()` in loops. SwiftUI's `.task {}` auto-cancels when the view disappears — prefer it over a bare `Task {}` for view-lifetime work.
+
+The #1 footgun — mutating observed UI state off the main actor:
+
+```swift
+// Bad — detached task mutates main-isolated state; intermittent glitches + Swift 6 data-race warning
+@MainActor @Observable final class Feed {
+    var items: [Item] = []
+    func load() {
+        Task.detached {
+            let data = try? await API.fetch()
+            self.items = data ?? []          // off-main mutation: WRONG
+        }
+    }
+}
+
+// Good — Task {} inherits the main actor; await off-main work, mutation lands on-main
+@MainActor @Observable final class Feed {
+    var items: [Item] = []
+    func load() async {
+        do {
+            items = try await API.fetch()    // await suspends; assignment is back on main
+        } catch is CancellationError {
+            // view disappeared — nothing to do
+        } catch {
+            // surface error
+        }
+    }
+}
+// In the view: .task { await feed.load() }   // auto-cancels on disappear
+```
+
+Escape hatch for UI-centric apps: set **Default Actor Isolation = MainActor** (SE-0466) on the target — unannotated code becomes main-actor-isolated by default, killing false-positive data-race warnings; you opt *out* with `nonisolated` only where you genuinely need it. The full diagnostic catalog, Sendable rules, and the staged Swift 6 migration live in [references/concurrency.md](references/concurrency.md).
+
+## Persistence
+
+| Choice | Use when |
+| --- | --- |
+| **SwiftData** (default) | New SwiftUI apps; relational/object graph; light-to-moderate migration needs |
+| Core Data | Advanced/custom migrations, mature `NSPersistentCloudKit` edge cases |
+| Files (`Codable` → disk) | Trivial, non-relational blobs only |
+
+```swift
+import SwiftData
+
+@Model final class Workout {
+    var name: String
+    var minutes: Int
+    init(name: String, minutes: Int) { self.name = name; self.minutes = minutes }
+}
+
+// App entry: attach the container once
+WindowGroup { ContentView() }.modelContainer(for: Workout.self)
+
+// In a view: query + mutate
+struct ListView: View {
+    @Query(sort: \Workout.name) private var workouts: [Workout]
+    @Environment(\.modelContext) private var context
+    var body: some View {
+        List(workouts) { Text($0.name) }
+            .toolbar { Button("Add") { context.insert(Workout(name: "Run", minutes: 30)) } }
+    }
+}
+```
+
+Bad: hand-rolling JSON-to-disk for relational data with cross-references. Good: model the relationship with `@Model` and let SwiftData own identity and autosave.
+
+## Navigation
+
+Use `NavigationStack` with a value-typed `path` + `navigationDestination(for:)` — type-safe, programmatic, and deep-linkable. `NavigationView` is deprecated.
+
+```swift
+// Bad
+NavigationView { List(items) { NavigationLink(item.name, destination: DetailView(item: item)) } }
+
+// Good — push by value, deep-link by mutating the path
+@State private var path: [Item] = []
+NavigationStack(path: $path) {
+    List(items) { item in NavigationLink(item.name, value: item) }
+        .navigationDestination(for: Item.self) { DetailView(item: $0) }
+}
+// Deep link: path = [parent, child]
+```
+
+Use `NavigationSplitView` for iPad/Mac multi-column layouts.
+
+## Testing
+
+Swift Testing is the default (Xcode 16+, matured through Xcode 26): `@Test`, `#expect` (soft — keeps running), `#require` (hard — throws/unwraps), `@Test(arguments:)` for parameterized cases, `@Suite` types, parallel + in-process by default.
+
+```swift
+import Testing
+@testable import MyApp
+
+@Suite struct ScoreTests {
+    @Test func startsAtZero() { #expect(Score().value == 0) }
+
+    @Test(arguments: [1, 2, 3]) func adds(_ n: Int) {
+        var s = Score(); s.add(n)
+        #expect(s.value == n)
+    }
+
+    @Test func requiredUser() throws {
+        let user = try #require(UserStore().current)   // hard stop if nil
+        #expect(user.isActive)
+    }
+}
+```
+
+UI automation (`XCUIApplication`) and performance (`XCTMetric`) **stay in XCTest** — both frameworks coexist in one target. Run: `xcodebuild test -scheme MyApp -destination 'platform=iOS Simulator,name=iPhone 17'`. Depth (traits, `confirmation` for async events, in-memory `ModelContainer` for SwiftData, the XCTest migration table) in [references/testing.md](references/testing.md).
+
+## Build / run loop
+
+```bash
+xcodebuild -scheme MyApp -destination 'platform=iOS Simulator,name=iPhone 17' build
+xcodebuild -scheme MyApp -destination 'platform=iOS Simulator,name=iPhone 17' test
+xcrun simctl list devices                 # manage simulators
+swift build && swift test                 # SwiftPM packages (libraries / modular targets)
+```
+
+App = `.xcodeproj`/`.xcworkspace` built with `xcodebuild`. Library or shared module = `Package.swift` built with `swift build`; use SwiftPM to pin dependency versions.
+
+## iOS 26 adoption (brief)
+
+New surface: Liquid Glass via `.glassEffect()` (no `UIVisualEffectView`), the `@Animatable` macro for custom animatable shapes, native SwiftUI `WebView`, `Chart3D`, richer `TabView` roles. Adopt them behind `if #available(iOS 26, *)`; do not casually raise the whole deployment target — most apps still support N-1/N-2.
+
+## Anti-patterns
+
+| Anti-pattern | Why it's wrong | Do instead |
+| --- | --- | --- |
+| `actor` for a SwiftUI view model | Reentrant, not main-bound → UI mutates off-main | `@MainActor @Observable` class |
+| `Task.detached` to silence a warning | Drops actor + priority inheritance; hides the real race | `Task {}` or `.task {}` |
+| `@nonisolated(unsafe)` to quiet isolation errors | Disables the safety you turned on; the race remains | Make the type `Sendable` or keep it main-isolated |
+| `DispatchQueue.main.async` inside an `@Observable` model | Old concurrency model fighting actors | Annotate the model `@MainActor` |
+| `ObservableObject` / `@Published` for new code | Whole-object invalidation, no isolation help | `@Observable` |
+| `NavigationView` | Deprecated, no type-safe path | `NavigationStack` + `navigationDestination` |
+| Blocking the main actor with sync network/disk I/O | Freezes the UI | `await` async work, hop back to main to mutate |
+| `@MainActor` on pure compute / leaf utilities | Needless serialization onto the UI thread | Leave it `nonisolated` |
+| `XCTAssert` in a new Swift Testing file | Mixing frameworks; loses `#expect` diagnostics | `#expect` / `#require` |
+| Force-unwrapping `@Query` / fetch results | Crashes on empty store | Handle the empty case |
+
+## Cross-references
+
+- Native Android in Kotlin/Compose → [../kotlin-android/SKILL.md](../kotlin-android/SKILL.md)
+- One codebase for iOS + Android via KMP/CMP → [../compose-multiplatform/SKILL.md](../compose-multiplatform/SKILL.md)
+- Cross-platform Dart → [../flutter/SKILL.md](../flutter/SKILL.md)
+- React Native runtime / native modules → [../react-native/SKILL.md](../react-native/SKILL.md); the EAS/OTA shipping pipeline → [../expo/SKILL.md](../expo/SKILL.md)
+- Store submission / release process → [../ship/SKILL.md](../ship/SKILL.md)
+- Cloud CI build/sign and the non-Swift test stack are siblings (`github-actions`, `testing-web`) — see `recommends`.

package/skills/swift-ios/evals/README.md

@@ -0,0 +1,3 @@
+# Evals — swift-ios
+
+These cases are routing/trigger fixtures plus one capability rubric. `should_trigger` lists prompts that must select this skill (including a verbatim Swift 6 diagnostic and a Catalan phrasing); `should_not_trigger` lists adjacent prompts that must route to the named sibling instead. No Xcode, simulator, or Swift toolchain is needed to evaluate them — judge whether a router would pick `swift-ios` and explain why. The `capability` case is graded against its `must_include` checklist by reading the model's proposed refactor, not by compiling or running anything; pass it only if the answer covers each rubric point (MainActor isolation, `Task {}` over `Task.detached`, Sendable, `@Observable` + `@State`, cancellation).

package/skills/swift-ios/evals/cases.yaml

@@ -0,0 +1,46 @@
+skill: swift-ios
+
+should_trigger:
+  - prompt: "Build a native iOS app in SwiftUI to track workouts with local persistence."
+    why: Core greenfield SwiftUI app with SwiftData persistence — the skill's home turf.
+  - prompt: "Compiler says 'main actor-isolated property cannot be referenced from a nonisolated context' after I turned on Swift 6 mode."
+    why: Non-obvious — a verbatim strict-concurrency diagnostic that only this skill diagnoses and fixes.
+  - prompt: "Should my SwiftUI view model be an actor or a @MainActor class?"
+    why: Concurrency-architecture decision unique to Swift/SwiftUI; the answer is @MainActor, not actor.
+  - prompt: "Migrate my XCTest cases to #expect / @Test and parameterize them."
+    why: Swift Testing ownership; XCTest-to-Swift-Testing migration lives here.
+  - prompt: "Necesito una app nativa de iOS amb SwiftUI i concurrència moderna (async/await)."
+    why: Catalan/Spanish phrasing for a native SwiftUI + concurrency app.
+  - prompt: "How do I do type-safe programmatic navigation with NavigationStack and deep links?"
+    why: NavigationStack + typed path + navigationDestination is owned by this skill.
+  - prompt: "My @Observable model glitches the UI when it updates from a background fetch — what's wrong?"
+    why: Non-obvious symptom of off-main mutation of observed state, the #1 footgun.
+
+should_not_trigger:
+  - prompt: "Build the same app for both iOS and Android from one Kotlin codebase."
+    route_to: compose-multiplatform
+    why: Shared KMP/CMP across both OSes, not Apple-native single-platform.
+  - prompt: "Build this mobile app in Flutter with Dart."
+    route_to: flutter
+    why: Different language and ecosystem entirely.
+  - prompt: "Set up EAS Build and OTA updates for my React Native app."
+    route_to: expo
+    why: The React Native / Expo shipping pipeline, not Swift coding.
+  - prompt: "Write the native Android version in Jetpack Compose."
+    route_to: kotlin-android
+    why: Kotlin + Compose + Android side of the language/platform split.
+  - prompt: "Add a GitHub Actions workflow to build and sign my iOS app in CI."
+    route_to: github-actions
+    why: Generic cloud CI/signing process, not in-editor Swift app coding.
+
+capability:
+  - scenario: >
+      A SwiftUI screen has an @Observable model that fetches from the network inside a
+      Task.detached and assigns the result to a published-like property, producing intermittent
+      UI glitches and a Swift 6 data-race warning. Refactor it correctly.
+    must_include:
+      - Identifies that the model must be @MainActor (or rely on default-isolation MainActor) and that the off-main mutation is the bug.
+      - Replaces Task.detached with Task {} or .task {} so the main-actor context is inherited; awaits the async work and lets the mutation land back on main.
+      - Marks any cross-actor value types Sendable (or keeps them main-isolated) and explains the diagnostic.
+      - Uses @Observable (not ObservableObject) and owns the model via @State in the view.
+      - Notes cancellation — .task {} auto-cancels on disappear, or checks Task.isCancelled.