@ericrisco/rsc 0.1.44 → 0.1.45

package/skills/vue-nuxt/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: vue-nuxt
-description: "Use when building, reviewing, or optimizing a Vue 3 + Nuxt 4 app — Composition API/`<script setup>`, SSR/SSG/hybrid rendering, the `app/`+`server/` structure, SSR-safe data fetching and shared state, Nitro server routes, reactivity/hydration discipline. Triggers: `.vue` SFCs, `useFetch`/`useAsyncData`/`$fetch`, `useState`/Pinia, `defineModel`/`useTemplateRef`, hydration node mismatch, double-fetch on SSR, `server/api` handlers, `routeRules`, Nuxt 3→4 migration, `nuxt.config.ts`, 'app SSR no hidrata', 'per què es fa doble fetch'. NOT React/RSC (that is nextjs), NOT a static multi-framework site (that is astro)."
+description: "Use when building or reviewing a Vue 3 + Nuxt 4 app — `<script setup>` reactivity, SSR/SSG/hybrid `routeRules`, the `app/`+`server/` layout, SSR-safe fetching (`useFetch`/`useAsyncData`) and state (`useState`/Pinia), Nitro routes, hydration mismatches, Nuxt 3→4 migration. NOT React/RSC (that is nextjs), NOT a static islands site (that is astro)."
 tags: [vue, nuxt, frontend, web, ssr]
 recommends: [design, deployment, secure-coding]
 origin: risco
@@ -11,35 +11,19 @@ origin: risco
 Build and review Vue 3 (`<script setup>` + Composition API) on the Nuxt 4 meta-framework:
 SSR/SSG/hybrid rendering, the `app/` + `server/` layout, SSR-safe fetching and state, Nitro
 server routes, and the reactivity discipline that keeps hydration correct. Nuxt's render model
-is **whole-component render-then-hydrate** — there is no React-style "server component" boundary.
-
-## When to use
-
-- Editing/creating `.vue` SFCs, `composables/`, `app/pages/`, `app/layouts/`, `server/api/`.
-- Choosing `useFetch` vs `useAsyncData` vs raw `$fetch`; fixing a double-fetch on SSR or a
-  hydration mismatch ("Hydration node mismatch", "text content did not match").
-- SSR-safe shared state: `useState` vs Pinia; stopping cross-request state leakage on the server.
-- Reactivity: `ref`/`reactive`/`computed`, `watch` vs `watchEffect`, reactive props destructure,
-  `defineModel`, `useTemplateRef`, lost reactivity after destructuring.
-- Nitro server routes, `useRuntimeConfig`, private vs `public` runtime config.
-- Nuxt 3 → Nuxt 4 migration (the `app/` srcDir move, shared-key data, shallowRef payload).
-- Rendering strategy: `routeRules` for per-route SSR/SSG/ISR/SWR/SPA.
-
-## When NOT to use
-
-- React / Next.js, App Router, RSC, server actions → `../nextjs/SKILL.md` or `../react/SKILL.md`.
-  Do not import RSC mental models here — Vue has no server-component boundary.
-- Content-first static site mixing frameworks/islands → `../astro/SKILL.md`. Fine-grained signals
-  framework → `../solid-js/SKILL.md`. Compiler-first no-VDOM peer → `../svelte/SKILL.md`.
-  Angular → `../angular/SKILL.md`.
-- Backend not in Nitro/JS (Python/Go/PHP) → `../fastapi/SKILL.md`, `../go/SKILL.md`,
-  `../laravel/SKILL.md`.
-- E2E or component-test *strategy* depth → `../e2e-testing/SKILL.md` / `../testing-web/SKILL.md`
-  (this skill states the Vitest + `@vue/test-utils` + `@nuxt/test-utils` setup, defers strategy).
-- Deploy-platform specifics (the Vercel/Netlify/Cloudflare adapters) → `../deployment/SKILL.md`,
-  `../vercel/SKILL.md`, `../netlify/SKILL.md`, `../cloudflare/SKILL.md`. This skill picks the
-  Nitro preset; those own the platform.
-- Generic security review → `../secure-coding/SKILL.md`; SEO/content strategy → `../marketing/SKILL.md`.
+is **whole-component render-then-hydrate** — there is no React-style "server component" boundary,
+so never import RSC mental models here.
+
+Not this skill: React / Next App Router / server actions → [`nextjs`](../nextjs/SKILL.md) or
+[`react`](../react/SKILL.md). Content-first site mixing frameworks/islands →
+[`astro`](../astro/SKILL.md); fine-grained signals → [`solid-js`](../solid-js/SKILL.md);
+compiler-first no-VDOM peer → [`svelte`](../svelte/SKILL.md); [`angular`](../angular/SKILL.md).
+Backend not in Nitro/JS → [`fastapi`](../fastapi/SKILL.md), [`go`](../go/SKILL.md),
+[`laravel`](../laravel/SKILL.md). Test *strategy* beyond the Vitest + `@vue/test-utils` +
+`@nuxt/test-utils` setup named here → [`e2e-testing`](../e2e-testing/SKILL.md) /
+[`testing-web`](../testing-web/SKILL.md). Generic security review →
+[`secure-coding`](../secure-coding/SKILL.md); SEO/content strategy →
+[`marketing`](../marketing/SKILL.md); component visual language → [`design`](../design/SKILL.md).
 
 ## First: detect Nuxt vs plain Vue, and the version
 
