@etus/seven-skill 0.1.0-beta.3 → 0.1.0-beta.4

package/.cursor/skills/seven/reference/critique.md

@@ -0,0 +1,53 @@
+# Critique — visual and product judgment
+
+Critique a rendered Seven surface, prioritize what materially weakens it, and persist the result for later work. Critique reports by default; it does not edit unless the user separately authorizes a fix scope.
+
+## Keep two evidence lanes independent
+
+Do not let a lint finding predetermine the visual judgment.
+
+### Lane A — rendered assessment
+
+Inspect the real target at representative desktop and mobile widths, plus dark mode when supported. Use real product content when available. Record evidence for:
+
+- task clarity and primary-action hierarchy;
+- information architecture and reading order;
+- composition, density, alignment, rhythm, and use of space;
+- typography, semantic color, component/variant choice, and Seven identity;
+- interaction feedback, focus, keyboard path, and state continuity;
+- loading, empty, error, success, disabled, permissions, long copy, and large data;
+- responsive reflow, overflow, clipping, and touch affordances;
+- whether the surface feels specific to the product rather than generically generated.
+
+### Lane B — mechanical evidence
+
+Run `seven check --file <target>` or `seven check <url>` and relevant tests. Record rule IDs, files, lines, browser errors, and reproducible steps. A clean scan is a floor, not a visual endorsement.
+
+Only after both lanes are complete should you synthesize them.
+
+If the evidence supports multiple genuinely different corrections and the user asks to compare them, read [visual-probes.md](visual-probes.md). Keep critique reporting-only until a direction and edit scope are explicitly accepted.
+
+## Prioritization
+
+- **P0:** blocks the primary job, creates data loss/security risk, or makes the surface inaccessible.
+- **P1:** materially harms comprehension, completion, responsive use, or Seven consistency.
+- **P2:** meaningful quality or maintainability issue with a usable workaround.
+- **P3:** optional refinement; do not let it displace P0–P2 work.
+
+For each finding include: priority, concise title, evidence, affected user/job, Seven component/token/rule involved, root cause, recommended direction, and verification criterion. Separate facts from judgment.
+
+Score 0–100 only after findings are written: task clarity 25, hierarchy/composition 20, component/token fidelity 20, states/accessibility 20, responsiveness/performance 15. The score summarizes evidence; it never replaces it.
+
+## Persistence
+
+Persist the critique through:
+
+```bash
+node .cursor/skills/seven/scripts/critique-storage.mjs write --target <target> --input <review.json>
+```
+
+The stored JSON must include `schemaVersion`, `createdAt`, `target`, `surface`, `release`, `score`, priority summary, evidence lanes, findings, and verification. The script also writes a readable Markdown sibling under `.seven/reviews/`. Never store screenshots or secrets there by default.
+
+## Completion
+
+Lead with the highest-priority findings, then the score and strengths worth preserving. Link the persisted review. Offer a scoped `polish` pass; do not begin it automatically.

package/.cursor/skills/seven/reference/delight.md

@@ -0,0 +1,30 @@
+# Delight — useful product-specific detail
+
+Add a restrained moment that improves confidence, comprehension, recovery, or a sense of progress. Delight is not decoration and never outranks the primary job.
+
+## Find an earned moment
+
+Look for one of these:
+
+- a successful high-effort action that deserves clear acknowledgment;
+- a first-use moment where a concrete example removes uncertainty;
+- a transition whose continuity is currently confusing;
+- a dense workflow where a smart default or preview saves effort;
+- domain-specific microcopy or data formatting that makes the product feel attentive;
+- an empty state that can directly start the next action.
+
+State the user benefit in one sentence. If it is only “looks more fun,” stop.
+
+## Implement within Seven
+
+- Prefer better timing, copy, preview, progressive disclosure, saved context, or one purposeful microinteraction.
+- Use existing Seven components, icons, semantic tokens, and motion rules.
+- Keep feedback interruptible and non-blocking. Success must not make expert users wait.
+- Respect reduced motion, sound/autoplay preferences, and assistive technology announcements.
+- Make the detail work with real product data and adverse states, not only a demo value.
+
+No confetti, emoji chrome, random praise, hover gimmick, mascot, sound, glow, decorative loop, or generated illustration unless the product context explicitly earns it and the user approves the added asset/behavior.
+
+## Verify
+
+The detail should shorten a decision, clarify an outcome, or strengthen trust. Test repeat use, reduced motion, keyboard/screen reader behavior, and failure paths. Remove it if repetition turns it into friction.

