devrites 5.10.1 → 5.11.0

package/pack/generated/devin/skills/devrites-prose-craft/reference/structures.md

@@ -0,0 +1,196 @@
+# Structures to avoid
+
+The sentence- and paragraph-level shapes that mark machine-written prose. Each row is a
+pattern and its fix. Calibrated: the slop is the *decorative* version; the genuine structural
+version (a real enumeration, a real contrast that carries information) stays.
+
+## Negative parallelism — the "not X, it's Y" family
+
+The single most recognizable tell. It mimics insight by manufacturing a contrast.
+
+| Pattern | Fix |
+|---|---|
+| "It's not X, it's Y." / "It isn't X. It's Y." | State Y. "Y is the cause." |
+| "Not just X, but Y." / "Not only X but also Y." | State both plainly, or just Y if X is filler. |
+| "The question isn't X. It's Y." | Ask the real question once, or state the answer. |
+| "This isn't about X. It's about Y." | "This is about Y." |
+| "X isn't the problem. Y is." | "Y is the problem." |
+| "No X. No Y. Just Z." | "Z." or a normal sentence naming Z. |
+| Negation chain: "No fluff, no filler, no jargon." / "It didn't ask. It didn't wait." | Say what the thing is. One negation earns its place when the reader would assume the opposite; a drumroll of them does not. Carve-out: factual inventories ("takes no arguments, no headers, and no body") stay. |
+
+Drop the negation; lead with the thing you actually mean.
+
+## Rule of three / decorative tricolon
+
+AI defaults to three-item adjective or benefit triplets. The fix depends on whether the three
+items are *real*.
+
+- **Decorative triad** — "innovative, transformative, and groundbreaking", "fast, reliable, and
+  scalable" as a flourish → cut to the one that's true and provable, or delete.
+- **Real enumeration** — three acceptance criteria, three slices, three status codes the
+  endpoint returns → **keep all three.** This is precision, not slop. The technical register
+  needs the complete list.
+
+Test: if removing one item loses information a reader needs, it's a real list — keep it. If the
+three are interchangeable adjectives, it's a triad — cut it.
+
+## Importance inflation
+
+Announcing significance instead of showing it. Let the reader judge weight.
+
+| Pattern | Fix |
+|---|---|
+| "a pivotal moment", "a broader movement" | Describe what happened; drop the significance label. |
+| "The implications are significant." | Name the specific implication. |
+| "This is a critical step." | Show why it's required (the dependency, the gate, the risk). |
+
+## Vague attribution — cite the source or drop it
+
+The prose twin of DevRites's evidence discipline (`devrites-source-driven`, `evidence.md`). An
+unnamed authority is not a source; it inflates one person's claim into consensus.
+
+| Pattern | Fix |
+|---|---|
+| "Experts believe…", "Studies show…", "Research suggests…" | Name the study/doc/benchmark, or cut the appeal and state the claim on its own merits. |
+| "Best practice says…", "The community recommends…", "It's widely agreed…" | Link the source (an RFC, the framework docs, a measured result), or make the call yourself and own it in `decisions.md`. |
+
+If you can't name who holds the view, you don't have a source — you have a guess. State it as one.
+
+## Abstract category nouns — name the specific items
+
+"Various factors", "several considerations", "a number of issues" say nothing. Replace the
+category word with the actual items.
+
+| Pattern | Fix |
+|---|---|
+| "improvements across various metrics" | "cuts p95 latency 120ms→80ms and halves the query count" |
+| "there are several considerations" | List the considerations, or name the one that matters. |
+| "performance issues", "some edge cases" | Name the N+1 query; name the empty-input and the 10k-row cases. |
+
+Offender words to catch: factors, aspects, considerations, issues, elements, things, areas,
+metrics (unnamed). In a spec or `decisions.md`, the specific item is the whole point.
+
+## False agency — name who acts
+
+Giving inanimate things human verbs. Common in machine prose because it avoids naming the actor.
+
+| Pattern | Fix |
+|---|---|
+| "the data tells us" | "the grader reads X and returns Y" |
+| "the decision emerges" | "we chose X because…" |
+| "the complaint becomes a fix" | "the team fixed it in slice 3" |
+| "the test ensures correctness" | "the test asserts `total === 42`" |
+
+Front the actor: the script, the gate, the function, the engineer, or "you".
+
+## Dramatic fragmentation & rhetorical setups
+
+| Pattern | Fix |
+|---|---|
+| "[Noun]. That's it. That's the [thing]." | One complete sentence. |
+| "X. And Y. And Z." (staccato for drama) | Join into normal sentences; vary length. |
+| "The result? Devastating." (self-posed Q&A) | Fold into a statement. |
+| "What if [reframe]?" as a hook | Make the point directly. |
+| "Think about it:" / "Here's what I mean:" | Delete; the next sentence already does the work. |
+| Performed insight: "that's not nothing", "the punchline is", "sit with that", "that's the whole point", "Turns out…" | State the claim the phrase was gesturing at. One hit can be voice; several in one piece is a tell. |
+
+## Inflated constructions
+
+Three small tells that pad a plain sentence into something that sounds weightier than it is.
+
+| Pattern | Fix |
+|---|---|
+| **Copula-dodge** — "X serves as / functions as / stands as / boasts / features…" | Use the plain verb. "The gateway **is** the entry point", "the module **has** three handlers". |
+| **Participle tail** — "…, highlighting its importance", "…, reflecting broader trends", "…, underscoring its role as a dynamic hub" | Cut the trailing `-ing` clause; it adds fake depth, not information. |
+| **Aphorism formula** — "X is the Y of Z" ("caching is the heartbeat of the system"), "X is not a tool but a Y" | State the actual property. "The cache holds the hot rows so the DB isn't hit on every request." |
+| **Invented concept label** — coining a pseudo-term as if it's established: "the N+1 tax", "the supervision paradox", "the abstraction trap" | Name the concrete thing and skip the coined label, or define it once if it genuinely recurs. |
+
+## Passive voice (prose register)
+
+Every prose sentence wants a subject doing something. Passive hides the actor and drains energy.
+
+| Pattern | Fix |
+|---|---|
+| "It was decided that…" | "We decided…" |
+| "Mistakes were made." | Name who, and what. |
+| "The endpoint is called by the client." | "The client calls the endpoint." |
+
+Calibration: passive is fine when the actor is genuinely unknown or irrelevant ("the row is
+deleted on cascade"). Don't contort a sentence to name an actor that doesn't matter.
+
+## Rhythm
+
+- Don't run three same-length sentences in a row; don't stack three short fragments for effect.
+- Don't end every paragraph on a punchy one-liner. Vary where the weight lands.
+- **Em-dashes:** at most one per paragraph, used where a comma or period won't do. Multiple per
+  paragraph is the tell. (Catch both the em-dash `—` and the `--` substitute.)
+- Don't open consecutive sentences with the same Wh- word ("What makes this… What this means…")
+  as a crutch; lead with the subject.
+
+## Formatting tells
+
+- **No "Bold term: explanation" bullet lists** as the default structure for prose — the most
+  recognizable AI formatting pattern. Use real prose, or a plain bullet, unless the document's
+  existing style genuinely uses definition lists (a glossary, an API reference).
+- No emoji in headings or section titles (artifacts and code both).
+- Don't over-bold. Bold the one load-bearing term, not every noun.
+
+## Reasoning-chain scaffolding
+
+Internal monologue leaking into published prose. The reader needs the conclusion and the
+evidence, not the tour of how the model thought.
+
+| Pattern | Fix |
+|---|---|
+| "Let me think step by step", "Breaking this down", "To approach this systematically" | State the conclusion, then the evidence. |
+| "Here's my thought process", "Working through this logically", "Step 1:" as inner narration | Numbered *argument* stays; numbered *self-talk* goes. |
+
+A `review.md` finding that walks error paths in order is an argument. A chat reply that
+announces "First, let's consider…" is scaffolding.
+
+## Narrated candor
+
+Announcing that you are about to be honest, instead of being honest.
+
+| Pattern | Fix |
+|---|---|
+| "I want to be upfront:", "To be fully transparent:", "Two caveats I would rather flag than let you discover later:" | "Two caveats:" plus the caveats. |
+| "Rather than bury this, I'll say it plainly:" | Say it. |
+
+**Deletion test.** Cut the frame. If nothing is lost, it was never content.
+
+**Keep:** the disclosure itself ("I haven't tested this on Windows"), and a real
+conflict-of-interest label ("I own shares in the company discussed here").
+
+## Prompt restatement and recap-flattery
+
+| Pattern | Fix |
+|---|---|
+| "You're asking about…", "To answer your question…", "That's a great question. The…" | Answer. The reader knows what they asked. |
+| Recap-flattery: restating the other person's own work back at them as praise before the point | Substance first. If thanks is warranted: one plain clause, no recap. |
+
+Distinct from sycophancy ("Great question!"), which validates the reader without recapping
+their work.
+
+## Self-labeling significance
+
+After listing items, pointing back and labeling one as contrarian / clever / the real story.
+
+| Pattern | Fix |
+|---|---|
+| "That last move is the contrarian one." / "This is the interesting part." / "The third bullet is the real story." | Put the load-bearing item first, or expand it with specifics, and cut the label. |
+
+If the move is actually contrarian, the description already shows it. The label is unearned
+when the reader cannot see the contrast without it.
+
+## Diff-anchored writing
+
+Docs or comments narrating the edit instead of describing the thing as it is.
+
+| Pattern | Fix |
+|---|---|
+| "This function was added to replace the previous approach of iterating through all items." | "This function uses a hash map for O(1) lookups." |
+
+**Carve-out:** changelogs, release notes, migration guides, and `decisions.md` narrate
+change on purpose. Leave them. The tell is a README, comment, or spec overview written as
+archaeology of the last diff.

package/pack/generated/devin/skills/devrites-source-driven/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: devrites-source-driven
+description: Verify uncertain framework or library behavior in installed source or official docs. Use for unfamiliar APIs; not internal code.
+triggers:
+  - model
+---
+
+# devrites-source-driven: verify, don't guess
+
+When library behavior matters and is uncertain, verify it against installed source or
+authoritative documentation before relying on it.
+
+## When to trigger
+- You're about to rely on an API signature, default, config key, or behavior you're not
+  sure of.
+- The docs in memory might be stale (the project pins a different version).
+- Tests can't easily prove the assumption, but it drives the implementation.
+- An error message points at framework behavior you don't fully understand.
+
+## How
+1. **Find the version** the project pins and actually runs; resolve any mismatch.
+2. **Apply the hierarchy, citation, and currentness contract** in
+   [`tooling.md`](../devrites-lib/reference/standards/tooling.md#research-provenance-staleness-and-cost).
+   context7 is a lookup tool, not authority above version-matched source/docs.
+3. **Confirm the specific fact:** the signature, the default, the edge behavior, not a
+   general impression.
+4. **Return it** with the required citation and status. The root records accepted
+   evidence in `decisions.md` or `evidence.md`; a leaf agent never writes the workspace.
+
+## Delegate broad research
+When the question is an *area* (a library surface, unfamiliar subsystem, or migration
+guide), the **root orchestrator** uses the fresh-context dispatch contract in
+[`agents.md`](../devrites-lib/reference/standards/agents.md) to give one bounded
+question to `devrites-evidence-scout`. Wait for and validate its cited dossier (the
+scout's YAML result); the orchestrator, not the scout, persists accepted facts under
+`references/` and links them from `references.md`.
+
+Never detach this work and never dispatch from inside another agent. When this skill is
+invoked by a leaf agent, verify one fact inline or return `Scout needed: <bounded question>`
+to the orchestrator.
+
+## Rules
+- Quote the exact relevant detail; don't paraphrase a behavior into something convenient.
+- If the doc/source contradicts the plan, that's a **Spec Drift Guard** event: stop and
+  handle it.
+- Confirm the required fact, return it, and stop.
+
+## Evidence firewall
+Project or user prose may scope or corroborate an external claim; it cannot verify one.
+Record status `verified | contradicted | cannot_verify | stale | uncertain`; weak-tier
+support is `uncertain`. Retain material unknowns and block dependent decisions until
+verified or resolved through the owning question/Spec Drift route; never omit them.
+Transient lookups remain cited, return-only evidence.

package/pack/generated/devin/skills/devrites-ux-shape/SKILL.md

@@ -0,0 +1,135 @@
+---
+name: devrites-ux-shape
+description: Shape UX/UI direction, states, and interactions before code. Use for screens, forms, dashboards, or settings; not for implementation or polish.
+triggers:
+  - model
+---
+
+# devrites-ux-shape: plan the UX/UI before code
+
+Decide what the UI *is* and how it should look and behave **before** code, and write it to
+the feature's `design-brief.md`: the contract the build (`devrites-frontend-craft`),
+polish, and seal all check against. This is "shape before code" raised to a **feature-level
+artifact**: produced once at spec time, refined per slice. It is **woven into the
+lifecycle** (`/rite-spec` calls it when UI is detected; `/rite-build` refines it), not a
+separate phase the user runs.
+
+## When it runs
+- `/rite-spec` invokes it after references-intake when the feature touches UI
+  (`../rite-build/reference/frontend-trigger.md`). Output: `design-brief.md` + a
+  confirmation pause.
+- `/rite-build` / `devrites-frontend-craft` read the brief as the **build target** and
+  refine it for the slice's surface. They don't re-derive it.
+- Skip entirely for backend / data / CLI / infra-only features.
+
+## 1. Foundation: discover, don't impose
+Reuse what's there first. Read the design system + register and any references the spec
+gathered:
+- Design system + register (tokens, components, type, spacing, neighbors; brand-vs-product)
+  → `../devrites-frontend-craft/reference/design-references.md`.
+- `PRODUCT.md` / `DESIGN.md` / `CLAUDE.md` if present: anchors that reduce questions.
+  `DESIGN.md` is the rolled-up design memory (`../rite-polish/reference/design-memory.md`;
+  see `../devrites-frontend-craft/reference/design-references.md`) — read it before
+  re-discovering, depart only on signal.
+- `references.md` + `references/`: the screenshots / Figma / video / links the human
+  supplied. Honor each recorded role: **target** = fidelity contract, **constraint** =
+  required rule, **inspiration** = extract only the cited principle.
+
+## 2. Discovery: one round, assert-then-confirm
+Understand the feature deeply enough to make excellent design calls: **no code, no
+markup**. Use the `devrites-interview` cadence: one question per turn (≤3 per pass),
+best-guess attached, stop when answers converge. One round is the default; add a second only for
+material gaps. When `PRODUCT.md` + the spec already pin an answer, **assert it and ask to
+confirm** ("reads as Restrained: confirm?"), don't offer a four-option menu. Cover:
+- **Purpose & user:** who, in what state of mind (rushed / exploring / anxious / focused).
+- **Content & data:** realistic ranges (0 / typical / many), dynamic content, real
+  media/assets the surface needs.
+- **Preserve + anti-goals:** identity, IA, behavior, content voice, SEO/analytics hooks,
+  existing accessibility wins, or assets that must survive; what this must NOT become;
+  the biggest risk of getting it wrong.
+
+## 3. Design direction: the direction set (commit, don't hedge)
+One deliberate visual decision on five fronts, each anchored in an existing reference so
+the call is checkable, not taste:
+- **Scene sentence:** who / where / ambient light / mood, per
+  `../devrites-frontend-craft/reference/design-references.md`. Forces dark-vs-light and
+  tone from the scene, not the category.
+- **Color strategy:** Restrained / Committed / Multi-role / Saturated, per the
+  color-commitment table in `../devrites-frontend-craft/reference/quality-standards.md`.
+  Pick from the scene; register doesn't decide it.
+- **Calibration:** density (Airy / Balanced / Dense) and motion (Minimal / Standard /
+  Expressive), per the calibration table in the same quality-standards file. Set both from
+  the scene so the build targets a calibration, not a guess (a 2am SRE → Dense + Minimal; a
+  launch hero → Airy + Expressive).
+- **Named anchor references:** 2-3 *specific* products / brands / objects to steer toward
+  (not adjectives like "modern" or "clean"), plus the saved `references/` files.
+- **Visual thesis:** the focal point and hierarchy in one sentence, plus one memorable
+  move (or `none — system continuity`) and the obvious-but-wrong direction rejected. This
+  creates intentional distinction without forcing novelty into product UI.
+
+Respect the existing identity (default, ~90%); depart only on an explicit signal.
+
+## 4. Scope: task-scoped, never persisted
+Name the output target so sketch-vs-ship isn't guessed: **fidelity** (sketch / mid-fi /
+high-fi / production. DevRites default is production), **breadth** (one screen / a flow /
+a surface), **interactivity**, **time intent**. These ride in the brief only; they do not
+change the project's design system, and never get written to `PRODUCT.md` / `DESIGN.md`.
+
+## 5. Key states + interaction model
+List every state the feature needs and what the user must see/feel in each (default,
+loading initial+subsequent, empty→next-action, error→recovery, success, disabled/
+no-permission, long-content/overflow), the information hierarchy (what's seen 1st / 2nd /
+3rd; primary action unmistakable), responsive reflow, a11y must-haves, and the interaction
+model (inline vs navigated vs (rarely) modal; optimistic vs pending; feedback). Name the
+representative states, viewports, input modes, and target R-ids that will prove the result;
+"looks polished" is not a proof target. Canonical state list:
+`../devrites-frontend-craft/reference/shape.md`.
+
+## 6. Visual-direction probe: capability-gated
+When the work is net-new or directionally ambiguous and fidelity ≥ mid-fi, pressure-test
+the lane with something concrete instead of words: pull Figma context, generate image
+probes, screenshot reference sites, or route a code-fidelity question to `/rite-prototype`.
+**Capability-gated**: announce the skip in one line if no tool is available. Flow:
+[reference/visual-direction-probe.md](reference/visual-direction-probe.md).
+
+## 7. AI-slop pre-check
+Run the two-altitude category-reflex check (`../rite-polish/reference/anti-ai-slop.md`) on
+the chosen direction *before* writing the brief, if the palette/theme is guessable from
+the category, rework the scene sentence and color strategy. Cheaper to catch the slop in
+the brief than in the build.
+
+## 8. Write the brief + gate
+Write `design-brief.md` ([reference/brief-template.md](reference/brief-template.md)):
+**compact** (3-5 bullets) when discovery was crisp, **full** when the surface is ambiguous
+or multi-screen. Don't pad a clear brief to look thorough; don't skip the pause to look
+fast. Then honor the run mode (`../devrites-lib/reference/standards/afk-hitl.md`):
+- **HITL:** present the brief and **STOP for explicit confirmation**. The pause is the
+  point: shape ends at the user's "go", not at your own certainty. Disagreement → revisit
+  the relevant discovery question.
+- **AFK:** assert the best-guess direction, record it in `decisions.md` + an advisory
+  `questions.md` entry, and proceed. A direction touching the irreversible-risk list still
+  pauses.
+
+Completion: the smallest useful brief exists; primary action, states, interaction, proof
+targets, and reference role/usage are explicit; the run-mode gate is resolved. Only then may
+UI code start.
+
+## Output
+```
+UX/UI shaped: <slug>
+Direction: <color strategy> · density <airy|balanced|dense>/motion <minimal|standard|expressive> · "<scene sentence>" · anchors: <ref A, ref B>
+States: <n listed>   Probe: <figma | images | prototype | skipped — no tool>
+Brief: design-brief.md (<compact | full>)
+Gate: <confirmed | awaiting confirmation | AFK-asserted>
+Next: /rite-define (UI slices map to the brief's states) — or /rite-build refines it per slice
+```
+
+## NEVER (ux-shape)
+- Never write code, markup, or a component here: produce the thinking, not the UI.
+- Never finalize the brief without naming the **primary action** and the **full state set**
+  (not just the happy path).
+- Never decide visual direction by taste when the project has a system: discover first.
+- Never treat an **inspiration** reference as a fidelity target: honor its recorded role.
+- Never skip the HITL confirmation pause "because the brief is obviously right": ask once,
+  wait.
+- Never re-derive the brief from scratch in `/rite-build`: refine the existing one.

package/pack/generated/devin/skills/devrites-ux-shape/reference/brief-template.md

@@ -0,0 +1,108 @@
+# `design-brief.md` template: the UX/UI contract
+
+The feature-level design decision, produced **before** code by `devrites-ux-shape` (at
+`/rite-spec` when UI is detected) and the **target** the build, polish, and seal check
+against. `devrites-frontend-craft` refines it per slice and appends build-time decisions;
+it is never re-derived from scratch.
+
+Pick the shape by how clear the answers are. **Compact** is the default for a crisp prompt;
+**full** when the surface is ambiguous, multi-screen, or the user asked to shape it as a
+step. Don't pad a clear brief into a long one to look thorough.
+
+## Compact form (default)
+```markdown
+# Design brief: <feature>
+Slug: <kebab>   Shaped: <iso>   Register: brand | product   Fidelity: <sketch|mid-fi|high-fi|production>
+
+- **Building**: <one line — what + who it's for + the primary action>
+- **Thesis**: <focal point + hierarchy> · memorable move: <one move | none — system continuity> · preserve/avoid: <identity + anti-goal>
+- **Direction**: <color strategy> · density <airy|balanced|dense>/motion <minimal|standard|expressive> · "<scene sentence>" · targets: <R-ids> · constraints: <R-ids> · inspiration: <R-ids>
+- **Locks**: accent <token> · radius <scale> · theme <light|dark>
+- **States**: <the states this surface needs, comma-listed>
+- **Interaction**: <inline / navigated / modal · feedback · entry→completion in a phrase>
+- **Proof**: <states × viewports × input modes; target R-ids; zero material visual mismatches>
+- **Confirm or override?** <the one or two things you still want the user to confirm>
+```
+
+## Full form
+```markdown
+# Design brief: <feature>
+Slug: <kebab>   Shaped: <iso>   Register: brand | product
+
+## 1. Summary
+What this is, who it's for, what it must accomplish, what existing identity/behavior must
+survive — including IA, content voice, SEO/analytics hooks, and accessibility wins — and
+the anti-goal (2-3 sentences).
+
+## 2. Primary action
+The single most important thing the user does or understands here. Everything else is secondary.
+
+## 3. Design direction
+- Color strategy: Restrained | Committed | Multi-role | Saturated — why (from the scene, not the category).
+- Calibration: density Airy | Balanced | Dense · motion Minimal | Standard | Expressive — from the scene (`../../devrites-frontend-craft/reference/quality-standards.md` — Calibration).
+- Scene sentence: "<who uses it, where, under what light, in what mood>".
+- Visual thesis: <focal point + 1st/2nd/3rd hierarchy> · memorable move: <one | none — system continuity>.
+- References by role: targets <R-ids> · constraints <R-ids> · inspiration <R-ids>.
+- Locks: one accent <token> · one radius scale · one theme — held page-wide
+  (`../../devrites-frontend-craft/reference/quality-standards.md` — Consistency locks).
+- Rejected direction: <the obvious-but-wrong direction + why>.
+- Departure: default (preserve identity) | departing because <explicit signal>.
+
+## 4. Scope  *(task-scoped — not persisted to PRODUCT.md / DESIGN.md)*
+Fidelity · breadth · interactivity · time intent.
+
+## 5. Layout & hierarchy
+What gets emphasis; what's seen 1st / 2nd / 3rd; how information flows. Hierarchy, not CSS.
+
+## 6. Key states
+Every state + what the user needs to see and feel:
+| State | User sees / feels | Notes |
+|---|---|---|
+| default / populated | | |
+| loading | | initial + subsequent |
+| empty | | welcoming + the next action |
+| error | | what happened + how to recover |
+| success | | |
+| disabled / no-permission | | |
+| long-content / overflow / many items | | |
+
+## 7. Interaction model
+Inline vs navigated vs (rarely) modal; optimistic vs pending; focus & keyboard; feedback on
+every action; the flow from entry to completion.
+
+## 8. Content & copy
+Labels, empty/error messages, microcopy in the product's voice. Realistic dynamic ranges.
+For image-led surfaces: required media roles + likely source (project asset / generated /
+SVG-CSS / icon library / accepted omission) and the shippable provenance/usage recorded in
+`references.md`.
+
+## 9. Responsive & a11y
+Reflow 320→1440 (what stacks / collapses / scrolls); focus order, labels, contrast,
+keyboard, target size. Floor: `../../devrites-frontend-craft/reference/quality-standards.md`.
+
+## 10. Visual-direction probe
+Which probe ran (figma / images / prototype / skipped — no tool), which direction won, what
+changed in the brief because of it. Artifacts saved under `references/`.
+
+## 11. Proof targets
+Representative states × viewports × input modes, the target R-ids or brief rules each
+render is compared with, and the exact interaction/accessibility checks. A visual pass
+requires zero unresolved **material** mismatch; accepted departures are recorded below.
+
+## 12. Open questions
+Genuinely unresolved only. If you'd write "Recommend: X", decide X instead.
+
+## Build-time refinements  *(appended by devrites-frontend-craft per slice)*
+- SLICE-001: <decision made while building this surface + why>.
+```
+
+## How downstream phases use it
+- `/rite-define`: UI slices map to the **Key states**, **Interaction model**, and **Proof
+  targets**; each UI slice names the visual acceptance it proves.
+- `/rite-build` + `devrites-frontend-craft`: build **to** the brief; refine per slice;
+  append refinements above instead of re-deriving.
+- `/rite-prove` + `browser-evidence.md`: render the proof targets, compare against the
+  brief + target references, and close material deltas.
+- `/rite-polish`: Phase 4 reads the brief so polish honors the agreed direction.
+- `/rite-seal` + `devrites-frontend-reviewer`: check the UI matches the brief (states
+  covered, direction held, references matched).

package/pack/generated/devin/skills/devrites-ux-shape/reference/visual-direction-probe.md

@@ -0,0 +1,48 @@
+# Visual-direction probe: test the lane before the brief locks
+
+Before finalizing `design-brief.md`, pressure-test the visual direction with something
+concrete instead of words, *when it will clarify the brief*. This is the
+DevRites-native answer to "build it according to the design (Figma, images)": show a
+direction, get a reaction, then write the brief.
+
+## When to run (all true)
+- The work is **net-new** or directionally **ambiguous**. An existing surface or an
+  approved reference classified **target** already fixes the direction → skip.
+- Fidelity is **mid-fi or higher**. Sketch-only planning → skip.
+- A probe tool is available (below). **Capability-gated**: never ask the user to
+  install APIs or tooling. If none is available, **announce the skip in one line** and
+  proceed to the brief. The one-line announcement is required; it forces a conscious choice
+  instead of letting the step quietly evaporate.
+
+## Pick the probe by what's available (first match)
+1. **Figma reference supplied** → pull design context with the Figma integration (frames,
+   tokens, components, a screenshot of the target). Record what it dictates. A Figma frame
+   that conflicts with the project's design system is a **question for the user**, not a
+   silent choice.
+2. **Native image generation available** (Figma Make, an image-gen MCP, computer-use, or
+   similar) → generate **2-4 distinct direction probes** from the discovery answers (color
+   strategy, scene sentence, anchors). They must differ in **primary direction**:
+   hierarchy, density, typographic voice, topology, not just palette tweaks. Treat them as
+   *direction tests*, not final UI.
+3. **A code-fidelity question** ("which of these layouts works in our stack") →
+   route to **`/rite-prototype`** (2-4 real UI variations on one throwaway route). Prototype
+   is DevRites' existing tool for this; don't rebuild it here.
+4. **Reference sites / links only** → screenshot them (`devrites-browser-proof` tooling)
+   and read the relevant intent (tone, density, interaction).
+5. **Nothing available** → one-line skip, proceed.
+
+## How to use the result
+- Ask which direction feels closest, what's off, what carries forward. Don't treat
+  generated imagery as final UX, copy, or accessibility behavior.
+- If the probe reveals a mismatch, revise the **discovery inputs** (scene sentence, color
+  strategy, anchors) *before* writing the brief. That's the whole point of probing.
+- Save probe artifacts (generated images, Figma exports, screenshots) into
+  `.devrites/work/<slug>/references/`, index them in `references.md` with what each shows,
+  and note the winning direction in the brief's **Visual-direction probe** section.
+
+## Limits
+- Don't skip discovery because image generation is available.
+- Don't run a probe for a minor refinement of existing work. It's for shaping a new
+  surface or a big directional choice.
+- Don't block the brief on a slow or failing tool: try once, then skip with the one-line
+  note.