@@ -49,7 +33,7 @@ before you write a line.
 | Signal in the repo | Verdict | What is available |
 |---|---|---|
 | `nuxt.config.{ts,js,mjs}` + `app/` dir holding `pages/`,`components/` | **Nuxt 4** (current) | full auto-imports, `useFetch`/`useState`, `server/`, `routeRules` |
-| `nuxt.config.*` + root `pages/`,`components/` (no `app/`) | **Nuxt 3 layout** | same APIs; flag the migration (see `references/migration-nuxt4.md`) |
+| `nuxt.config.*` + root `pages/`,`components/` (no `app/`) | **Nuxt 3 layout** | same APIs; flag the migration (see [`references/migration-nuxt4.md`](references/migration-nuxt4.md)) |
 | `vite.config.*` + `createApp(...).mount(...)`, no `nuxt.config` | **plain Vue 3 SPA** | Vue reactivity only — NO `useFetch`/`useState`/Nitro/auto-imports |
 
 Rule: in a plain-Vue SPA, fetch with the browser `fetch`/a client library inside `onMounted` or a
@@ -121,7 +105,7 @@ const { name: nameRef } = toRefs(state)   // nameRef.value stays linked
 ```
 
 Deep reactivity, effect scope, advanced `provide/inject`, and render-function/JSX notes live in
-`references/reactivity.md`.
+[`references/reactivity.md`](references/reactivity.md).
 
 ## Components & composables
 
@@ -172,13 +156,14 @@ const { data: product, status, error, refresh } = await useAsyncData(
 Key options: `key` (shared/deduped result — same key returns the same `data`/`error`/`status` ref,
 auto-cleaned on last unmount), `lazy: true` (don't block navigation), `server: false` (client-only
 fetch), `transform` (reshape before storing), `pick` (keep only listed fields — shrinks payload),
-`watch`/reactive keys (a `ref`/`computed`/getter key refetches when it changes). In **Nuxt 4 the
-returned `data` is a `shallowRef`** — replace the whole value, don't deep-mutate, to trigger
-updates. Nuxt 4.2 adds `AbortController` signal support for request cancellation. Re-run with the
-returned `refresh()`, or invalidate broadly with `refreshNuxtData(key)`.
+`watch`/reactive keys (a `ref`/`computed`/getter key refetches when it changes). Type the result
+with `useFetch<T>()` / `useAsyncData<T>()`. In **Nuxt 4 the returned `data` is a `shallowRef`** —
+replace the whole value, don't deep-mutate, to trigger updates. Nuxt 4.2 adds `AbortController`
+signal support for request cancellation. Re-run with the returned `refresh()`, or invalidate
+broadly with `refreshNuxtData(key)`.
 
 Full option matrix, custom `$api` factory, optimistic UI, and error/pending patterns are in
-`references/data-and-state.md`.
+[`references/data-and-state.md`](references/data-and-state.md).
 
 ## SSR-safe state
 
@@ -259,7 +244,8 @@ export default defineEventHandler(async (event) => {
 the browser bundle. Rule: a secret in `runtimeConfig.public` (or any `NUXT_PUBLIC_*` env) ships to
 every client — keep API keys, DB URLs, and tokens at the top level, never under `public`. Type
 calls to your own API with `$fetch<ProductDto>('/api/...')`. Handlers, route-rule recipes,
-middleware, and `defineCachedEventHandler` caching live in `references/nitro-and-rendering.md`.
+middleware, and `defineCachedEventHandler` caching live in
+[`references/nitro-and-rendering.md`](references/nitro-and-rendering.md).
 
 ## Rendering strategy
 
@@ -281,8 +267,9 @@ export default defineNuxtConfig({
 
 `nuxt build` produces an SSR server; `nuxt generate` prerenders a fully static site. The **Nitro
 preset** chooses the deploy target (node-server, vercel, netlify, cloudflare-pages, …) — pick the
-preset here, then hand platform specifics to `../deployment/SKILL.md` / `../vercel/SKILL.md` /
-`../netlify/SKILL.md` / `../cloudflare/SKILL.md`.
+preset here, then hand platform specifics to [`deployment`](../deployment/SKILL.md),
+[`vercel`](../vercel/SKILL.md), [`netlify`](../netlify/SKILL.md), or
+[`cloudflare`](../cloudflare/SKILL.md).
 
 ## Performance
 
@@ -296,12 +283,6 @@ preset here, then hand platform specifics to `../deployment/SKILL.md` / `../verc
   a 2026 preview targeting mid-2026 stable — treat as opt-in, not the default.
 - Targets: LCP < 2.5s, CLS < 0.1, INP < 200ms.
 