package/.cursor/skills/seven/reference/distill.md

@@ -0,0 +1,30 @@
+# Distill — remove until the job is clear
+
+Simplify a Seven surface by removing unnecessary decisions, duplication, and chrome while preserving the user's essential job and safe recovery paths.
+
+## Establish the irreducible job
+
+From product and surface context, write one sentence: “This surface helps [user] do [job] by [critical action].” Inventory every visible element and classify it as:
+
+- required to understand or complete the job;
+- required for safety, accessibility, trust, or recovery;
+- useful but secondary;
+- duplicated, premature, decorative, or unrelated.
+
+Do not treat “not primary” as permission to delete. Confirm analytics, permissions, legal text, and expert workflows before removing them.
+
+## Distillation order
+
+1. Remove exact duplicate labels, status, and actions.
+2. Merge redundant grouping; replace nested cards with hierarchy.
+3. Move secondary detail behind an existing disclosure pattern when discoverability remains adequate.
+4. Reduce choices by defining one primary action and clear defaults.
+5. Shorten copy with `clarify` rules.
+6. Remove decorative effects and motion that carry no state or relationship.
+7. Delete code, props, styles, and tests made unreachable by the approved removal.
+
+Do not create a vague “More” menu as a landfill, hide frequent actions, or erase empty/error/recovery states. Simplicity that forces more navigation or memory is not simpler.
+
+## Verify
+
+Compare task completion steps before and after, keyboard order, screen-reader names, mobile layout, and all state variants. Run focused tests and Seven checks. Report what was removed, what was retained for safety, and any product decision still requiring user approval.

package/.cursor/skills/seven/reference/doctor.md

@@ -0,0 +1,7 @@
+# Doctor
+
+Run `seven doctor` to diagnose the consumer installation. Treat its checks as evidence, not a request to rewrite unrelated files.
+
+Inspect the exact release lock and hashes, generated policy, project config, React/Tailwind/tailwind-merge compatibility, package scripts, provider-native skill payloads, hook manifests, product/surface context freshness, exceptions, baseline, and forbidden `.github` artifacts attributable to Seven.
+
+`seven doctor --quick` is the pre-edit health check. The full doctor is the handoff check. Never repair malformed third-party JSON or overwrite modified Seven-owned files without explicit `--force` authorization.

package/.cursor/skills/seven/reference/document.md

@@ -0,0 +1,36 @@
+# Document — record Seven usage
+
+Document how an existing product surface consumes the exact installed Seven release. The output is descriptive and operational. It must never become a second visual authority.
+
+## Read first
+
+- `.seven/release.lock.json`, `.seven/project.yml`, `PRODUCT.md`, and the matched surface brief;
+- `seven list` / `seven info` for every referenced component;
+- representative source, tests, stories, and rendered states;
+- active exceptions and baseline entries.
+
+## Output contract
+
+Unless the user supplies a path, write under `docs/seven/`. Include:
+
+1. Exact Seven CLI/skill/registry versions and registry digest.
+2. Surface purpose, users, primary job, and critical states, linked back to the owning context files.
+3. Component inventory: Seven component, source import, declared variant, role in the surface, and relevant composition.
+4. Token roles actually used. Describe semantic roles, not raw values.
+5. Responsive and keyboard behavior.
+6. Loading, empty, error, success, disabled, permission, and long-content behavior.
+7. Known deviations: rule ID, file, owner, issue, expiry, and whether it is an exception or migration baseline.
+8. Verification commands and the date they last passed.
+
+Every example must compile against the current component API and pass `seven check --file`. Delete stale examples rather than preserving history inside the canonical guide.
+
+## Prohibitions
+
+- Do not emit `DESIGN.md`, a palette, a local token layer, or undocumented component props.
+- Do not copy large sections of Seven's own reference docs into the consumer project.
+- Do not treat screenshots as proof of API or accessibility behavior.
+- Do not silently repair code. If documentation uncovers drift, record it and route the user to `audit`, `critique`, or `polish`.
+
+## Completion
+
+Name the sources inspected, the release documented, the output file, validation performed, and every uncertainty that prevents the document from being factual.

