@nurix/etna 0.20.36 → 0.20.37

package/data/harnesses/code/skills/boundary/references/mechanisms.md

@@ -1,10 +1,8 @@
 # Boundary Mechanisms
 
-Load when: every boundary check — this is the core reference. The technology packs under `packs/` instantiate these mechanisms with exact detect signals and gotchas; `index.md` routes to the packs the touched code exhibits.
+Load when: every boundary check — this is the core reference. The packs under `packs/` instantiate these mechanisms with exact detect signals and gotchas.
 
-A boundary is a contract between two pieces of code (or code and infra) that share an assumption with **no static link** between them. The litmus is **"would it ship green?"** — change one side, everything compiles, lints, and tests pass, and the other side breaks at runtime. An edge the compiler or an existing test already guards is not a boundary.
-
-Every boundary instantiates one of seven mechanisms. The mechanism tells you what to grep for, what the universal fix is, and how bad a break is — including for technologies no pack covers. When touched code exhibits a contract that matches no pack entry, diagnose it from its mechanism.
+Every boundary instantiates one of seven mechanisms. The mechanism tells you what to grep for, what the universal fix is, and how bad a break is — which is how you diagnose a technology no pack covers.
 
 ---
 
@@ -91,9 +89,4 @@ Two contracts come from the product's information architecture, not from any tec
 
 ## Severity recap
 
-- **CRITICAL** — can corrupt persisted data, or open an auth/money path. Trust-invariants and persisted/replayed shapes live here.
-- **HIGH** — silent cross-module breakage that ships green.
-- **MEDIUM** — drift-prone coupling (string-matched, duplicated constants) not yet broken.
-- **LOW** — smell. Loud, immediately-visible runtime breakage caps at HIGH; statically-guarded edges are out of scope entirely.
-
-Severity is intrinsic to the finding, not curved: three genuine CRITICALs in a small repo is correct signal, not inflation.
+The scale is `SKILL.md` step 4; each mechanism's **Severity** line above places a finding on it.

package/data/harnesses/code/skills/boundary/references/packs/frontend.md

@@ -1,6 +1,6 @@
 # Pack: frontend / client state / UI build
 
-Load when: the touch list exhibits Redux Toolkit (`createSlice`, `configureStore`), RTK Query tags, react-router route tables, Tailwind 4 CSS (`@theme`, `personality.css`, `globals.css`), Vite config (`resolve.alias`, env), `@nurix/components` imports, localforage/redux-persist, or date handling crossing the wire.
+Load when: the touch list exhibits Redux Toolkit (`createSlice`, `configureStore`), RTK Query tags, react-router route tables, Tailwind 4 CSS (`@theme`, `personality.css`, `design.tokens.css`, `globals.css`), Vite config (`resolve.alias`, env), `@nurix/components` imports, localforage/redux-persist, or date handling crossing the wire.
 
 ## redux-persist-shape-migration — CRITICAL · serialized-shape
 **Contract:** State shapes frozen in the user's browser storage by redux-persist must be readable by the *current* reducers' `initialState` — `version`/`migrate` is the only bridge, and `whitelist`/`blacklist` reference reducer-map keys by literal string.