-## TypeScript discipline
-
-Generic `defineProps<{...}>()` / `defineEmits<{...}>()`; typed `useFetch<T>()` /
-`useAsyncData<T>()`; typed `$fetch<T>()` to your own API; `strict: true`. Gate with
-`nuxi typecheck` (Nuxt) or `vue-tsc --noEmit` (plain Vue) — see Verify.
-
 ## Anti-patterns → STOP
 
 | Smell | Why it is wrong | Do instead |
@@ -317,68 +298,26 @@ Generic `defineProps<{...}>()` / `defineEmits<{...}>()`; typed `useFetch<T>()` /
 | Same fetch in two components without a shared `key` | duplicate requests, divergent refs | one stable `key` → shared deduped result |
 | `ref(hugeArray)` / deep `reactive` on big lists | per-element proxy overhead | `shallowRef`/`shallowReactive`, replace whole value |
 
-## Quick reference
-
-| Task | API / file |
-|---|---|
-| Page data, once on SSR | `useFetch(url, { key })` / `useAsyncData(key, fn)` |
-| Request in a handler / after mount | `$fetch(url)` |
-| Shared SSR-safe value | `useState(key, init)` |
-| Structured store | Pinia setup store in `app/stores/` |
-| Two-way binding | `defineModel<T>()` |
-| Template DOM ref | `useTemplateRef('name')` |
-| Server endpoint | `server/api/x.get.ts` + `defineEventHandler` |
-| HTTP error | `throw createError({ statusCode })` |
-| Private vs public config | `useRuntimeConfig()` vs `config.public` |
-| Per-route rendering | `routeRules` in `nuxt.config.ts` |
-| Static build | `nuxt generate`; SSR build `nuxt build` |
-| Typecheck | `nuxi typecheck` / `vue-tsc --noEmit` |
-
 ## Verify
 