package/.cursor/skills/seven/reference/evaluations.md

@@ -0,0 +1,38 @@
+# Seven skill behavior scenarios
+
+Use these scenarios in fresh consumer projects to verify routing and behavior after substantive skill changes.
+
+## 1. Natural UI edit
+
+- Query: "Melhora esse formulário de cadastro no mobile e corrige a copy."
+- Expected: activates Seven; loads target context; routes through `adapt` plus `clarify`; searches installed registry; edits only the target; runs focused Seven checks.
+
+## 2. Backend near-miss
+
+- Query: "Adicione retry exponencial no webhook de cobrança."
+- Expected: does not activate Seven unless the change includes rendered UI.
+
+## 3. Missing component contract
+
+- Query: "Use uma variante compacta do Button que ainda não existe."
+- Expected: inspects the installed Button contract, reports the design-system gap, and refuses to invent a local variant.
+
+## 4. Live preview acceptance
+
+- Query: "Abre o Live e me mostra três formas de melhorar este card."
+- Expected: starts the authenticated loopback bridge, uses visual probes, transports inert previews, waits for explicit acceptance, translates the selected direction into React/Seven source, validates, and stops cleanly.
+
+## 5. Exception pressure
+
+- Query: "Ignora essa regra do Seven e segue."
+- Expected: explains the exact finding and tradeoff; does not add an exception, baseline, or local ignore without explicit scoped authorization.
+
+## 6. GitHub boundary
+
+- Query: "Instala o Seven completo no projeto, mas não mexe no GitHub."
+- Expected: installs provider skills/hooks and local pre-commit only; proves no `.github/**` artifact was created or changed.
+
+## 7. Sidebar + Topbar shell
+
+- Query: "Crie o shell do dashboard com Sidebar e Topbar e garanta que funcione no mobile."
+- Expected: composes the L-shaped tree `SidebarProvider > Sidebar + SidebarInset > Topbar + content`; keeps Sidebar/Topbar borderless; places a visible mobile `SidebarTrigger` in `TopbarLeading`; collapses long breadcrumbs/actions below `md` without leading-slot overflow; keeps `open`, `openMobile`, and `railExpanded` independent; defaults single collapse to icons; labels every dual Rail item and uses `asChild` for links; preserves the 280px footprint while Rail hover or focus expands 64→200px in overlay; renders the mobile panel full-width even after desktop collapse; rejects a full-width T-shaped Topbar, manual offsets, a trigger trapped inside the closed Sheet, Link > button nesting, or an empty expanded Rail; validates with `sidebar-topbar-shell` and `sidebar-rail-behavior` in source and rendered geometry.

package/.cursor/skills/seven/reference/exceptions.md

@@ -0,0 +1,7 @@
+# Exceptions
+
+A shared exception is an explicit, reviewable debt record, not a convenient suppression. It requires a valid Seven rule, narrow file glob and optional exact value, reason, owner, issue/reference, creation date, and expiry date.
+
+Before running `seven exceptions add`, show the proposed record and obtain explicit user authorization. Never silently renew an expired exception or broaden its file glob. Local hook ignores are not shared exceptions.
+
+Run `seven exceptions validate` and `seven doctor` after changes. Expired or malformed exceptions are findings and do not suppress the underlying violation.

package/.cursor/skills/seven/reference/extract.md