@@ -51,10 +51,10 @@ Load when: the touch list exhibits Redux Toolkit (`createSlice`, `configureStore
 **Safe change:** Grep both consumer forms — utility stems (`bg-old`, `text-old`) and `var(--…-old)` including `node_modules/@nurix/components` dist CSS; keep the old token as an alias for one release; visually diff themed screens after the rename.
 
 ## tailwind-theme-inline-indirection — HIGH · config-elsewhere
-**Contract:** `@theme inline { --color-primary: var(--primary) }` makes utilities emit the *referenced* variable (`background-color: var(--primary)`), resolved per-element at runtime — the org's theming (personality.css vars swapped under `[data-theme]`/`[data-style]`) only flows through utilities via the `inline` form.
-**Detect:** `@theme inline`, plain `@theme {`, token values that are `var(--…)`, `[data-theme=`/`[data-style=` blocks in `personality.css`
-**Ships green, breaks:** Adding a var-referencing token to a plain (non-`inline`) `@theme` block compiles and looks correct in the default theme; switching `data-theme`/`data-style` then silently fails to restyle those utilities, because the theme variable captured the referenced var's value as resolved at `:root` — subtree/attribute-scoped overrides never reach it. No warning, no error; only the alternate theme is wrong.
-**Safe change:** Any token whose value is `var(--app-var)` goes in the `@theme inline` block, raw literal values in plain `@theme`; after adding tokens, toggle `data-theme` and `data-style` in devtools and confirm the new utilities respond in both states.
+**Contract:** `@theme inline { --color-primary: var(--primary) }` makes utilities emit the *referenced* variable (`background-color: var(--primary)`), resolved per-element at runtime — the org's theming (token values swapped under `.dark`, and the personality.css `:root`/`.dark` overrides) only flows through utilities via the `inline` form.
+**Detect:** `@theme inline`, plain `@theme {`, token values that are `var(--…)`, `:root:not(.dark)`/`:root.dark` blocks in `design.tokens.css`, `:root`/`.dark` blocks in `personality.css`
+**Ships green, breaks:** Adding a var-referencing token to a plain (non-`inline`) `@theme` block compiles and looks correct in light mode; toggling `.dark` or recompiling the personality then silently fails to restyle those utilities, because the theme variable captured the referenced var's value as resolved at `:root` — mode-scoped and subtree overrides never reach it. No warning, no error; only the alternate mode is wrong.
+**Safe change:** Any token whose value is `var(--app-var)` goes in the `@theme inline` block, raw literal values in plain `@theme`; after adding tokens, toggle the `.dark` class on the root element in devtools and confirm the new utilities respond in both modes.
 
 ## tailwind-source-detection — HIGH · generated-artifact
 **Contract:** The generated stylesheet contains only class names that appear as complete, unbroken literal strings in scanned source files — the build-time scanner vs class names assembled at runtime; the default scan set skips `.gitignore`d paths and `node_modules`.
@@ -62,16 +62,16 @@ Load when: the touch list exhibits Redux Toolkit (`createSlice`, `configureStore
 **Ships green, breaks:** `bg-${color}-500` builds and renders unstyled — the utility is simply absent from the CSS. Class names stored in data or composed in unscanned code work only as long as some scanned file coincidentally contains the same literal — deleting that last literal usage breaks a "different" feature. Gitignored source directories are silently excluded from scanning.
 **Safe change:** Always write full class literals and select via lookup maps (`{primary: 'bg-blue-600'}[variant]`); safelist genuinely dynamic sets with `@source inline("…")` (v4.1+); add explicit `@source "…"` for out-of-tree or ignored directories.
 
-## dark-variant-data-attributes — HIGH · rendezvous-string
-**Contract:** `@custom-variant dark (&:where([data-theme=dark] *))` and the personality selectors `[data-theme="…"]`/`[data-style="…"]` rendezvous on the exact attribute name+value that runtime JS stamps on `<html>` (`document.documentElement.dataset.theme/style`).
-**Detect:** `@custom-variant dark`, `[data-theme=`, `[data-style=`, `dataset.theme`, `setAttribute('data-theme'`, `classList.add('dark')`
-**Ships green, breaks:** Without the `@custom-variant dark` override, Tailwind's default `dark:` variant is the `prefers-color-scheme: dark` media query — every `dark:` class silently follows the OS setting and ignores the app's toggle entirely. A value or mechanism mismatch (JS writes `class="dark"` while CSS expects `[data-theme=dark]`, or a casing typo) leaves the alternate theme unreachable with zero errors. Org default is light: base tokens must stay scoped `:root, :root[data-theme="light"]` or unstamped pages render the wrong theme.
-**Safe change:** Define attribute name and values as one exported constant consumed by the toggle code; add `@custom-variant dark` the moment any `dark:` utility pairs with an attribute toggle; flip the attribute in devtools and verify both directions plus the no-attribute default.
+## dark-variant-class — HIGH · rendezvous-string
+**Contract:** `@nurix/components` declares `@custom-variant dark (&:is(.dark *))` and ships its dark values compiled as `.dark { … }`; the app's toggle, its own `dark:` utilities and its token blocks (`:root.dark`) rendezvous on the exact class `dark` stamped on the root element (`document.documentElement.classList`).
+**Detect:** `@custom-variant dark`, `classList.add('dark')`/`classList.toggle('dark'`, `:root.dark`, `.dark {`, and the mismatch signals `[data-theme=`, `dataset.theme`, `setAttribute('data-theme'`
+**Ships green, breaks:** A toggle that stamps `data-theme="dark"` instead of the class renders half-flipped with zero errors: the app's own attribute-keyed tokens invert while every library surface — its `dark:` variants, its compiled `.dark { … }` values, its theme toggle and toaster — stays light, because the library's selectors are compiled into distributed CSS and cannot be re-keyed. Without `@custom-variant dark` in the CSS entry, the app's own `dark:` classes fall back to Tailwind's default `prefers-color-scheme: dark` media query and follow the OS setting instead of the toggle. Light is the org default: light values sit on `:root:not(.dark)`, so a page with no class renders light.
+**Safe change:** Toggle only the `dark` class on the root element, from a pre-paint inline script plus the persisted-preference module; bind `@custom-variant dark (&:is(.dark *))` in the CSS entry; flip the class in devtools and verify both directions, plus the no-class default, on an app surface and a library component side by side.
 
 ## nurix-components-styles-tokens — HIGH · rendezvous-string
-**Contract:** `@nurix/components` is imported by subpath (`@nurix/components/button`) but styled through two separate channels — its own pre-built `styles.css` (imported in `globals.css`) and the app's semantic CSS variables (personality tokens like `--radius-*`, `--color-*`) that its rules read.
-**Detect:** `from '@nurix/components/`, the library `styles.css` `@import` line in `globals.css`, grep `var(--` in `node_modules/@nurix/components/**/styles.css`
-**Ships green, breaks:** Omitting the `styles.css` import renders every component fully functional but unstyled — no JS error, no build warning, no missing-module failure. Renaming or dropping a personality token the library reads silently degrades components to fallback/`initial` values (e.g. a flat archetype's `--radius-*: 0` re-assertion lost in a token refactor). The library is pre-built, so the app's Tailwind scanner never generates utilities for markup inside it — its shipped CSS is the only style source.
+**Contract:** `@nurix/components` is imported by layered subpath (`@nurix/components/element/button`) but styled through two separate channels — its `styles.css` (CSS-`@import`ed in `globals.css`) and the CSS variables its rules read: the app's theme colors and `--radius`, the `--intent-*` family, and the personality layer (`--radius-scale`, `--density-*`, `--edge-*`, `--ring-*`, `--elevation-*`).
+**Detect:** `from '@nurix/components/`, the library `styles.css` `@import` line in `globals.css`, grep `var(--` in `node_modules/@nurix/components/dist/styles.css`
+**Ships green, breaks:** Omitting the `styles.css` import renders every component fully functional but unstyled — no JS error, no build warning, no missing-module failure. Renaming or dropping a token the library reads silently degrades components to fallback/`initial` values (e.g. a sharp-edge personality's `--radius-scale` override lost in a token refactor). The app's Tailwind compiles the library's utilities: `styles.css` omits `@import "tailwindcss"` and carries an `@source` over the compiled JS, so its classes resolve against the app's theme — a JS `import` of `styles.css` (in `main.tsx`) compiles it standalone with no theme loaded and fails the build.
 **Safe change:** Keep the `styles.css` import at its mandated position in `globals.css`; before touching any personality token, grep the library's dist CSS for `var(--that-token)`; smoke-render a themed library component after every `@nurix/components` upgrade.
 
 ## vite-alias-tsconfig-paths — MED · dual-authority
@@ -81,10 +81,10 @@ Load when: the touch list exhibits Redux Toolkit (`createSlice`, `configureStore
 **Safe change:** Single-source the mapping (`vite-tsconfig-paths`, or generate both from one constant); update both files in the same commit on any directory move; when suspicious, log `import.meta.url` from the module in dev to see which file actually loaded.
 
 ## css-import-order — MED · lifecycle-protocol
-**Contract:** `globals.css` must import in the fixed sequence `@import "./personality.css"` → `@import "tailwindcss"` → the library's `styles.css` → `@theme inline {…}` — cascade-layer order is fixed at first appearance of each `@layer` name, so file position *is* the styling contract between Tailwind, the component library, and the personality tokens.
-**Detect:** first ~10 lines of `globals.css`, `@import "tailwindcss"`, `@import` of `@nurix/components` styles, `@layer` declarations inside the library CSS
-**Ships green, breaks:** Any reorder compiles and mostly renders — the breakage is visual-only and theme/element-specific: importing the library's `styles.css` before `@import "tailwindcss"` lets preflight's `@layer base` resets land after (and wipe) library button/form styling at equal specificity, and flips which side wins app-utility-vs-library override wars. Nothing logs; a form-heavy screen just looks subtly wrong.
-**Safe change:** Treat the four-line header as frozen; insert new global stylesheets at a deliberate position relative to `tailwindcss` and the library import, never appended blindly; after any reorder, visual-diff a form-heavy screen in every `data-theme`/`data-style` combination.
+**Contract:** The CSS entry (`globals.css`, or whatever the manifest names) must import in the fixed sequence `@import "./fonts.css"` → the project's `design.tokens.css` → `@import "tailwindcss"` → the library's `styles.css` → the project's `personality.css` → `@theme inline {…}` — cascade-layer order is fixed at first appearance of each `@layer` name, and `personality.css` is bare `:root`/`.dark` blocks that only *tie* the library's unlayered `:root`/`.dark` (0,1,0), so it wins only by following `styles.css`. File position *is* the styling contract between Tailwind, the component library, and the personality tokens.
+**Detect:** first ~10 lines of the CSS entry, `@import "tailwindcss"`, `@import` of `@nurix/components` styles, the `personality.css` `@import`, `@layer` declarations inside the library CSS
+**Ships green, breaks:** Any reorder compiles and mostly renders — the breakage is visual-only and theme/element-specific: importing the library's `styles.css` before `@import "tailwindcss"` lets preflight's `@layer base` resets land after (and wipe) library button/form styling at equal specificity, and flips which side wins app-utility-vs-library override wars; importing `personality.css` before `styles.css` lets the library's neutral personality defaults win the tie, so the product's density, motion, radius and depth silently revert to neutral. Nothing logs; a form-heavy screen just looks subtly wrong. (`design.tokens.css` writes `:root:not(.dark)`/`:root.dark` at (0,2,0) and wins wherever it sits.)
+**Safe change:** Treat the header as frozen; insert new global stylesheets at a deliberate position relative to `tailwindcss` and the library import, never appended blindly; after any reorder, visual-diff a form-heavy screen in light and dark (`.dark`).
 
 ## date-fns-local-tz — HIGH · serialized-shape
 **Contract:** Datetimes cross the wire as UTC ISO strings or date-only `YYYY-MM-DD`, but date-fns `format()` and accessors operate in the runtime's local timezone — serializer and formatter must agree on the zone, and nothing checks that they do.

package/data/harnesses/code/skills/boundary/references/packs/generic-tail.md

@@ -1,6 +1,6 @@
 # Generic tail — technologies outside the mandated stack
 
-Load when: the touched code exhibits one of these technologies and no dedicated pack covers it. Entries here are deliberately thin — one gotcha and the safe-change essence each; diagnose the rest from the mechanism (see `../mechanisms.md`). When the org adopts one of these seriously, promote its section into a full pack.
+Load when: the touched code exhibits one of these technologies and no dedicated pack covers it. Each entry is one gotcha and the safe-change essence; diagnose the rest from its mechanism in `mechanisms.md`. A technology the org adopts seriously gets its section promoted into a full pack.
 
 ## API styles
 

package/data/harnesses/code/skills/brainstorm/README.md

@@ -12,8 +12,8 @@ commits it.
 
 ## The architecture — one capability, two seats
 
-Prose obligations decay in the conversing seat: the fleet audit behind v3 found the same rules
-dying in every real session, even the successful ones. So the capability is split:
+Prose obligations decay in the conversing seat: an audit of real sessions finds the same rules
+dying in every one, the successful ones included. So the capability is split:
 
 | Seat | Component | Owns |
 | --- | --- | --- |
@@ -27,17 +27,15 @@ line, the twin writes the result — so reconciliation is observable, never asse
 
 ## The session lifecycle
 
-```
-/brainstorm start
-  → basis gate (a document, an old session folder of any format, or a brain dump)
-  → bootstrap docs/research/{topic}-brainstorm/ (ops/ untracked; twin writes the surface)
-  → converse: dump / interview / probe / blindspot / converge — steerable in plain language
-  → "let me read" anytime: compose on demand, read the thesis, come back
-/brainstorm stop
-  → converge → manifest → ONE user approval → apply → uselessness test
-  → folder moves to docs/history/brainstorms/{topic}/ (the completion marker)
-  → the user decides: delete or commit
-```
+- **`/brainstorm start`**
+  1. Basis gate — a document, a prior session folder in any format, or a brain dump.
+  2. Bootstrap `docs/research/{topic}-brainstorm/` — `ops/` untracked; the twin writes the surface.
+  3. Converse — dump, interview, probe, blindspot, converge — steerable in plain language.
+  4. "Let me read" anytime — compose on demand, read the thesis, come back.
+- **`/brainstorm stop`**
+  1. Converge → manifest → **one** user approval → apply → uselessness test.
+  2. The folder moves to `docs/history/brainstorms/{topic}/` — the completion marker.
+  3. The user decides: delete or commit.
 
 The working surface: `thesis.md` (claim → argument → what changed, recomposed whole, stamped),
 `forks.md` (open questions with close conditions — the only convergence currency), `ledger.md`

package/data/harnesses/code/skills/brainstorm/SKILL.md

@@ -9,166 +9,184 @@ Help the user think correctly about a large-scale change, in a record that reads
 pause, and end with a harvest so complete the session folder is useless. You are the
 **facilitator** — the conversation seat of a capability split across two seats:
 
-- **You (this skill, main loop)** hold the conversation. Your only writes: append to
-  `ops/capture.md` every turn, write sync-log dispatch lines, and freeze the basis at intake.
-- **The twin (the `brainstorm` agent, pinned strong tier)** owns the paper: it distills ops into
-  the working surface, recomposes the thesis whole, audits, and drives the harvest. You dispatch
-  it at gates and relay its reports. You never write the working surface yourself — prose
-  obligations decay in the conversing seat; that is the whole architecture.
-- **The detector** (`scripts/detector.mjs`) owns mechanical integrity; the twin runs it.
-
-References — load at the named moments, and read the routed file in full (no skimming to save
-context; this skill is sized by completeness):
-
-- `references/doctrine.md` — when judging what a turn's substance *is* (force, fork, commitment)
-  or how to word what you capture.
-- `references/session-schema.md` — when bootstrapping a session or interpreting detector/twin
-  output.
-- `references/harvest.md` — at `stop`, before orchestrating the pipeline.
+| Seat | Owns | Writes |
+| --- | --- | --- |
+| **You** (this skill, main loop) | the conversation; dispatching the twin at gates and relaying its reports | `ops/capture.md` every turn, the sync-log dispatch lines, the basis at intake — **nothing else** |
+| **The twin** (the `brainstorm` agent, pinned strong tier) | the paper: distilling ops into the working surface, recomposing the thesis whole, audits, the harvest | every other file in the folder |
+| **The detector** (`scripts/detector.mjs`, run by the twin) | mechanical integrity | — |
+
+**Never write the working surface yourself** — prose obligations decay in the conversing seat, and
+the split exists to keep them out of it.
+
+Load each reference at its moment and read it in full — **never skim to save context**; this skill
+is sized by completeness:
+
+| Reference | Load when |
+| --- | --- |
+| `references/doctrine.md` | judging what a turn's substance *is* (force, fork, commitment), or how to word what you capture |
+| `references/session-schema.md` | bootstrapping a session, or interpreting detector or twin output |
+| `references/harvest.md` | at `stop`, before orchestrating the pipeline |
 
 ## The one habit that is yours: capture
 
-Append to `ops/capture.md` **every turn**, both sides, lowest bar — raw notes, not prose:
-what the user said that matters, and your own substance (causal diagnoses, informed rejections of
-options you presented, definitions, reasoning chains behind recommendations), plus residue you
-judge not worth filing. Turn-stamped per the schema (`### T# · <ISO datetime>`). Never distill
-here — distillation is the twin's. If a piece of your reasoning lives only in the chat when the
-twin next dispatches, you leaked it. This habit is also what makes every re-entry cheap: the
-folder plus ops is the session's whole memory.
+Append to `ops/capture.md` **every turn**, both sides, at the lowest bar — raw notes, not prose:
+
+- what the user said that matters;
+- your own substance — causal diagnoses, informed rejections of options you presented,
+  definitions, reasoning chains behind recommendations;
+- residue you judge not worth filing.
+
+Stamp each turn per the schema (`### T# · <ISO datetime>`). **Never distill here** — distillation is
+the twin's. Reasoning that lives only in the chat when the twin next dispatches has leaked. The
+folder plus ops is the session's whole memory, which is what makes every re-entry cheap.
 
 ## `start`
 
-Find sessions by their folders — no index keeps a row per session: `docs/research/*-brainstorm/`
-(active) and `docs/history/brainstorms/*/` (harvested), the folder name being the topic and each
-`thesis.md` heading its subject. Topic matches an active session → resume it
-(re-entry, below). Harvested or prior-generation match → offer it **as a basis** for a fresh
-session. No match → new session.
-
-**1 · The entry gate.** A session needs substance: ask for a **basis** — a reference document
-(path or URL), a prior session folder of *any* format or generation, or a one-shot brain dump in
-prose, now. Information is information: an old v2 brainstorm folder is ingested exactly like a
-PRD — copied into `basis/`, frozen, distilled; never operated on in place, never migrated.
-Drip-sized input (a bug fix, one button) → say this skill is the wrong tool and don't open the
+Find sessions by their folders — **no index keeps a row per session**. Active sessions are
+`docs/research/*-brainstorm/`, harvested ones `docs/history/brainstorms/*/`; the folder name is the
+topic and each `thesis.md` heading its subject.
+
+| Topic matches | Do |
+| --- | --- |
+| an active session | resume it (Re-entry, below) |
+| a harvested session, or a session folder in another format | offer it **as a basis** for a fresh session |
+| nothing | open a new session |
+
+**1 · The entry gate.** A session needs substance. Ask for a **basis**, now:
+
+- a reference document (path or URL);
+- a prior session folder, in any format — ingested exactly like a PRD: copied into `basis/`,
+  frozen, distilled; **never** operated on in place, **never** migrated;
+- a one-shot brain dump in prose.
+
+Drip-sized input (a bug fix, one button): say this skill is the wrong tool, and do not open the
 session unless the user explicitly overrides. No basis, no session.
 
-**2 · Bootstrap.** Folder `docs/research/{topic}-brainstorm/` (kebab slug, confirm in one line).
-Create `ops/` with a `.gitignore` containing `*`, `ops/capture.md`, `ops/sync-log.md`; copy the
-basis into `basis/`. No index row: the folder is the session's entry. Then write the sync-log dispatch
-line and dispatch the twin (gate: start) to write the initial surface — you don't scaffold
-`state.md`/`thesis.md`/`forks.md`/`ledger.md` yourself.
-
-**3 · Calibrate + frame.** Distill the basis first — it seeds everything. Calibrate from the
-living docs (the ownership index, recent decision records, any open-questions doc) so your
-questions match this repo, not a template. Then one `AskUserQuestion` batch: **sitting** (single
-sprint — the default and the shape that succeeds — or explicitly multi), **execution reality**
-(greenfield / brownfield / hybrid — migration gotchas discovered at plan time are discovered too
-late), and **where the idea is right now** (fully in their head → dump; half-formed → interview).
-Propose the **aspect map** — the thinking dimensions for *this* idea, derived from the basis,
-no fixed list; the user edits it; it lives in `state.md`.
-
-**4 · Orient.** 3–4 lines, assuming a first-time user: how the session works (you talk, the
+**2 · Bootstrap.**
+
+1. Name the folder `docs/research/{topic}-brainstorm/` (kebab slug); confirm it in one line.
+2. Create `ops/` holding a `.gitignore` containing `*`, `ops/capture.md`, and `ops/sync-log.md`.
+3. Copy the basis into `basis/`. Add no index row — the folder is the session's entry.
+4. Write the sync-log dispatch line and dispatch the twin (gate: start) to write the initial
+   surface. **Never scaffold** `state.md`, `thesis.md`, `forks.md`, or `ledger.md` yourself.
+
+**3 · Calibrate and frame.**
+
+1. Distill the basis first — it seeds everything.
+2. Calibrate from the living docs (the ownership index, recent decision records, any
+   open-questions doc), so your questions match this repo, not a template.
+3. Ask one `AskUserQuestion` batch:
+   - **sitting** — single sprint (the default, and the shape that succeeds) or explicitly multi;
+   - **execution reality** — greenfield, brownfield, or hybrid; a migration gotcha found at plan
+     time is found too late;
+   - **where the idea is now** — fully in their head → dump; half-formed → interview.
+4. Propose the **aspect map** — the thinking dimensions for *this* idea, derived from the basis,
+   from no fixed list. The user edits it; it lives in `state.md`.
+
+**4 · Orient.** In 3–4 lines, written for a first-time user: how the session works (you talk, the
 folder keeps everything), the steering verbs in plain words, "let me read" (pause and read the
 thesis anytime), and what `stop` does (converge → your approval → harvest → the folder moves and
-you choose delete or commit). Then begin — **always in dump or interview**; probe and converge
-are mid-session moves, never starting postures.
+you choose delete or commit). Then begin — **always in dump or interview**; probe and converge are
+mid-session moves, never starting postures.
 
 ## The moves
 
-Five named, user-steerable interlocution moves — who drives, how much gets asked. No `MODE:`
-field, no switch ceremony, no sanctioned trigger words: **any phrasing that implies a move
-triggers it** ("I want to poke holes" → probe; "what am I missing?" → blindspot; "let's decide"
-→ converge). The first time each
-move fires, name in one line what you're doing. Offer a switch when the signals say so (the user
-monologues mid-interview; every probe answer is "haven't thought about it") — one offer, never
-seized.
-
-- **dump** — user drives. No questions mid-stream. Reflect back the shape, contradictions, and
-  implications as they land — that reflection *is* active listening; never sit silent.
-- **interview** — you drive. `AskUserQuestion` batches of 2–3, scoped to one aspect at a time.
-  Questions derive from the basis and the current surface — never from a template inventory;
-  never interview to fill empty files.
-- **probe** — you challenge: flaws, edge cases, conflicts with the tech fragment or domain
-  fragment. Each finding is noted in ops and moves on — don't demand resolution mid-probe.
-- **blindspot** — hunt unknown unknowns. This move is dispatched, not conversed: you co-built
-  the frame, so the outside view is structurally the twin's — dispatch it (gate: on demand,
-  scope: blindspot) to cold-read the whole surface against the thesis's stated goal. Candidates
-  die at the twin's quality gate (grounded in this folder, material to the design, new,
-  answerable) so the user never over-replies to noise; at most five survivors arrive, each
-  already filed as a fork. Relay them in prose — finding → why it's material here → what
-  answering it would change — never as a question barrage: the user engages what matters and
-  converge burns the rest down later. Don't wait to be asked — a user-only trigger makes
-  coverage depend on the user remembering to ask: self-initiate a pass occasionally, at the
-  moments the frame settles (an aspect closes, a converge burst lands, the thesis materially
-  recomposes), by widening a reconcile dispatch's scope. Self-initiation needs no offer — it
-  seizes nothing; survivors land as forks either way, and zero survivors is one relay line,
-  never manufactured findings.
-- **converge** — burn forks down to commitments or explicit parks. `AskUserQuestion` for picks.
-  Each resolution carries Why + How to apply (the twin files it; you capture it).
+Five user-steerable moves set who drives and how much gets asked. There is no `MODE:` field, no
+switch ceremony, and no sanctioned trigger word: **any phrasing that implies a move triggers it**
+("I want to poke holes" → probe; "what am I missing?" → blindspot; "let's decide" → converge). The
+first time each move fires, name what you are doing in one line. When the signals call for a
+switch (the user monologues mid-interview; every probe answer is "haven't thought about it"), offer
+it once — never seize it.
+
+- **dump** — the user drives. Ask no questions mid-stream. Reflect back the shape, contradictions,
+  and implications as they land — that reflection is the active listening; **never sit silent**.
+- **interview** — you drive. `AskUserQuestion` batches of 2–3, one aspect at a time. Derive the
+  questions from the basis and the current surface — **never** from a template inventory, and
+  **never** interview to fill empty files.
+- **probe** — you challenge: flaws, edge cases, conflicts with the tech or domain fragment. Note
+  each finding in ops and move on; **never** demand resolution mid-probe.
+- **blindspot** — the hunt for unknown unknowns, **dispatched, never conversed**: you co-built the
+  frame, so the outside view belongs to the twin.
+  1. Dispatch the twin (gate: on demand, scope: blindspot) to cold-read the whole surface against
+     the thesis's stated goal. Its quality gate kills any candidate not grounded in this folder,
+     material to the design, new, and answerable; at most five survivors return, each already
+     filed as a fork.
+  2. Relay survivors in prose — finding → why it is material here → what answering it would
+     change — **never** as a question barrage: the user engages what matters, and converge burns
+     the rest down later. Zero survivors is one relay line; **never** manufacture findings.
+  3. Self-initiate a pass, without offering, whenever the frame settles — an aspect closes, a
+     converge burst lands, the thesis materially recomposes — by widening a reconcile dispatch's
+     scope. A user-only trigger makes coverage depend on the user remembering to ask.
+- **converge** — burn forks down to commitments or explicit parks, with `AskUserQuestion` for
+  picks. Each resolution carries Why and How to apply; you capture it, the twin files it.
 
 ## Twin dispatches — the gates
 
-Dispatch at: **start** (bootstrap), **on demand** (below), **pause**, **stop**. One dispatch in
-flight at a time. For every dispatch *you* write the dispatch line to `ops/sync-log.md`
-(`S# | gate: <g> | dispatched: <ts> | scope: <s>`) — the twin appends the result; the pairing is
-how reconciliation stays observable instead of asserted. Relay the twin's one-line report at the
-next turn break ("4 edits · 2 new forks · 6 open · untouched: risks") — the only ambient
-convergence pressure this skill applies — plus what the recompose changed, so a rewrite of the
-user's thinking is never silent. A `failed` result: tell the user plainly and re-dispatch at the
-next gate.
-
-**On demand** means: the user asks ("let me read", "sync up", "what's open?"), or you judge the
-capture has accumulated enough that the surface has fallen meaningfully behind. **"Let me read"**
-is a recognized pause act: dispatch a compose (say honestly that it takes a couple of minutes),
-then point them at `thesis.md` — mandated shape, claim → argument → what changed, stamped — and
-pick the conversation back up when they return. Reading one's own thinking mid-session is a
-designed-for act, not an interruption.
+Dispatch at **start** (bootstrap), **on demand** (below), **pause**, and **stop** — **one dispatch in
+flight at a time**.
+
+1. Before each dispatch, write its line to `ops/sync-log.md`
+   (`S# | gate: <g> | dispatched: <ts> | scope: <s>`). The twin appends the result; the pairing
+   keeps reconciliation observable instead of asserted.
+2. At the next turn break, relay the twin's one-line report ("4 edits · 2 new forks · 6 open ·
+   untouched: risks") plus what the recompose changed — a rewrite of the user's thinking is
+   **never** silent. The report is the only ambient convergence pressure this skill applies.
+3. On a `failed` result, tell the user plainly and re-dispatch at the next gate.
+
+**On demand** means the user asks ("let me read", "sync up", "what's open?"), or you judge the
+capture has outrun the surface meaningfully. **"Let me read"** is a designed-for pause, not an
+interruption: dispatch a compose (say honestly it takes a couple of minutes), point the user at
+`thesis.md` — claim → argument → what changed, stamped — and resume when they return.
 
 ## Re-entry — resume, or context loss
 
-Re-entry is a read, not a reconstruction: re-read this skill's hub, `state.md` (posture line
-first), and the tail of `ops/capture.md`; then dispatch the twin (gate: on demand) for a
-re-brief + freshness audit. This covers three triggers identically: resuming a parked session,
-a new sitting, and **loss of conversational context mid-session (compaction)** — if you find
-yourself mid-session without memory of it, this is the procedure; the folder was built so that
-nothing you "remembered" matters. While a session folder exists, read `state.md` at the start of
-every turn.
+Re-entry is a read, not a reconstruction. It covers three triggers identically: resuming a parked
+session, a new sitting, and **losing conversational context mid-session (compaction)** — finding
+yourself mid-session without memory of it means running this procedure; nothing you "remembered"
+matters.
+
+1. Re-read this hub, `state.md` (posture line first), and the tail of `ops/capture.md`.
+2. Dispatch the twin (gate: on demand) for a re-brief and freshness audit.
+
+While a session folder exists, read `state.md` at the start of every turn.
 
 ## `stop` — the fixed pipeline
 
-Read `references/harvest.md` first. The pipeline always runs — a stop *is* convergence plus
-harvest; you orchestrate, the twin executes each leg:
+Read `references/harvest.md` first. The pipeline **always** runs — a stop *is* convergence plus
+harvest. You orchestrate; the twin executes each leg.
 
-1. **Converge** — every open fork resolved now or explicitly parked with a destination
-   (mini-converge in conversation; the scope-guard trio in `harvest.md` disambiguates parks).
-   If no blindspot round has run this session, offer one first (one offer, never seized) — an
-   unknown unknown found after commitments freeze is the expensive kind.
-2. **Final sync + manifest** — dispatch the twin (gate: stop). It builds the manifest only when
+1. **Converge** — resolve every open fork now, or park it explicitly with a destination
+   (mini-converge in conversation; the scope-guard trio in `harvest.md` disambiguates parks). If no
+   blindspot round has run this session, offer one first, once — an unknown unknown found after
+   commitments freeze is the expensive kind.
+2. **Final sync and manifest** — dispatch the twin (gate: stop). It builds the manifest only when
    the detector's manifest gate is clean; relay anything blocking.
-3. **One approval** — present the manifest via `AskUserQuestion`. Gap rounds later re-enter here:
-   every write to canonical docs is user-approved, no exceptions.
-4. **Apply → uselessness test → move** — the twin's legs; relay results. Harvest fails loud:
-   a partial apply leaves the folder visibly unfinished in `docs/research/` and the user restarts
-   the stop — never resume silently.
-5. **The offer** — after the move to `docs/history/brainstorms/{topic}/`: **delete the folder, or
-   commit it** — the user decides; the design assumes deletion. Relay via `AskUserQuestion`.
+3. **One approval** — present the manifest via `AskUserQuestion`. Gap rounds re-enter here: every
+   write to canonical docs is user-approved, **no exceptions**.
+4. **Apply → uselessness test → move** — the twin's legs; relay the results. Harvest fails loud: a
+   partial apply leaves the folder visibly unfinished in `docs/research/` and the user restarts the
+   stop — **never** resume silently.
+5. **The offer** — after the move to `docs/history/brainstorms/{topic}/`, ask via
+   `AskUserQuestion`: **delete the folder, or commit it**. The user decides; the design assumes
+   deletion.
 
 ## Conduct — holds for the whole session
 
-1. **Speak plain English; codes live in files.** Name every item by what it is; append the code
-   in parentheses only when traceability needs it ("…the timeout question (F2)"). Never lead
-   with a bare `F3`/`D7`.
-2. **No production code outside the session folder while open.** Illustrative snippets live in
-   the folder. Asked for production code: offer a sketch inside the folder, or `/brainstorm stop`
+1. **Speak plain English; codes live in files.** Name every item by what it is, with the code in
+   parentheses only where traceability needs it ("…the timeout question (F2)"). **Never** lead with
+   a bare `F3`/`D7`.
+2. **No production code outside the session folder while it is open.** Illustrative snippets live
+   in the folder. Asked for production code, offer a sketch inside the folder, or `/brainstorm stop`
    first.
-3. **`AskUserQuestion` at exactly four sites:** the intake frame batch, interview batches,
-   converge picks, and the stop approvals (manifest; delete-or-commit). Everywhere else, prose.
+3. **`AskUserQuestion` at exactly four sites:** the intake frame batch, interview batches, converge
+   picks, and the stop approvals (manifest; delete-or-commit). Everywhere else, prose.
 4. **Suggested, never seized.** Moves, abstractions, probes — one offer each; accept refusal
-   without re-litigating. Exemption: a self-initiated blindspot dispatch — it takes no
-   conversational control; its findings arrive as forks the user may simply ignore.
-5. **Nothing lives only in the transcript.** Ops is the floor: if it isn't in the folder or in
-   ops, it doesn't exist. Flaws, gaps, and contradictions surface to the twin as capture — the
-   twin turns them into forks; forks are the only convergence currency.
-6. **The user decides when to converge and when to stop.** Distance-to-coherent is visible in
-   every relayed twin report; you never say "let's decide now."
+   without re-litigating. The one exemption is a self-initiated blindspot dispatch: it takes no
+   conversational control, and its findings arrive as forks the user may ignore.
+5. **Nothing lives only in the transcript.** What is not in the folder or in ops does not exist.
+   Flaws, gaps, and contradictions reach the twin as capture; the twin turns them into forks, the
+   only convergence currency.
+6. **The user decides when to converge and when to stop.** Distance-to-coherent is visible in every
+   relayed twin report; **never** say "let's decide now."
 7. **Only `/brainstorm start` and `/brainstorm stop` enter or leave a session.** No
    auto-invocation, ever.