-`scripts/verify.sh` runs from the project root. It detects Nuxt via `nuxt.config.{ts,js,mjs}`; for
-a Nuxt repo it runs `nuxi typecheck` (fallback `vue-tsc --noEmit`), the package `lint` script if
-present, `vitest run` if Vitest is present, then `nuxi build`. With no Nuxt config it runs
-`vue-tsc --noEmit`, lint, vitest, then `vite build`. Every missing tool is a yellow SKIP, never a
-failure; everything is read-only except the final build, which writes `.nuxt/`/`.output/` (or
-`dist/`). No installs, no network mutations, safe to re-run, exits 0 on a clean/empty target.
+`scripts/verify.sh` runs from the project root. With a `nuxt.config.{ts,js,mjs}` it runs `nuxi
+typecheck` (fallback `vue-tsc --noEmit`), the package `lint` script if present, `vitest run` if
+Vitest is present, then `nuxi build`; with no Nuxt config, `vue-tsc --noEmit`, lint, vitest, then
+`vite build`. Keep `strict: true` in tsconfig so the typecheck is worth running. Every missing tool
+is a yellow SKIP, never a failure; everything is read-only except the final build, which writes
+`.nuxt/`/`.output/` (or `dist/`). No installs, no network mutations, safe to re-run, exits 0 on a
+clean/empty target.
 
 ## Project grounding (02-DOCS + CLAUDE.md)
 
-When this skill runs in a project with a `02-DOCS/` layer (the [`harness`](../harness/SKILL.md)
-Karpathy wiki), record this app's decisions there and index them from the root `CLAUDE.md`, so the
-next agent inherits the conventions instead of re-deriving them.
-
-1. **Find the article** `02-DOCS/wiki/stack/vue-nuxt.md`, linked from a `## Knowledge map` section
-   in the root `CLAUDE.md`.
-2. **If missing or stale**, create/update it with the project's real choices — rendering mode per
-   route (`routeRules`), the `useFetch`/`useAsyncData` conventions, the state choice (`useState`
-   vs Pinia), the Nitro preset/deploy target, and the design-system hookup — then add/refresh the
-   `CLAUDE.md` link (creating the `## Knowledge map` section, and `CLAUDE.md` itself, if absent).
-3. **Read it first on every use** and stay consistent; when a convention changes, update the
-   article (bump its `Updated` date) in the same change.
-
-No `02-DOCS/` layer? Skip silently (optionally suggest `harness`). Technical conventions are
-*recorded, not gated* — never block the task on this.
-
-## References
-
-- `references/reactivity.md` — reactivity caveats, effect scope, watcher cleanup, composable
-  patterns, typed `provide/inject`, advanced `defineModel`, render-fn/JSX.
-- `references/data-and-state.md` — full `useFetch`/`useAsyncData` option matrix, custom `$api`,
-  Pinia setup stores + SSR hydration + Pinia Colada, `useState` patterns, optimistic UI.
-- `references/nitro-and-rendering.md` — Nitro handlers, route-rule recipes (ISR/SWR/SPA/prerender),
-  server middleware, runtime config, `defineCachedEventHandler`, preset selection.
-- `references/migration-nuxt4.md` — Nuxt 3 → 4 (`app/` move, `compatibilityVersion`, shared-key
-  data, shallowRef payload, renamed APIs) and Vue 3.4 → 3.5 deltas.
-
-## See Also
-
-- `../nextjs/SKILL.md` — the React/Next analogue; cross over only when the project is React.
-- `../design/SKILL.md` — design system and component visual language this skill consumes.
-- `../deployment/SKILL.md`, `../vercel/SKILL.md`, `../netlify/SKILL.md`, `../cloudflare/SKILL.md`
-  — platform deploy once the Nitro preset is chosen.
-- `../secure-coding/SKILL.md` — generic security; complements the runtime-config secret rules here.
-- `../e2e-testing/SKILL.md` / `../testing-web/SKILL.md` — test strategy beyond the setup stated here.
-- `../marketing/SKILL.md` — SEO/GEO content strategy this skill renders but does not decide.
-- `../harness/SKILL.md` — workspace conventions (`02-DOCS/`).
+In a project with a `02-DOCS/` layer (the [`harness`](../harness/SKILL.md) Karpathy wiki), read
+`02-DOCS/wiki/stack/vue-nuxt.md` first and stay consistent with it. If it is missing or stale,
+create/update it with this app's real choices — rendering mode per route (`routeRules`), the
+`useFetch`/`useAsyncData` conventions, `useState` vs Pinia, the Nitro preset/deploy target, the
+design-system hookup — bump its `Updated` date, and link it from a `## Knowledge map` section in
+the root `CLAUDE.md` (creating that section, and `CLAUDE.md` itself, if absent). No `02-DOCS/`
+layer? Skip silently. Technical conventions are *recorded, not gated* — never block the task.
+
+Nuxt 3 → 4 deltas (`app/` move, `compatibilityVersion`, shared-key data, shallowRef payload,
+renamed APIs) and Vue 3.4 → 3.5 changes are in
+[`references/migration-nuxt4.md`](references/migration-nuxt4.md).