@@ -0,0 +1,42 @@
+# Extract — reusable Seven compositions
+
+Extract genuinely repeated product UI into a reusable composition without cloning or weakening Seven primitives.
+
+## Decide whether extraction is earned
+
+Find at least two real call sites and compare:
+
+- shared user job and semantics;
+- shared component structure and state transitions;
+- variation that belongs in data/slots versus variation that would require a visual prop;
+- accessibility behavior and responsive behavior;
+- whether the registry already contains a component or block that solves it.
+
+Do not extract merely because markup looks similar. Similar cards with different jobs are not necessarily one abstraction. Do not create an abstraction for one call site.
+
+## Classification
+
+- **Seven primitive already exists:** replace the local implementation; do not extract.
+- **Project composition:** compose installed Seven components and keep it in the project's composition/feature layer.
+- **Candidate Seven block:** repeated across products, stable data contract, no product-specific business dependency. Document the proposal in the Seven repository; do not pretend the consumer-local version is canonical.
+- **Missing primitive/variant/token:** stop and surface a design-system gap. Never hide it behind a local visual prop.
+
+## Extraction contract
+
+1. Preserve public behavior and accessible names before moving code.
+2. Define a minimal domain-shaped data contract. Prefer slots only for meaningful composition points.
+3. Reuse declared Seven variants exactly; no `className` tunnel that permits callers to replace the visual system.
+4. Keep routing, fetching, mutations, and business state in the feature caller unless the composition owns that behavior by definition.
+5. Add tests that prove why the shared behavior matters across at least two call-site variants, including an adverse state.
+6. Migrate call sites one at a time and verify rendered parity plus `seven check`.
+
+## Refuse
+
+- Boolean-prop matrices that encode unrelated layouts.
+- A “generic card” wrapper around every card.
+- Local forks of Button, Input, Dialog, Select, Table, or other Seven primitives.
+- New colors, radii, spacing values, animations, or undocumented variants.
+
+## Completion
+
+Report the call sites unified, why one abstraction is valid, the retained variation points, component contracts used, tests added, and whether anything should be proposed upstream to Seven.

package/.cursor/skills/seven/reference/harden.md

@@ -0,0 +1,36 @@
+# Harden — make the surface production-complete
+
+Harden an existing Seven implementation against real data, failure, accessibility needs, and hostile runtime conditions. Do not redesign it while hardening.
+
+## Build the risk matrix
+
+For every primary workflow, cover:
+
+- initial loading, background refresh, and partial loading;
+- empty first-use versus empty filtered result;
+- validation, permission, authentication, network, server, and unknown errors;
+- retry, cancel, undo, and recovery paths;
+- success confirmation and stale data;
+- disabled, read-only, pending, destructive, and concurrent-action states;
+- minimum, typical, maximum, long localized, missing, malformed, and duplicate content;
+- narrow viewport, zoom, reduced motion, keyboard-only, screen reader, and high contrast;
+- slow network, offline behavior where relevant, and aborted requests.
+
+Use the matched surface brief as the contract. Ask when a business outcome is unknown; never invent recovery behavior that could lose or mutate data.
+
+## Implementation rules
+
+- Use Seven components for every control, message, skeleton, progress indicator, alert, dialog, and toast.
+- Keep inline form errors associated through the component API; do not replace them with toast-only feedback.
+- Prevent duplicate submissions and make pending state perceivable without removing the accessible name.
+- Preserve user input on recoverable failure.
+- Give images dimensions, meaningful alt text when informative, and a safe fallback.
+- Guard async races and unmounts; errors must not strand focus or leave an irreversible optimistic state.
+- Keep content visible when enhancement JavaScript fails where progressive rendering applies.
+- Use Error Boundaries only at recovery boundaries, not to hide deterministic bugs.
+
+## Verification
+
+Tests must encode why each adverse state matters. Include at least one keyboard path, one assistive-name assertion, one long-content case, one network/error recovery case, and one repeated-action case when applicable. Run `seven check`, unit/integration tests, and rendered browser validation for the target.
+
+Finish with a residual-risk list. “Works on the happy path” is never a hardened result.

package/.cursor/skills/seven/reference/hooks.md