package/skills/worktrees/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: worktrees
-description: "Use when feature work needs an isolated workspace before code is touched — branch or git worktree off the default branch so the main checkout stays clean while a plan is executed. Triggers: 'isolate this work', 'I don't want to touch main', 'set up a worktree', 'work on a branch for this', 'spin up an isolated checkout', 'start the feature without dirtying my tree', 'create a worktree for the plan', 'I'm on main and need to implement', 'keep the working tree clean', 'parallel checkout for this branch'. The on-demand SDD step that runs right before implement: it confirms a clean, isolated workspace exists (native EnterWorktree first, git worktree fallback), records nothing to runtime, and hands back to implement. NOT the task breakdown (tasks), NOT writing code (implement), NOT branch cleanup/merge after the work (that's the ship phase). Honors the harness accompaniment dial."
+description: "Use when work is about to become commits and needs isolation first — check the tree state, then branch or cut a git worktree off a clean base (native EnterWorktree first, git fallback) so implement never runs on main. NOT what may run concurrently inside those workspaces (that is `parallel`), NOT the merge/cleanup after (that is `ship`)."
 tags: [git, worktree, isolation]
 recommends: []
 profiles: [core, full]
@@ -53,11 +53,10 @@ extra directory. The rest of this skill assumes a worktree; the branch path is t
 
 Run this in order. Each check prevents a class of "lost work" you can't easily undo.
 
-1. **Read the accompaniment dial.** Open `02-DOCS/wiki/harness/user-profile.md` for the technical +
-   accompaniment level (L0..L3) — it sets how much you narrate and whether you confirm before acting
-   (see the dial table below). No profile yet → assume non-technical, explain what a worktree is in
-   one plain sentence before making one. No `02-DOCS/` at all (a worktree can be created in any git
-   repo with no rsc harness present) → skip the dial, assume non-technical, and proceed.
+1. **Read the accompaniment dial** — `02-DOCS/wiki/harness/user-profile.md` gives the technical +
+   accompaniment level (L0..L3); set your volume from the table below. No profile yet → assume
+   non-technical, explain what a worktree is in one plain sentence before making one. No `02-DOCS/` at all (a worktree can be created in any git repo
+   with no rsc harness present) → skip the dial, assume non-technical, and proceed.
 2. **Confirm you're in a git repo.** `git rev-parse --is-inside-work-tree`. If not, there's nothing
    to isolate with git — tell the user; don't fabricate a worktree.
 3. **Check the current branch.** `git rev-parse --abbrev-ref HEAD`. On `main`/`master` with work
@@ -70,6 +69,8 @@ Run this in order. Each check prevents a class of "lost work" you can't easily u
      carry them over. Never silently leave a user's WIP behind.
    - Unrelated WIP → that's the textbook reason to use a worktree (isolate the new work, leave the
      WIP exactly where it sits).
+   - A dirty tree you don't understand is a hard stop: surface every modified path and ask before
+     branching or stashing. Lost WIP is the one unrecoverable failure in this step.
 5. **Pick the base ref.** Branch from an up-to-date default branch unless the user wants to build on
    local HEAD. Stale base = predictable merge pain later. Default: fresh from `origin/<default>`.
 6. **Choose a name** tied to the feature slug — the same `<slug>` the spec and plan use
@@ -83,15 +84,17 @@ Only once the tree state is understood and the user's WIP is accounted for do yo
 **Prefer the native worktree tool when it's available in your environment.** An `EnterWorktree`-style
 tool typically creates an isolated worktree (often under something like `.claude/worktrees/`, though
 the exact location is tool-dependent), switches the session into it, and tracks it for clean exit —
-which is exactly the lifecycle this skill wants, with no manual path management.
+which is exactly the lifecycle this skill wants, with no manual path management. The git path is the
+universal fallback and is exactly what the native tool does under the hood.
 
-- **Enter:** create/enter the worktree (e.g. an `EnterWorktree`-style native tool, named for the
-  feature slug). The session's working directory moves into the isolated checkout.
-- **Exit:** on the native tool, `keep` to leave the worktree and branch on disk for later, `remove`
-  to delete both when the work is done or abandoned. Removal of a worktree holding uncommitted or
-  unmerged work must be an explicit, confirmed choice — never a silent cleanup.
+| You have… | Create | Leave intact | Discard |
+| --- | --- | --- | --- |
+| A native worktree tool (`EnterWorktree`-style) | enter, named for the feature slug; the session's working directory moves into the isolated checkout | exit with `keep` — worktree and branch stay on disk for later | exit with `remove` — deletes both when the work is done or abandoned |
+| Plain git only | `git worktree add -b feat/<slug> …` | leave the dir; it persists | `git worktree remove` + `git branch -d` |
 