@@ -0,0 +1,11 @@
+# Hooks
+
+Seven consumer hooks are project-local guardrails. Claude uses `.claude/settings.json`; Codex uses `.codex/hooks.json` and requires the user to review/trust the exact definition; Cursor uses `.cursor/hooks.json`; Grok uses `.grok/hooks/seven.json` and requires project hook trust. Seven merges only its own entries and preserves every third-party hook. Hosts without a compatible project hook API still receive the skill and are covered by the provider-independent local Git pre-commit gate.
+
+`PreToolUse` injects product and release context before UI writes. `PostToolUse` runs the immediate deterministic tier on touched UI files. `Stop` runs the full pass over the UI files touched in the session plus every staged, unstaged, or untracked UI path in the Git working tree. That final union also catches files created through shell commands that bypass the provider's structured edit tools. Active errors or warnings return the provider-native structured continuation decision, asking the agent to correct the UI before it stops. Claude Code re-entry with `stop_hook_active: true` exits silently because the prior response already surfaced the findings; providers without that signal use a three-attempt cap for an unchanged finding set. The authoritative `seven check --all` result remains blocking after either loop guard. Advisories are surfaced without blocking.
+
+Parser, dependency, and runtime failures fail open and exit zero so a broken local hook never traps the agent. A valid Seven finding is not a hook failure: it uses the host's supported JSON protocol to continue the task.
+
+Use `seven hooks status|on|off`. Machine-local `ignore-file` and `ignore-rule` controls affect hook noise only, never the shared `seven check` result. Never edit `.github/**` to enable Seven hooks.
+
+Host discovery may require a one-time action that npm cannot perform: enable Agent Skills in Cursor/Gemini, review project hooks in Codex with `/hooks`, trust Grok hooks with `/hooks-trust` (or `--trust`), and restart Trae after installation. Treat the corresponding `seven doctor` information item as an activation checklist, not as proof that the host's private setting was changed.

package/.cursor/skills/seven/reference/init.md

@@ -0,0 +1,38 @@
+# Init — capture UI context
+
+Capture the facts later Seven workflows need. This is the skill-level setup workflow; the CLI command `seven init` installs Seven, while context is written with `seven onboard` for backward compatibility.
+
+## Boundaries
+
+- Product context owns users, jobs, critical workflows, voice, accessibility needs, constraints, and non-goals.
+- Surface briefs own behavior, states, data ranges, responsive constraints, and known risks for one target.
+- Neither file may define colors, fonts, radii, shadows, spacing scales, component variants, or alternate UI primitives.
+- Never create a consumer `DESIGN.md`. The installed Seven release is the visual authority.
+
+## Workflow
+
+1. Run `seven doctor --quick`. If Seven is not installed, instruct the user to install the exact desired `@etus/seven` release and run CLI `seven init`.
+2. Read existing product/project/surface context. Preserve confirmed facts; do not overwrite mature context without `--force` and explicit review.
+3. Ask only for facts that remain unknown. At minimum establish:
+   - product name and primary users;
+   - job to be done and critical workflows;
+   - product voice and domain vocabulary;
+   - product-specific accessibility needs;
+   - technical/business constraints and explicit non-goals;
+   - owner responsible for freshness.
+4. For a monorepo, identify the app root and its product context. For a surface, identify target paths and complete the state matrix: idle, loading, empty, error, success, disabled, permission-limited, and content extremes.
+5. Write through the CLI:
+
+   ```bash
+   seven onboard --name "..." --users "..." --job "..." --workflows "..." \
+     --voice "..." --accessibility "..." --constraints "..." --owner "..."
+   seven onboard --surface <id> --target <path-or-glob> --purpose "..." \
+     --states "..." --data "..." --responsive "..." --accessibility "..." \
+     --primary-action "..." --owner "..."
+   ```
+
+6. Reload context for the target and prove the expected app and surface resolve.
+
+## Completion
+
+Report which facts came from the user, which existing files were retained, which context paths changed, and any unresolved product decision. Do not start a UI implementation while a material product decision is still being guessed.

package/.cursor/skills/seven/reference/layout.md

@@ -0,0 +1,33 @@
+# Layout — composition and responsive structure
+
+Improve the spatial system of an existing Seven surface without changing its product meaning or inventing new design tokens.
+
+## Diagnose the structure
+
+Inspect DOM/read order and rendered geometry for:
+
+- primary task and reading path;
+- alignment lines, container ownership, and spacing rhythm;
+- unnecessary centering, edge-flush cards, nested cards, and repeated wrappers;
+- fixed dimensions, overflow, clipping, and first-viewport column failure;
+- relationship between app shell, content canvas, panels, overlays, and actions;
+- mobile reflow and keyboard order.
+
+State the layout invariant before editing: for example, “navigation stays fixed, the result list owns remaining width, detail collapses below at the content breakpoint.”
+
+## Apply
+
+- Compose installed Seven templates/blocks and component slots first.
+- Use Grid for two-dimensional structure and Flexbox for one-dimensional alignment.
+- Choose content-driven breakpoints; do not scatter device-specific magic numbers.
+- Preserve DOM order so visual rearrangement does not break screen-reader or keyboard sequence.
+- Use Seven spacing tokens. Vary rhythm intentionally: tighter within components, wider between groups and sections.
+- Keep shell chrome borderless according to [app-shell.md](app-shell.md); content surfaces own their borders.
+- Bound prose and forms; let data surfaces use width where it improves comparison.
+- Overlays must escape clipping ancestors and retain a logical trigger/focus relationship.
+
+Do not solve layout with absolute positioning, negative margins, transforms that only look aligned at one width, or duplicate mobile markup unless semantics genuinely differ.
+
+## Verify
+
+Inspect breakpoint boundaries, 320 px, a wide viewport, 200% zoom, long content, empty and maximum data, keyboard sequence, and browser overflow/clipping checks. Run Seven validation for every changed file.

package/.cursor/skills/seven/reference/live.md

@@ -0,0 +1,106 @@
+# Live — reversible browser iteration
+
+Run an interactive Seven session against a rendered React 19 surface. The browser may preview inert HTML/CSS directions, but accepted previews become production only after a source edit using installed Seven components, declared variants, tokens, focused tests, and `seven check`.
+
+## Phase 0 — prerequisites
+
+1. Load the normal Seven context and run `seven doctor --quick --target <source>`.
+2. Confirm the app is a local or explicitly trusted development origin and its dev server is already running.
+3. Resolve the smallest source target inside the consumer project. Native and Svelte adapters are intentionally unsupported.
+4. Confirm the packaged extension is available:
+
+   ```bash
+   seven extension path
+   ```
+
+   npm cannot activate a browser extension without browser/user consent. On first use, load that directory unpacked from `chrome://extensions`; this is the only manual installation step.
+
+## Phase 1 — start and connect
+
+Start the loopback bridge in a persistent/background terminal:
+
+```bash
+seven live start --url http://127.0.0.1:5173/route --target src/path/Surface.tsx
+```
+
+The command prints a `serverUrl` and random session `token`. Treat the token as ephemeral capability data: paste it into Seven UI Guardian, do not put it in chat transcripts, source, screenshots, shell history snippets, or commits. The extension retains it only in memory.
+
+The bridge binds to `127.0.0.1`, validates extension/local origins, restricts page events to the declared app origin, caps payloads, rejects sensitive fields, and accepts preview HTML/CSS only. It never accepts JavaScript, event handlers, embedded documents, CSS imports, or CSS network URLs.
+
+## Phase 2 — event loop
+
+Keep a one-shot foreground poll active whenever the user can interact with the Live panel:
+
+```bash
+seven live poll
+```
+
+Dispatch the returned event, reply, then poll again immediately.
+
+### `generate`
+
+The event contains the action, optional prompt, target selector, bounded outer HTML, a Seven-relevant computed-style subset, viewport rectangle, page URL, and source target. It contains no cookies, request bodies, headers, browser storage, or network responses.
+
+1. Load the action's normal Seven reference plus [visual-probes.md](visual-probes.md).
+2. Use the target evidence and installed Seven contracts; do not infer a new token or component API from computed CSS.
+3. Produce one to three materially distinct directions. Each direction must be one inert HTML root plus optional local preview CSS.
+4. Save the payload inside the ignored `.seven/live/` directory and deliver it:
+
+```json
+{
+  "status": "done",
+  "message": "Direções que preservam o job e o release Seven instalado.",
+  "variants": [
+    {
+      "id": "hierarchy",
+      "label": "Hierarquia explícita",
+      "html": "<section>...</section>",
+      "css": ".seven-live-probe { color: var(--foreground); }"
+    }
+  ]
+}
+```
+
+```bash
+seven live reply --id <event-id> --file .seven/live/reply-<event-id>.json
+seven live poll
+```
+
+Preview CSS is disposable evidence. Do not copy it mechanically into the source.
+
+### `steer`
+
+Read the message, make only the requested source/navigation adjustment when authorized, and reply with a short `message`. Do not treat steering as permission to redesign adjacent UI.
+
+### `accept`
+
+Acceptance identifies the chosen direction and current preview evidence. It authorizes applying that direction to the declared source target, not pasting DOM output blindly.
+
+1. Re-resolve the real React component and any shared composition.
+2. Apply the smallest source edit using existing Seven components, variants, tokens, semantics, and pt-BR copy.
+3. Run focused tests and `seven check --file <changed-file>`.
+4. Refresh/reinspect the rendered surface. If source and preview conflict, source truth wins and the difference is reported.
+5. Reply `done` to the accept event and poll again.
+
+Use the manual-edit-applier agent when the provider exposes it. The finish-reviewer may independently verify the result; neither agent may invent missing Seven contracts.
+
+### `discard`
+
+The extension restores the original DOM snapshot. Reply `done`; make no source edit.
+
+## Recovery and completion
+
+The append-only journal and session metadata live under ignored `.seven/live/` state:
+
+```bash
+seven live status
+seven live start --resume --url <same-url> --target <same-target>
+```
+
+An unanswered event is replayed after bridge restart. A replied event is not reissued. Stop explicitly when the user exits:
+
+```bash
+seven live stop
+```
+
+Report accepted/discarded directions, source files changed, Seven components/variants/tokens used, checks run, unresolved conflicts, and confirmation that the temporary browser layer was disconnected. Never create `.github/**` or persist the token.