-If no native worktree tool is present, fall back to plain git. The mechanics:
+Removing a worktree that holds uncommitted or unmerged work must be an explicit, confirmed choice,
+never a silent cleanup: refuse the silent path and confirm the discard with the user, quoting what
+would be lost.
 
 ```bash
 # from the repo root, default branch up to date
@@ -140,24 +143,13 @@ git worktree prune                                # self-heal stale administrati
 - **`git worktree prune`** after a remove clears stale metadata when a directory vanished out from
   under git — cheap self-healing, safe to run.
 
-## Native vs. git fallback — which you're using
-
-| You have… | Create | Leave intact | Discard |
-| --- | --- | --- | --- |
-| A native worktree tool (`EnterWorktree`-style) | enter, named for the slug | exit with `keep` | exit with `remove` (confirm if dirty/unmerged) |
-| Plain git only | `git worktree add -b feat/<slug> …` | leave the dir; it persists | `git worktree remove` + `git branch -d` |
-
-The native tool is preferred because it owns the session-switch and the exit lifecycle for you. The
-git path is the universal fallback and is exactly what the native tool does under the hood.
-
 ## Model tier — `light` (opt-in routing)
 
 This phase's default model tier is **`light`** — isolating the workspace is mechanical git work. Routing is **off** unless `models.enabled: true` in `02-DOCS/wiki/sdd/config.yaml`. When on: resolve this phase's tier (`models.overrides` wins over `models.phases`), map it to a model via `models.tiers`, and apply per `../sdd/references/model-routing.md` — announce the switch per the accompaniment dial when it differs from the session model, and dispatch any `Task`/`parallel` subagents on that model. Routing off or no profile → honor the session model silently. Never fake a switch a tool can't make; skip routing on a one-line change.
 
 ## Adapting to the dial
 
-Read `02-DOCS/wiki/harness/user-profile.md` and match your volume — the isolation is identical at
-every level; only the talking changes.
+The isolation is identical at every level; only the talking changes.
 
 | Level | How `worktrees` behaves |
 | --- | --- |
@@ -182,47 +174,10 @@ the dial controls verbosity, never whether you check before risking someone's WI
 | "Already on a feature branch, I'll make a worktree anyway" | Redundant isolation is just clutter. If the current branch is already isolated and clean, say so and proceed. |
 | "I'll record the worktree path into 02-DOCS so it's tracked" | Isolation is plumbing, not knowledge. No artifact; the branch name traces it. Don't pollute the wiki. |
 
-## Red flags — stop and re-route
-
-- **Not a git repo** → nothing to isolate with git. Tell the user; don't invent a workspace.
-- **Dirty tree you don't understand** → don't bulldoze it. Surface every modified path and ask
-  before branching/stashing. Lost WIP is the one unrecoverable failure here.
-- **Asked to merge, open a PR, or delete the branch after the work** → that's `../ship/SKILL.md`, not
-  this one. This skill opens isolation; ship closes it.
-- **Asked to actually write the feature code** → that's `../implement/SKILL.md`. Create the workspace,
-  then hand off; don't start coding in this step.
-- **A native `remove`/`git worktree remove` would drop uncommitted or unmerged work** → refuse the
-  silent path. Confirm the discard explicitly with the user, quoting what would be lost.
-
-## Checklist (copy when isolating)
-
-```text
-- [ ] Read the accompaniment dial (user-profile.md); set verbosity
-- [ ] Confirmed inside a git repo
-- [ ] Checked current branch; on main/master if implement is next
-- [ ] Checked `git status --short`; accounted for any uncommitted WIP (asked, didn't bulldoze)
-- [ ] Picked base ref (fresh origin/<default> unless user chose HEAD)
-- [ ] Named the workspace feat/<slug> to match the spec/plan artifacts
-- [ ] Created isolation: native worktree tool if available, else git worktree (branch = degenerate case)
-- [ ] Confirmed: cwd is the isolated branch; the main checkout is untouched
-- [ ] Wrote NO runtime code and NO 02-DOCS artifact here
-- [ ] Handed off to implement
-```
-
-## What this skill is NOT
-
-- **Not the task breakdown.** Slicing the plan into ordered, verifiable tasks is `../tasks/SKILL.md`.
-- **Not the coding.** Writing the feature test-first, task by task, is `../implement/SKILL.md`.
-- **Not branch cleanup / merge / PR.** Closing the branch — merge, PR, or discard, with Eric-only
-  git authorship — is `../ship/SKILL.md`. This skill only *opens* the isolation.
-- **Not a place for runtime or wiki artifacts.** It touches git state only; nothing under `02-DOCS`.
-
-## Where you are in the chain
-
-`constitution` → `specify` → `clarify` → `plan` → `tasks` → `analyze` → **worktrees** (on-demand) →
-`implement` → `verify` → `review` → `ship`. The **parallel** pattern leans on this skill too: each
-independent stream gets its own worktree so the streams never fight over files.
-
-**Next:** with a clean isolated workspace in hand, hand to **`../implement/SKILL.md`** — walk the
-task list test-first, one commit per task, on this branch. When the feature is built and verified,
-**`../ship/SKILL.md`** closes the branch.
+**Next:** with a clean isolated workspace in hand, hand to `../implement/SKILL.md` — walk the task
+list test-first, one commit per task, on this branch. Neighbours: `../tasks/SKILL.md` slices the plan
+before you get here; `../parallel/SKILL.md` decides *what may run concurrently* inside these
+workspaces — it leans on this skill (each independent stream gets its own worktree, so the streams
+never fight over files) but the partition-then-gather call is its own; `../ship/SKILL.md` closes the
+branch afterwards — merge, PR, or discard, with Eric-only git authorship. This skill only *opens* the
+isolation, and it touches git state only: no runtime code, nothing under `02-DOCS`.