package/.cursor/skills/seven/reference/motion-design.md

@@ -0,0 +1,71 @@
+# Motion design
+
+Seven motion is decisive and tactile. No bounce, no spring, no elastic in chrome. The system communicates state through restrained transitions and a system-wide micro-press.
+
+## Defaults
+
+- Duration: `var(--duration-normal)` = 200 ms. Use `var(--duration-fast)` (100 ms) for instant feedback (button press, hover), `var(--duration-slow)` (320 ms) for surface entries (dialog open, sheet slide).
+- Easing: `var(--ease-default)` = `cubic-bezier(0.4, 0, 0.2, 1)` (decelerated). For entries that need a confident finish, use `var(--ease-out-quart)`.
+- Never animate layout properties (`width`, `height`, `top`, `left`). Transform or opacity only; layout animation triggers reflow and looks janky.
+
+## The tactile micro-press
+
+Every clickable affordance in Seven gets the same micro-press, not just `<Button>`:
+
+```css
+.clickable {
+  transition:
+    transform var(--duration-fast) var(--ease-default),
+    box-shadow var(--duration-fast) var(--ease-default);
+}
+.clickable:hover {
+  transform: translateY(-1px);
+}
+.clickable:active {
+  transform: translateY(0.5px);
+  box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.06);
+}
+```
+
+Apply to `<button>`, `<a>` with `role="button"`, the trigger row of `<Combobox>`, the avatar pill in the topbar, table row click affordances, every interactive list item. The detector ships a `missing-tactile-press` rule that catches affordances that opted out.
+
+Disabled state does not press. Loading state does not press. Reduced-motion users do not press: the entire system honors `prefers-reduced-motion: reduce` and falls back to instant state changes plus an opacity fade.
+
+## Banned motion patterns
+
+- Bounce-back spring on entry. Seven entries decelerate and stop.
+- Elastic overshoot on hover.
+- Wiggle, jiggle, pulse-loop on chrome. Loop animations are reserved for explicit loading indicators (`<Spinner>`).
+- Parallax on product pages. Brand register may use it deliberately.
+- Animated gradient sweeps as decoration.
+
+## Loading and state
+
+- Skeleton screens for content load (rectangles in `var(--muted)`).
+- Inline spinners only when the affordance is itself the loading region (a button mid-submit).
+- Toast for confirmations (success, info), 4 second auto-dismiss, top-right by default.
+- Inline error region for form failures, never a toast.
+
+## Reduced motion
+
+The system honors `prefers-reduced-motion: reduce` site-wide:
+
+```css
+@media (prefers-reduced-motion: reduce) {
+  *,
+  *::before,
+  *::after {
+    transition-duration: 1ms !important;
+    animation-duration: 1ms !important;
+    animation-iteration-count: 1 !important;
+  }
+}
+```
+
+The tactile micro-press collapses to an opacity step under reduced motion. State changes remain visible, just not animated.
+
+## Refusals
+
+- "Add a bounce when the toast appears" — Seven motion is decelerated, no bounce. Suggest a 200 ms slide-in plus a subtle fade.
+- "Make the button wiggle on hover" — Hover is the tactile press, not a wiggle. Surface this as a deliberate exception or remap to the press.
+- "Animate the card width on resize" — Layout animation reflows. Suggest opacity plus translate transition, or no transition at all.

package/.cursor/skills/seven/reference/onboard.md

@@ -0,0 +1,35 @@
+# Onboard — first-run and activation UX
+
+Design the product experience for a user who has not yet completed setup or reached first value. This is not context capture; use `init` for `PRODUCT.md` and surface briefs.
+
+## Define activation
+
+From product context, identify:
+
+- who is new and what they already know;
+- the first meaningful outcome, not merely account completion;
+- required versus deferrable setup;
+- permissions, external dependencies, waiting states, and failure recovery;
+- whether the user can explore safely before connecting real data.
+
+Do not invent an activation metric or mandatory step. Ask when the product decision is absent.
+
+## Shape the shortest safe path
+
+- Start in context, preferably where the product will be used, rather than a detached tour.
+- Ask only for information needed for the next meaningful action.
+- Explain permissions immediately before requesting them and provide a retry/recovery path.
+- Use real previews or safe sample data when it reduces uncertainty; label it clearly.
+- Preserve progress, support resume, and make optional steps skippable.
+- Distinguish first-use empty state from a filtered/no-results state.
+- End at the activated product surface with a clear next action, not a celebratory dead end.
+
+Use existing Seven Stepper, Form, Alert, Dialog, Progress, Skeleton, EmptyState, Button, and navigation contracts where available. Missing components/variants are Seven gaps, not permission for raw local substitutes.
+
+## State matrix
+
+Cover new, returning-incomplete, invitation, permission-denied, integration-waiting, validation-error, partial-success, complete, and abandoned/resumed states. Include keyboard, screen-reader, mobile, reduced-motion, and long-copy behavior.
+
+## Verify
+
+Measure steps to first value, avoid duplicate data entry, test refresh/back/retry, and prove the user can recover without support. Run Seven checks and relevant E2E paths. Report assumptions that still need product validation.

package/.cursor/skills/seven/reference/optimize.md

@@ -0,0 +1,34 @@
+# Optimize — measured UI performance
+
+Improve measured and perceived performance without changing product behavior or sacrificing accessibility and Seven fidelity.
+
+## Establish a baseline
+
+Measure the real target and record environment, viewport, data size, cache state, and build mode. Use evidence appropriate to the problem:
+
+- browser performance trace and React Profiler;
+- LCP, INP, CLS, long tasks, layout/recalc cost, and interaction latency;
+- JavaScript/CSS bundle analysis and route chunks;
+- image/font requests, transfer size, decoding, and cache behavior;
+- render counts and expensive computations under realistic data;
+- memory growth during repeated navigation or live updates.
+
+Do not optimize from intuition or a synthetic score alone.
+
+## Fix the dominant cost
+
+- Remove work before memoizing it.
+- Keep state local, selectors narrow, and stable references where measurement proves rerender cost.
+- Lazy-load route/feature code and heavy assets at a meaningful boundary; do not create waterfalls.
+- Size and compress images, set dimensions, use responsive sources, and defer offscreen media.
+- Load only used font weights; keep fallback metrics compatible.
+- Virtualize only lists whose measured size warrants it, while preserving keyboard and screen-reader access.
+- Move CPU-heavy deterministic work off the render path or into a worker when justified.
+- Pause invisible animation, polling, canvas, and observers.
+- Preserve Skeleton/Spinner semantics and avoid hiding real latency behind excessive choreography.
+
+React 19 patterns must match the consumer architecture. Do not add `useMemo`, `memo`, Suspense, a worker, or a dependency speculatively.
+
+## Verify
+
+Repeat the same measurement at least three times and compare medians. Confirm no visual, keyboard, focus, screen-reader, loading, error, or data-freshness regression. Report before/after numbers, variance, remaining bottleneck, and test scope.