enigma-cli 1.33.1 → 1.33.3

package/assets/skills/anti-overengineering-policy/skill.json

@@ -7,6 +7,6 @@
     "minimalCode"
   ],
   "updated": "2026-07-17T00:17:02+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "3f0dcc28341bb0407860534f7ce9314cfc91b5e673f8f3d13b89d61851ed75f6"
 }

package/assets/skills/anti-overengineering-review/skill.json

@@ -4,6 +4,6 @@
   "provider": "FJRG2007/enigma",
   "description": "On-demand over-engineering review - diff review, whole-repo audit, and enigma: debt-marker ledger (tags delete/stdlib/native/yagni/shrink, line/dep scoring); lists cuts, applies nothing.",
   "updated": "2026-06-16T11:24:30+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "f742a2be3f328b9ea1ff9a35a449177c2cbec35ad16e46f7054b7a873a2ab017"
 }

package/assets/skills/backend-policy/SKILL.md

@@ -17,7 +17,7 @@ description: Backend/API architecture - controller-service-repository layering,
 - Separate controllers, services, repositories, and validators into distinct layers.
 - Controller/route handler: parse and validate input, call a service, shape the response. No business logic.
 - Service: business logic and orchestration. Reusable and domain-focused. No HTTP or framework details.
-- Repository/data access: the only layer that talks to the database (per database-expert). No business logic.
+- Repository/data access: the only layer that talks to the database (per database-expert). No business logic. On a TypeScript/JavaScript/Node/Bun stack that layer is the Prisma client over PostgreSQL by default - pick it without asking, and use another ORM only when the user, the requirements, or the existing codebase names one.
 - Validator/schema: input contracts via Zod or equivalent (per validation-policy).
 - Do not place business logic in route handlers, and do not place data access in services - go through the repository.
 

package/assets/skills/backend-policy/skill.json

@@ -1,9 +1,9 @@
 {
   "name": "backend-policy",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "provider": "FJRG2007/enigma",
   "description": "Backend/API architecture: controller-service-repository layering, API and request optimization (batching, avoiding redundant calls, skipping no-op writes), server-side caching (Redis), and Zod boundary validation.",
-  "updated": "2026-07-31T16:34:48+02:00",
-  "cliVersion": "1.33.1",
-  "sha": "768c2e088948ff97d6b897ce43854e53dfd156738e6a19548679b5327278433d"
+  "updated": "2026-08-01T15:51:38+02:00",
+  "cliVersion": "1.33.3",
+  "sha": "572fcf9780e3892942c300214367d7205ed6dcde173a64c61c1e519506cf0cfa"
 }

package/assets/skills/ciphera-style-policy/skill.json

@@ -4,6 +4,6 @@
   "provider": "FJRG2007/enigma",
   "description": "Ciphera code style conventions (formatting, naming, imports incl. namespace imports for wide module surfaces, comments, code-level anti-patterns; TypeScript-first, language-agnostic).",
   "updated": "2026-07-31T21:32:28+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "d6a86c28ad39ee502607a5ca8f6f361c8aa52b8fa946156165ec78c6139e495f"
 }

package/assets/skills/code-review-policy/skill.json

@@ -4,6 +4,6 @@
   "provider": "FJRG2007/enigma",
   "description": "Pre-delivery self-review gate, prioritized review dimensions, and change-quality criteria.",
   "updated": "2026-06-01T00:45:28+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "3d3bbe0602d5bbb4afe37648fe3c2fa39376b1bcbac5d8c441f01fad1e866ed0"
 }

package/assets/skills/core-engineering-policy/skill.json

@@ -4,6 +4,6 @@
   "provider": "FJRG2007/enigma",
   "description": "Core engineering execution policy and harness orchestration (highest-authority rules).",
   "updated": "2026-07-30T19:29:19+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "6a881d8589926fa7f48058314fd26d7042fd2ac82f1c87a6c11ffb54d1fda22b"
 }

package/assets/skills/database-expert/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: database-expert
-description: Senior database architecture - engine selection (PostgreSQL is the default relational engine for anything deployed or multi-writer; SQLite only for local-first, embedded, single-writer stores), schema design, normalization and anti-duplication, query/index optimization, scalability (partitioning, sharding, replication), and RGPD/GDPR encryption of sensitive data. Use when designing, modifying, migrating, querying, or reviewing any database, schema, SQL, ORM model, or persistence layer, and when choosing the datastore for a new project's stack.
+description: Senior database architecture - engine selection (PostgreSQL is the default relational engine for anything deployed or multi-writer; SQLite only for local-first, embedded, single-writer stores), ORM selection (TypeScript/JavaScript/Node/Bun projects use Prisma over PostgreSQL unless the user or the requirements name another ORM), schema design, normalization and anti-duplication, query/index optimization, scalability (partitioning, sharding, replication), and RGPD/GDPR encryption of sensitive data. Use when designing, modifying, migrating, querying, or reviewing any database, schema, SQL, ORM model, or persistence layer, and when choosing the datastore for a new project's stack.
 ---
 
 # Database Expert Policy (Senior Data Architecture Standards)
@@ -34,7 +34,17 @@ description: Senior database architecture - engine selection (PostgreSQL is the
 - MySQL/MariaDB only when the platform, the host or the team requires it. SQL Server or Oracle only where it is already the environment.
 - Do not add a second datastore before PostgreSQL runs out. It handles queues (`SELECT ... FOR UPDATE SKIP LOCKED`), full-text search, vectors, JSON documents and counters well past early scale. Add Redis, a search engine or a vector database when a measured limit demands it, not as part of the initial stack.
 - Serverless and edge runtimes still get PostgreSQL: the problem there is connection count, not the engine, so put a pooler in front (PgBouncer, Prisma Accelerate, the provider's pooled endpoint) instead of switching to a file database.
-- Wire it the same way every time: Prisma as the ORM for TypeScript, migrations committed to version control, the connection string from the environment and never in the repo, and pooling configured before the first load test rather than after the first outage.
+- Wire it the same way every time: the ORM below, migrations committed to version control, the connection string from the environment and never in the repo, and pooling configured before the first load test rather than after the first outage.
+
+---
+
+## ORM Selection (TypeScript/JavaScript: Prisma)
+
+- Every TypeScript, JavaScript, Node, Bun or Deno project uses **Prisma over PostgreSQL**. Pick it without being asked - it is the default stack, not one option among several to weigh up.
+- Use something else only when the user asks for another ORM, or the requirements or the existing codebase already commit to one. Then follow that choice and say in one line what it is.
+- Treat Prisma as the schema's source of truth: `schema.prisma` defines the models, `prisma migrate` generates the migrations and they are committed, and the generated client is the query path. Do not hand-write parallel DDL for the same tables.
+- Raw SQL stays available for what the query builder does poorly - `$queryRaw` with parameters, never interpolated input.
+- The identifier policy below still applies: UUID primary keys - `@id @default(uuid(7))` where the installed Prisma version accepts the version argument, otherwise an application-generated UUIDv7/ULID - and never `autoincrement()`.
 
 ---
 

package/assets/skills/database-expert/skill.json

@@ -1,9 +1,9 @@
 {
   "name": "database-expert",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "provider": "FJRG2007/enigma",
-  "description": "Senior database architecture policy: engine selection (PostgreSQL by default, SQLite only for local-first/embedded stores), query optimization, anti-duplication/normalization, scalability, and RGPD/GDPR encryption.",
-  "updated": "2026-07-31T19:05:08+02:00",
-  "cliVersion": "1.33.1",
-  "sha": "b21ae85a015305106f787be2eb0a022661b2e984bc42c6bc66703954256e3c53"
+  "description": "Senior database architecture policy: engine selection (PostgreSQL by default, SQLite only for local-first/embedded stores), ORM selection (Prisma in TypeScript/JavaScript), query optimization, anti-duplication/normalization, scalability, and RGPD/GDPR encryption.",
+  "updated": "2026-08-01T15:51:38+02:00",
+  "cliVersion": "1.33.3",
+  "sha": "4b7569446786c5bdbb71b2e9102aee0d8dd391b5e3e461d6fb1f05294d446ad9"
 }

package/assets/skills/debugging-policy/skill.json

@@ -4,6 +4,6 @@
   "provider": "FJRG2007/enigma",
   "description": "Reproduce-isolate-fix debugging methodology with root-cause discipline and regression verification.",
   "updated": "2026-06-01T00:45:28+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "14b0064c8b33a0dc85e51464b05005cf5801c756b1101789a6924b9548420f6b"
 }

package/assets/skills/dependency-policy/skill.json

@@ -4,6 +4,6 @@
   "provider": "FJRG2007/enigma",
   "description": "Dependency and supply-chain security: lockfiles and reproducible installs, version pinning, vulnerability auditing, vetting/minimizing packages, vendoring, and SBOM/provenance.",
   "updated": "2026-06-01T00:45:28+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "6375d835c2aef2c9bd31ce116444dc3d796f510f9970a213aa3ac4696d7e21b9"
 }

package/assets/skills/email-policy/skill.json

@@ -4,6 +4,6 @@
   "provider": "FJRG2007/enigma",
   "description": "Transactional email: React Email templates instead of hand-written HTML tables, server-side rendering, one send module behind the provider SDK, plain-text alternatives, idempotent background sending, link safety, and deliverability (SPF/DKIM/DMARC, bounce suppression, unsubscribe).",
   "updated": "2026-07-30T19:29:19+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "c9724fdbcdbeab99573be3fd44d4cdd97c2a394d99f3c4395f118f17356b00ed"
 }

package/assets/skills/frontend-design/skill.json

@@ -4,6 +4,6 @@
   "provider": "FJRG2007/enigma",
   "description": "Guidance for distinctive, intentional visual design when building new UI or reshaping an existing one.",
   "updated": "2026-07-29T01:18:36+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "9e30ee7d8a1a1e8c6e7f4e043857cd01841c68a427752e45bc0cad9ec5cfa279"
 }

package/assets/skills/frontend-policy/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: frontend-policy
-description: Frontend architecture - reusable components, abstraction thresholds, state management, no-op detection (skip any operation whose result equals the current state - form saves, toggles, filters, reorders - not just saves; dirty means the values DIFFER from the loaded snapshot, not that the user touched the field, so a value edited and put back leaves Save disabled), client-side caching (localStorage/sessionStorage to avoid redundant server calls and survive rate limits), instant first paint (render the shell immediately, load data async via the API, show skeletons - never block render on data), perceived performance and responsiveness (instant interaction feedback, prefetch on intent, debounce/throttle, cancel stale requests, avoid request waterfalls, lazy-load heavy widgets), large-list rendering (virtualized infinite scroll vs pagination, skeletons, progressive/parallel loading, short-TTL caching), optimistic UI with rollback, visual restraint (never a card inside a card, borders only where they carry information, spacing and background tone before chrome), icon actions (repeated row/card actions like copy, edit, rename, remove, download, refresh are icon-only buttons carrying aria-label plus title, never a text label), responsive/adaptive layout (fluid units, breakpoints, no overlap or horizontal overflow, viewport meta, touch targets), form fields that declare their keyboard and casing (autocapitalize/autocomplete/inputmode/spellcheck per field kind, set once in the shared Input, normalized on blur rather than on every keystroke, with an inline error on every field that has a rule), AI chat/assistant/agent interfaces (use Vercel's AI Elements registry for message threads, streaming, reasoning and tool-call panels, prompt inputs - never hand-roll chat UI in React), and periodic React code-health audits (react-doctor). Use when building or changing UI components, client state, forms/save flows, data fetching/caching, lists that show lots of data, loading states, dashboards/panels, layout/responsiveness, making the UI feel fast, building a chat/AI/agent/LLM interface, or any frontend structure.
+description: Frontend architecture - reusable components, abstraction thresholds, state management, no-op detection (skip any operation whose result equals the current state - form saves, toggles, filters, reorders - not just saves; dirty means the values DIFFER from the loaded snapshot, not that the user touched the field, so a value edited and put back leaves Save disabled), client-side caching (localStorage/sessionStorage to avoid redundant server calls and survive rate limits), instant first paint (render the shell immediately, load data async via the API, show skeletons - never block render on data), perceived performance and responsiveness (instant interaction feedback, prefetch on intent, debounce/throttle, cancel stale requests, avoid request waterfalls, lazy-load heavy widgets), large-list rendering (virtualized infinite scroll vs pagination, skeletons, progressive/parallel loading, short-TTL caching), optimistic UI with rollback, visual restraint (never a card inside a card, borders only where they carry information, spacing and background tone before chrome), icon actions (repeated row/card actions like copy, edit, rename, remove, download, refresh are icon-only buttons carrying aria-label plus title, never a text label), navigation that is iconified and grouped into labelled sections once it outgrows a flat list, a Cmd/Ctrl+K command palette with fuse.js fuzzy search over the loaded data once the app has enough destinations and records to hunt through, responsive/adaptive layout (fluid units, breakpoints, no overlap or horizontal overflow, viewport meta, touch targets), form fields that declare their keyboard and casing (autocapitalize/autocomplete/inputmode/spellcheck per field kind, set once in the shared Input, normalized on blur rather than on every keystroke, with an inline error on every field that has a rule), auth screens (breached-password feedback, strength meter, cookie consent answered before login/register), AI chat/assistant/agent interfaces (use Vercel's AI Elements registry for message threads, streaming, reasoning and tool-call panels, prompt inputs - never hand-roll chat UI in React), and periodic React code-health audits (react-doctor). Use when building or changing UI components, client state, forms/save flows, data fetching/caching, lists that show lots of data, loading states, dashboards/panels, layout/responsiveness, making the UI feel fast, building a chat/AI/agent/LLM interface, or any frontend structure.
 ---
 
 # Frontend Architecture Policy
@@ -146,6 +146,24 @@ A sidebar keeps its desktop width only while there is a desktop to put it in. On
 
 ---
 
+## Navigation Is Structured, Not A Growing List
+
+A sidebar gets one more entry per feature and nobody ever goes back to reorganize it, so it ends as a flat column of a dozen similar words that has to be read top to bottom every time. Structure it as it grows, by default and without being asked: the icons, the grouping and the ordering below are part of building the nav, not a redesign to propose afterwards.
+
+**Every entry carries an icon.** One icon set for the whole nav, one size, aligned in a single column so the labels line up. The glyph is what the eye aims at once the user knows the app, and it is what makes a collapsed rail possible later. Choose it for what the destination IS, not for the word in the label: a gauge for a dashboard, a key for credentials, sliders for settings. When no glyph reads for an abstract destination, take the set's neutral placeholder rather than a loose near-match - a wrong icon is read as a different feature.
+
+**The label stays.** This is the opposite call from Icon Actions above, and the difference is repetition: a row action repeats per row and its glyph is conventional, while a nav entry appears once and names a place the user may never have visited. Icon plus word, and the icon takes `aria-hidden="true"` because the label is already the accessible name.
+
+**Group once the list passes about seven entries.** Labelled sections of related destinations, with the label a quiet uppercase or muted heading rather than another bordered box (Visual Hierarchy above). Order the groups and the entries inside them by how often they are used, never alphabetically - alphabetical order is the one arrangement that guarantees the daily destination is somewhere in the middle. Account, billing and sign out sit apart at the bottom, separated by space.
+
+**Mark the active entry with more than colour**: a filled background or a leading bar plus `aria-current="page"`, so it survives a colourblind user and a screen reader. A group holding the active entry stays expanded.
+
+**Collapsible groups persist their state.** If a section can be collapsed, remember the choice per user (localStorage is enough) and restore it on the next visit; a nav that reopens every group on every navigation is worse than one that never collapsed.
+
+**Nav is not the only way in.** Past roughly a dozen destinations, grouping stops being enough and the user starts hunting: add the command palette from Search & Filtering below. Structure narrows the hunt; search ends it.
+
+---
+
 ## Links In Copy Are Links
 
 When UI copy names a destination - a URL, a doc page, a dashboard, a settings screen, an external service - make it reachable from where it is written. Printing a bare URL as plain text in a hint, description, empty state or error message leaves the user to select and copy it by hand, which is exactly the work the interface exists to remove.
@@ -261,6 +279,10 @@ Auth is the first screen a user meets and the one most often shipped half-built.
 - Every sign-in form with a password field carries a visible "Forgot your password?" link next to that field, leading to a real reset flow. Building the login screen without it is shipping a dead end.
 - The reset request screen confirms in the same words whether or not the address is registered ("If that address has an account, we have sent a link"). Never render "no account with that email" - the screen would be an account-existence oracle.
 - The new-password screen validates in real time against the same schema the server uses, uses the shared Input (which brings the show/hide toggle), and compares the confirmation field as the user types. Keep Submit disabled until both are valid, with the reason visible.
+- Wherever a password is created (sign-up, reset, change), check it against Have I Been Pwned's Pwned Passwords range API as the user types - debounced, request aborted when the value changes - and refuse a breached one with "This password appeared in a data breach. Choose a different one." Free, no key, and the password never leaves the browser: only the first 5 characters of its SHA-1 do (mechanics and the server-side half in security-policy).
+- The same screens refuse a password built out of the identity it protects: the email, its local part, the username, the display name, the site name. Compare normalized values (lowercased, accent-stripped, punctuation dropped) so `F.J.R.G_2007` and `fjrg2007` are one string, and check containment and near-matches, not just equality (the rule and the server half are security-policy's). The form already holds the email and the name the user just typed, so run it on every keystroke and name the reason inline: "Your password cannot contain your email address or username."
+- Next to it, a strength meter: a row of segments that fills and shifts colour (red, amber, green) with a one-line verdict. Drive it from an entropy estimator (`@zxcvbn-ts/core`), fed the user's own email and name as context, not from a regex counting character classes - "Passw0rd!" satisfies every class rule and is guessed instantly. The meter is advisory; the length floor and the breach check are the gate.
+- The consent banner is answered before either form submits (security-policy owns the cookie rules). Blocking the account on a "reject" is not the ask: record the choice, then continue.
 - After sign-up the user lands inside the app, already signed in. If the account still needs email verification, say so in the app with a way to resend, and block only the actions that need it.
 - Surface throttling honestly. On a `429`, show how long the wait is (from `Retry-After`), keep the button disabled with a countdown, and never swallow the response into a generic "something went wrong".
 - A one-time-code field is one input with `autocomplete="one-time-code"`, `inputmode="numeric"`, paste of the whole code, and no clearing of what the user typed on a wrong attempt. Say how many attempts are left only if the server chose to reveal it.
@@ -268,6 +290,18 @@ Auth is the first screen a user meets and the one most often shipped half-built.
 
 ---
 
+## Cookie Consent Banner
+
+A site that loads analytics, ads, A/B testing or session replay ships a consent surface. What may be set and when is security-policy's; this is the UI half.
+
+- Reject is as reachable as Accept: same level, same weight, one click. Hiding refusal behind an extra screen is a dark pattern, and in the EU it is not consent at all.
+- Three actions: accept all, reject all, and per-category choices with the strictly necessary group shown as always-on and not togglable. Nothing in the other categories loads until one of them is chosen.
+- It is a dialog over the page, not a layout shift: focus moves into it, Escape and the keyboard work, it does not sit on top of the primary action, and closing it does not reflow the page.
+- Persist the decision so it is asked once, and leave a permanent way back in (a footer link or a settings row) to change or withdraw it.
+- The login and sign-up screens do not submit while the banner is unanswered. Answer it, record the choice, then continue - including when the choice was to reject.
+
+---
+
 ## Client-Side Caching (Reduce Server Load)
 
 Cache on the client to avoid redundant server round-trips and to keep the app usable under rate limits. The goal is to reach the backend (and therefore Redis/DB) as rarely as correctness allows.
@@ -414,6 +448,19 @@ For a user-facing search box or finder over a list, use fuse.js (fuzzy search) r
 - Reach for fuse.js whenever the input is a search/filter box the user types free text into. Keep a plain equality/predicate filter only for exact, structured filtering (a status dropdown, a tag toggle) where fuzziness would be wrong.
 - Configure the searched `keys` and a sensible `threshold`, and run the search over the already-loaded client list where possible (reuse the data, per Client-Side Caching) before falling back to a server query.
 
+### Ctrl+K Opens A Command Palette Once There Is Enough To Hunt For
+
+When an app has more destinations and records than fit comfortably in the nav - roughly a dozen sidebar entries, or any list the user scrolls to find a known item - the fastest path stops being pointing and becomes typing. Ship the palette then, by default and without being asked. Before that, a three-screen app does not need one (anti-overengineering-policy).
+
+- **The shortcut is Cmd+K on macOS and Ctrl+K elsewhere**, bound once on the document and `preventDefault`ed (Ctrl+K focuses the browser's own search bar otherwise). The same handler answers `/` where the app has no text input focused, and Escape always closes.
+- **It must also be clickable.** A shortcut nobody discovers is not an entry point: put the search field in the header or at the top of the sidebar showing the shortcut hint inside it ("Search  Ctrl K"), and open the palette when it is clicked. Detect the platform for the hint rather than printing both.
+- **It opens centred over the page as a modal dialog**, near the top third so the results grow downwards without moving the input. It is a real dialog: `role="dialog"` with `aria-modal`, focus into the field, focus trapped while open, focus restored to the trigger on close, page scroll locked. Reuse the project's Modal - the palette is a variant of it, not a second dialog implementation (Component Reuse above).
+- **Search the data the client already holds**, fuzzy-matched with fuse.js in TS/JS, re-run on every keystroke - the in-memory pass is cheap and debouncing it only adds lag. Debounce only the part that reaches the server (~200-300ms) and abort the in-flight request when the query changes.
+- **Index everything the user thinks of as a thing**, not just pages: navigation destinations, records (projects, accounts, files), and actions ("Create project", "Sign out", "Toggle theme"). Group the results by kind with a heading per group, and show the destination path or a second line so two similarly named records are distinguishable.
+- **Empty query is not an empty panel.** Show recent items and the handful of most likely destinations, so opening it is useful before anything is typed.
+- **Full keyboard contract**: Up/Down move through results across group boundaries, Enter opens the highlighted one, Cmd/Ctrl+Enter opens it in a new tab where that makes sense, and the highlighted row is tracked with `aria-activedescendant` on a `role="listbox"`. The mouse hovering a row moves the highlight so the two never disagree.
+- **A no-results state names the query** and offers the nearest useful action ("No match for 'billling' - search all records"), rather than rendering nothing.
+
 ---
 
 ## AI Chat & Agent Interfaces

package/assets/skills/frontend-policy/skill.json

@@ -1,9 +1,9 @@
 {
   "name": "frontend-policy",
-  "version": "1.22.0",
+  "version": "1.23.0",
   "provider": "FJRG2007/enigma",
-  "description": "Frontend architecture: reusable components, abstraction thresholds, state management, no-op detection (skip any operation whose result equals current state, not just form saves; dirty means different from the loaded snapshot, not touched), instant first paint (render the shell, load data async, skeletons), perceived performance (prefetch on intent, debounce/throttle, cancel stale requests, avoid waterfalls, lazy widgets), large-list rendering (infinite scroll/pagination, virtualization, skeletons, progressive loading), optimistic UI with rollback, visual restraint (one card level, spacing before borders, one elevation scale), icon actions (repeated row/card actions are icon-only buttons with aria-label plus title, not text labels), responsive/adaptive layout (fluid units, breakpoints, no overlap/overflow, viewport meta, touch targets), form fields that declare their keyboard and casing (autocapitalize/autocomplete/inputmode per field kind, set once in the shared Input, normalized on blur), variable-length text (min-width:0 in flex/grid, wrap vs truncate, long unbroken strings, worst-case content checks), and AI chat/agent interfaces via Vercel's AI Elements registry instead of hand-rolled message threads.",
-  "updated": "2026-07-31T19:05:08+02:00",
-  "cliVersion": "1.33.1",
-  "sha": "79816cdc63a7fd64336b93296aada3520bab26b38a7f65600f5ca27745de3a65"
+  "description": "Frontend architecture: reusable components, abstraction thresholds, state management, no-op detection (skip any operation whose result equals current state, not just form saves; dirty means different from the loaded snapshot, not touched), instant first paint (render the shell, load data async, skeletons), perceived performance (prefetch on intent, debounce/throttle, cancel stale requests, avoid waterfalls, lazy widgets), large-list rendering (infinite scroll/pagination, virtualization, skeletons, progressive loading), optimistic UI with rollback, visual restraint (one card level, spacing before borders, one elevation scale), icon actions (repeated row/card actions are icon-only buttons with aria-label plus title, not text labels), responsive/adaptive layout (fluid units, breakpoints, no overlap/overflow, viewport meta, touch targets), form fields that declare their keyboard and casing (autocapitalize/autocomplete/inputmode per field kind, set once in the shared Input, normalized on blur), variable-length text (min-width:0 in flex/grid, wrap vs truncate, long unbroken strings, worst-case content checks), auth screens (breached-password feedback, strength meter, cookie consent before login/register), and AI chat/agent interfaces via Vercel's AI Elements registry instead of hand-rolled message threads.",
+  "updated": "2026-08-01T17:44:16+02:00",
+  "cliVersion": "1.33.3",
+  "sha": "434b0bb9dd8e19d68dc823198df64feb873e3644ae483bcd14b75d9e3d0f74ef"
 }

package/assets/skills/git-policy/skill.json

@@ -4,6 +4,6 @@
   "provider": "FJRG2007/enigma",
   "description": "Git & contribution policy (senior engineering standards).",
   "updated": "2026-07-16T22:44:02+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "e6dfbc33884000d9d25841bd9c5a84d6558ffd374882cb7b34451eb2cebc2161"
 }

package/assets/skills/logo-sourcing-policy/skill.json

@@ -7,6 +7,6 @@
     "logoColorPolicy"
   ],
   "updated": "2026-07-17T00:17:02+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "09cdbefd98625b02a7d03685e5deed128238ff8454a83fe22279610fe3ef8ddf"
 }

package/assets/skills/security-policy/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: security-policy
-description: Application and AI-agent security - secrets management, authentication and authorization (least privilege), credential flows (sign-in, sign-up that establishes the session, password reset, 2FA, and rate limiting per IP and per account), OWASP Top 10 mitigations, transport and crypto baseline, secure logging, and agent/MCP/tool-use safety (prompt injection, untrusted tool output, permission boundaries). Use when handling secrets, auth, login or registration screens, permissions, untrusted data or tool output, or any security-sensitive code, config, or infrastructure.
+description: Application and AI-agent security - secrets management, authentication and authorization (least privilege), credential flows (sign-in, sign-up that establishes the session, password reset, 2FA, breached-password checks against Have I Been Pwned, refusing a password that repeats the username, email or display name in any casing, and rate limiting per IP and per account), cookie attributes and consent gating before non-essential storage, OWASP Top 10 mitigations, transport and crypto baseline, secure logging, and agent/MCP/tool-use safety (prompt injection, untrusted tool output, permission boundaries). Use when handling secrets, auth, login or registration screens, permissions, untrusted data or tool output, or any security-sensitive code, config, or infrastructure.
 ---
 
 # Security Policy
@@ -55,6 +55,27 @@ These four screens are one system: an attacker who cannot guess a password will
 - On a successful reset: consume the token, rotate the session, and invalidate every other active session and refresh token for that account. Notify the account by email that the password changed.
 - Never send the new password by email, and never embed credentials in the link. The link proves control of the address, nothing more.
 
+### Every new password is checked against the breach corpus
+
+- Any screen where a password is CREATED - sign-up, reset confirmation, change password - checks the candidate against Have I Been Pwned's Pwned Passwords range API before accepting it. A password sitting in a public breach is already in every credential-stuffing list, whatever its length or symbol count says.
+- The API is free, needs no key and no account. Never send the password: SHA-1 the candidate, uppercase the hex, `GET https://api.pwnedpasswords.com/range/<first 5 hex chars>`, and look for the remaining 35 characters in the response, whose lines are `SUFFIX:COUNT`. Only the 5-character prefix ever leaves the client - that k-anonymity split is what the endpoint exists for.
+- Send `Add-Padding: true` so the response length cannot be used to infer which prefix was asked for.
+- Run it in real time while the user types (debounce ~400ms, abort the in-flight request when the value changes) so the answer is on screen before Submit, and run it again server-side on submit. The client check is UX; the server check is the rule.
+- Fail OPEN. If the lookup errors or times out, accept the password and log it: blocking every registration on a third-party outage is the worse failure.
+- Say what happened and what to do - "This password appeared in a data breach. Choose a different one." The breach count is optional; blaming the user is not.
+- Do not stack composition rules on top (one symbol, one digit, forced rotation). NIST SP 800-63B dropped them: a length floor (12+), the breach check, the identity check below and rate limiting are the controls that work.
+
+### A password may not be the account's own identity
+
+The same screens that check the breach corpus reject a password built out of the identity it protects. `Fjrg2007` for the user `fjrg2007` is one guess for anyone holding the email address, and it is the first thing a targeted attacker tries. NIST SP 800-63B names context-specific words - the username, the service name, the address - as the other list to refuse, next to the breach corpus.
+
+- Compare against every identifier the account is known by: the email, the email's local part, the username or handle, the display name, and the site or company name. Check each one separately; a password equal to the local part passes a check that only compared the full address.
+- **Compare NORMALIZED values, never raw ones.** Lowercase both sides, trim, normalize Unicode to NFKD and strip the accents, then drop everything that is not a letter or a digit. `F.J.R.G_2007`, `FJRG2007` and `fjrg 2007` all reduce to `fjrg2007`, which is the point: case, punctuation and spacing are not differences an attacker has to guess. Reuse the shared normalizer that already canonicalizes the email and the handle (validation-policy).
+- Reject on three relations, not just equality: the normalized password EQUALS an identifier, CONTAINS one that is 4 characters or longer (`myfjrg2007pass` still hands over the pattern), or is a near-match. For the near-match use a similarity ratio (Django's `UserAttributeSimilarityValidator` uses `SequenceMatcher` at 0.7); a padded year or a leetspeak swap (`fjrg2007!`, `fjrg20o7`) is the case that catches.
+- **The server is the authority.** It holds the real identity, so it runs the comparison on every password-creating request even when the client already did. On sign-up the values come from the submitted form; on reset and change they come from the account being modified, never from the request body.
+- A strength meter fed the user's own email and name (`@zxcvbn-ts/core` with `userInputs`) will score this password badly, and that is not the same thing: the meter is advisory and a score threshold is not a gate. Keep the equality, containment and similarity check as its own rule with its own refusal.
+- Say which rule refused and what to change: "Your password cannot contain your email address or username." At creation time the user already knows their own identifiers, so this reveals nothing an attacker could use, unlike a sign-in error.
+
 ### Rate-limit by IP AND by account
 
 - Limit both dimensions on every credential endpoint: sign-in, sign-up, password reset request, reset confirmation, email verification, 2FA/OTP verification, and any "does this identifier exist" helper the sign-in page calls.
@@ -73,6 +94,18 @@ These four screens are one system: an attacker who cannot guess a password will
 
 ---
 
+## Cookies & Consent
+
+- The session cookie is `HttpOnly`, `Secure`, `SameSite=Lax` (`Strict` where nothing legitimately enters the app cross-site), `Path=/`, with an explicit lifetime, and host-only unless a subdomain genuinely needs it. A token JavaScript can read is one XSS away from being someone else's session.
+- `SameSite=None` demands `Secure` and a stated reason: it re-opens CSRF, so it comes with a CSRF token on every state-changing request.
+- Use the `__Host-` prefix in production where the browser can enforce it (Secure, `Path=/`, no `Domain`).
+- Classify every cookie before setting it: strictly necessary (session, CSRF, load balancing, the consent record itself) against everything else (analytics, A/B, ads, session replay). Only the first group may be set before the user has answered.
+- Nothing in the second group runs until then. No analytics snippet, no tag manager, no third-party pixel, no `document.cookie` write, no `localStorage` copy of the same data: swapping the storage mechanism does not change the rule.
+- Record the decision - what was accepted, when, against which policy version - and make withdrawing it as easy as giving it.
+- An auth flow never starts with the banner unanswered: require the consent decision before sign-in or sign-up proceeds, so nothing is planted mid-flow behind the user's back. Accepting the non-essential ones must not be the price of an account - a "reject" that still signs the user in is what keeps this lawful under GDPR/ePrivacy, and the session cookie is strictly necessary anyway, so it needs no consent.
+
+---
+
 ## OWASP Top 10 Baseline
 
 - Injection (SQL/NoSQL/command/LDAP): use parameterized queries and safe APIs; never build queries or shell commands by string concatenation (query specifics in database-expert).

package/assets/skills/security-policy/skill.json

@@ -1,9 +1,9 @@
 {
   "name": "security-policy",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "provider": "FJRG2007/enigma",
-  "description": "Application and AI-agent security: secrets, authn/authz (least privilege), OWASP Top 10, transport/crypto baseline, secure logging, and agent/MCP/tool-use safety.",
-  "updated": "2026-07-31T16:26:45+02:00",
-  "cliVersion": "1.33.1",
-  "sha": "e5e7ac2791919e4b8483115ee8b83800c5ebdf4eebde019650d974b400417c55"
+  "description": "Application and AI-agent security: secrets, authn/authz (least privilege), credential flows with breach-checked passwords (Have I Been Pwned), OWASP Top 10, transport/crypto baseline, cookies and consent, secure logging, and agent/MCP/tool-use safety.",
+  "updated": "2026-08-01T17:44:16+02:00",
+  "cliVersion": "1.33.3",
+  "sha": "c9eac7999b326e4564816b10f3f681b9f6b2a88595d56244909757fb4bbc3c7f"
 }

package/assets/skills/skill-creator/skill.json

@@ -4,6 +4,6 @@
   "provider": "FJRG2007/enigma",
   "description": "Create new skills, modify and improve existing skills, and measure skill performance with evals and benchmarks.",
   "updated": "2026-07-29T01:18:36+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "13d24c217bdb6fe83fe16835d8f5c3d397a9f3338f16876c61ef96e97f34c90a"
 }

package/assets/skills/task-completion-policy/skill.json

@@ -4,6 +4,6 @@
   "provider": "FJRG2007/enigma",
   "description": "Exhaustive completion discipline for long/multi-item tasks - inventory, coverage ledger, verified done.",
   "updated": "2026-07-30T20:10:24+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "2f82288d83dca3676d6bc49955c89477cc298f77fa56b4e414cd95ff858fa261"
 }

package/assets/skills/technical-writing-policy/skill.json

@@ -4,6 +4,6 @@
   "provider": "FJRG2007/enigma",
   "description": "Concise, realistic technical copy - UI microcopy, descriptions, hints, empty/error states, and README/doc prose that informs without over-explaining or restating the obvious, and never uses a typographic dash.",
   "updated": "2026-07-28T20:30:23+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "a4b792103eb1f9dad93b9d70ea79dc18fe9cbbc318facf5adb47ae5907d842f9"
 }

package/assets/skills/testing-policy/skill.json

@@ -4,6 +4,6 @@
   "provider": "FJRG2007/enigma",
   "description": "Test strategy, coverage gates, deterministic tests, mocking discipline, regression-first bug fixing, and test-suite organization (layout by type/domain, mirrored paths, file naming, fixture/helper placement).",
   "updated": "2026-06-16T17:11:49+02:00",
-  "cliVersion": "1.33.1",
+  "cliVersion": "1.33.3",
   "sha": "3bdf591057b760f674fb2b1425f63acb426cda2c4f042e1a74c5a5d3807df664"
 }

package/assets/skills/validation-policy/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: validation-policy
-description: Strict frontend + backend schema validation (Zod or equivalent), normalization before validation (one shared normalizer on both sides - trim, lowercase the email, capitalize each word of a name, canonicalize a profile link or handle) and the rule that a check which cannot fail is not validation, schema consistency between client and server, and safe client-facing error handling. Use when handling any external input - forms, API request bodies, query params, CLI args, file parsing, or third-party payloads.
+description: Strict frontend + backend schema validation (Zod or equivalent), normalization before validation (one shared normalizer on both sides - trim, lowercase the email, capitalize each word of a name, canonicalize a profile link or handle) and the rule that a check which cannot fail is not validation, cross-field rules declared on the object schema rather than the field (password against the email or username, confirmation fields, date ranges), schema consistency between client and server, and safe client-facing error handling. Use when handling any external input - forms, API request bodies, query params, CLI args, file parsing, or third-party payloads.
 ---
 
 # Validation & Error Handling Policy
@@ -83,6 +83,15 @@ Per field kind (defaults - override only with a reason):
 - Before calling a field done, type three wrong values into it and confirm each is rejected. A validator nobody has watched fail is unverified.
 - The same applies to a permissive fallback: an `.optional()` that swallows `""`, a `catch()` that returns a default, or a `refine` that returns `true` on anything it cannot parse.
 
+### A rule about two fields lives on the object, not the field
+
+Some rules cannot be expressed where the field is declared, because the field cannot see its siblings. `z.string().min(12)` for a password is a complete-looking schema that has no way to know the email sitting next to it, which is how "the password may not be your email" ends up unimplemented on a form that otherwise validates everything.
+
+- Put cross-field rules on the OBJECT schema (`.superRefine`/`.refine` in Zod, a `model_validator` in Pydantic), and attach the error to the field the user has to change so it renders in that field's error slot, not at the top of the form.
+- The recurring ones: password against the email, its local part, the username, the display name and the site name (normalized on both sides, per security-policy); the confirmation field against the password; a start date against an end date; a "one of these is required" pair.
+- Give the object schema everything it needs to compare. On the server the identity usually comes from the account being modified rather than the request body, so build the schema with that value in scope (a factory that takes the identifiers and returns the schema) instead of trusting whatever the client sent.
+- The client mirrors the same object schema so the conflict shows as the user types, and the server runs it again as the authority.
+
 ---
 
 ## Validation Standards

package/assets/skills/validation-policy/skill.json

@@ -3,7 +3,7 @@
   "version": "1.4.0",
   "provider": "FJRG2007/enigma",
   "description": "Strict frontend + backend schema validation, normalization before validation (shared normalizers: trim, lowercase email, capitalize names, canonicalize links and handles), schema consistency, and safe client-facing error handling.",
-  "updated": "2026-07-31T19:05:08+02:00",
-  "cliVersion": "1.33.1",
-  "sha": "84bb43cc570aa927ab5c0311c17242b4158287961aa04af111cf83eb4eec6ce4"
+  "updated": "2026-08-01T17:44:16+02:00",
+  "cliVersion": "1.33.3",
+  "sha": "225e1e26f4a49fac70714b1bebc104ea42143203cc8fcc9e3330b29f05b6e025"
 }

package/bin/checksums.json

@@ -1,6 +1,6 @@
 {
-  "enigma-darwin-arm64": "f9e83b3b9be12c8248957edaff5aaf673e9449524c70938a28a7c9c999946ddd",
-  "enigma-linux-arm64": "04ebf9604c6a01bb1630d8737f297076bb2ea7c5708910dd9f6fbdfb88fc1d37",
-  "enigma-linux-x64": "6cce08f880b4c0de0c3304129384de6a07f4055b3c2a05587a238bc764679e03",
-  "enigma-win32-x64.exe": "e17d305ca7fff13f07df054d87e17e1333c483231d8bfde31fe5aa8898c6718e"
+  "enigma-darwin-arm64": "286cca0f828af2df05e34bbf8e65739191fd32828800780f639adf033da3534e",
+  "enigma-linux-arm64": "97df04765c3aab4ea4ed2737409cee89a4993e82627016dbdd0b6beabff06fec",
+  "enigma-linux-x64": "b328e77ba40317e71a0c41cac400e70f7d74fb45c33491525137ed62f359a271",
+  "enigma-win32-x64.exe": "3cf574dc946b3d4294ef8c368d79e18acf42de6a65100a54d41a8b98f5375d06"
 }

package/dist/guardrails.js

@@ -4,8 +4,8 @@
 import { homedir } from "os";
 import { fileURLToPath } from "url";
 import { execFileSync } from "child_process";
-import { readFileSync, statSync, existsSync } from "fs";
 import { dirname, join, resolve } from "path";
+import { readFileSync, writeFileSync, statSync, existsSync } from "fs";
 var COMMENT_LINE = /^\s*(\/\/|#|\*|--|<!--|\{?\/\*)/;
 var BUILTIN_RULES = [
   {
@@ -195,6 +195,163 @@ var BUILTIN_RULES = [
     severity: "block",
     skill: "frontend-policy"
   },
+  {
+    id: "fe-name-value-normalize",
+    label: "A person-name value is normalized, not just autocapitalized",
+    files: ["*.tsx", "*.jsx", "*.vue", "*.svelte", "*.astro", "*.html", "*.htm"],
+    excludeFiles: [
+      "*.test.*",
+      "*.spec.*",
+      "**/tests/**",
+      "**/__tests__/**",
+      "**/stories/**",
+      "*.stories.*",
+      "*.min.js",
+      "**/dist/**",
+      "**/build/**",
+      "**/_build/**",
+      "**/node_modules/**",
+      "**/vendor/**",
+      "dist/**",
+      "build/**",
+      "_build/**",
+      "node_modules/**",
+      "vendor/**"
+    ],
+    scope: "file",
+    // The twin of fe-name-input-capitalize, and the half that actually reaches the stored
+    // value: `autocapitalize` is a KEYBOARD hint. A phone honours it, a physical keyboard
+    // ignores it entirely, so "juan perez" typed on a laptop is stored exactly like that and
+    // the field looks broken to the user who typed it. The attribute alone clears the other
+    // rule, which is how a form ends up with the attribute and no normalization at all.
+    // Same person-name token set (see there for why `name`/`fullname` are excluded).
+    pattern: `autocomplete=\\{?["'](?:name|given-name|family-name|additional-name|honorific-prefix)["']|(?:\\bname|\\bid|\\bfor|formControlName)=\\{?["'](?:first[-_]?name|last[-_]?name|given[-_]?name|family[-_]?name|surname|apellidos?)["']`,
+    absent: "capitalizeWords|capitalizeName|capitalizeEach|toTitleCase|titleCase|startCase|properCase|normalizeName|normalizePerson|capitalize\\(|charAt\\(0\\)\\.toUpperCase|enigma:allow-no-capitalize",
+    message: 'Person-name field with no value normalization. `autocapitalize="words"` only shapes the phone keyboard - a physical keyboard ignores it, so "juan perez" is stored verbatim. Normalize the VALUE with the shared normalizer (validation-policy): trim, collapse inner spaces, and uppercase the first letter of every word, ONLY that letter, so `McDonald`, `O\'Brien` and `van der Berg` survive. Run it on blur (never on every keystroke - it moves the caret and breaks IME composition) and again on the server, which is the copy that decides what is stored. Put it in the shared Input/TextField so the next form gets it by construction. For a field that must keep exactly what was typed, add an `enigma:allow-no-capitalize` note (validation-policy, frontend-policy).',
+    severity: "block",
+    skill: "validation-policy"
+  },
+  {
+    id: "sec-password-breach-check",
+    label: "A new password is checked against the breach corpus",
+    files: ["*.tsx", "*.jsx", "*.vue", "*.svelte", "*.astro", "*.html", "*.htm", "*.ts", "*.js"],
+    excludeFiles: [
+      "*.test.*",
+      "*.spec.*",
+      "**/tests/**",
+      "**/__tests__/**",
+      "**/stories/**",
+      "*.stories.*",
+      "*.min.js",
+      "**/dist/**",
+      "**/build/**",
+      "**/_build/**",
+      "**/node_modules/**",
+      "**/vendor/**",
+      "dist/**",
+      "build/**",
+      "_build/**",
+      "node_modules/**",
+      "vendor/**"
+    ],
+    scope: "file",
+    // `autocomplete="new-password"` is the spec's own marker for a password being CREATED -
+    // sign-up, reset confirmation, change password - and never appears on a sign-in form
+    // (that one is `current-password`). So it selects exactly the screens where the check
+    // belongs, with no path guessing. Any mention of the check anywhere in the file clears
+    // it, including a call into a shared hook whose name carries `pwned`/`breach`.
+    pattern: `autocomplete=\\{?["']new-password["']`,
+    absent: "pwnedpasswords|haveibeenpwned|hibp|pwned|breach|enigma:allow-no-breach-check",
+    message: "A password is created here with no breach check. Length and symbol rules do not stop a password that is already in a credential-stuffing list. Check it against Have I Been Pwned's Pwned Passwords range API - free, no key, and the password never leaves the client: SHA-1 it, uppercase the hex, GET https://api.pwnedpasswords.com/range/<first 5 chars> with `Add-Padding: true`, and look for the remaining 35 characters in the `SUFFIX:COUNT` lines. Debounce it as the user types, abort the in-flight request when the value changes, repeat the check server-side on submit, and fail OPEN if the lookup errors so an outage never blocks a signup. For a flow that genuinely cannot reach it, add an `enigma:allow-no-breach-check` note (security-policy).",
+    severity: "block",
+    skill: "security-policy"
+  },
+  {
+    id: "sec-password-identity-match",
+    label: "A new password is not the account's own identity",
+    files: ["*.tsx", "*.jsx", "*.vue", "*.svelte", "*.astro", "*.html", "*.htm", "*.ts", "*.js"],
+    excludeFiles: [
+      "*.test.*",
+      "*.spec.*",
+      "**/tests/**",
+      "**/__tests__/**",
+      "**/stories/**",
+      "*.stories.*",
+      "*.min.js",
+      "**/dist/**",
+      "**/build/**",
+      "**/_build/**",
+      "**/node_modules/**",
+      "**/vendor/**",
+      "dist/**",
+      "build/**",
+      "_build/**",
+      "node_modules/**",
+      "vendor/**"
+    ],
+    scope: "file",
+    // The twin of sec-password-breach-check over the same selector, for the same reason the
+    // name rules are two: one `absent` cannot express "breach check AND identity check", and
+    // a file that does one is routinely missing the other. Same precision inheritance -
+    // `autocomplete="new-password"` marks a password being CREATED and nothing else.
+    // The `absent` set is deliberately NOT `email|username`: every sign-up form on earth
+    // mentions both, so keying on them would clear the rule everywhere it matters. It clears
+    // only on evidence of a COMPARISON - zxcvbn fed the user's own inputs (advisory, but a
+    // form gating on its score is a real implementation), Django's similarity validator, a
+    // helper named for the check, or password and an identifier on the same line either side
+    // of an equality/containment operator.
+    pattern: `autocomplete=\\{?["']new-password["']`,
+    absent: "userInputs|user_inputs|UserAttributeSimilarity|sameAs(?:Email|Username|Identity)|matchesIdentity|containsIdentity|identityMatch|notIdentity|personalInfo|(?:password|passwd|pwd)[^\\n]{0,60}(?:===|==|!==|\\.includes\\(|\\.indexOf\\(|\\.startsWith\\(|localeCompare)[^\\n]{0,60}(?:email|username|user_?name|handle)|(?:email|username|user_?name|handle)[^\\n]{0,60}(?:===|==|!==|\\.includes\\(|\\.indexOf\\(|\\.startsWith\\(|localeCompare)[^\\n]{0,60}(?:password|passwd|pwd)|enigma:allow-identity-password",
+    message: "A password is created here with nothing stopping it from being the account's own identity. `Fjrg2007` for the user `fjrg2007` is one guess for anyone who knows the email address. Refuse a candidate that equals, contains (4 characters or more), or closely resembles the email, its local part, the username, the display name or the site name - comparing NORMALIZED values on both sides (lowercase, trim, NFKD then strip accents, drop everything that is not a letter or a digit), so `F.J.R.G_2007` and `fjrg2007` are the same string and casing is never a difference. Declare it on the OBJECT schema, since a password field cannot see the email beside it, and run it again on the server where the real identity lives. A strength meter fed `userInputs` scores this badly but is advisory - keep the refusal as its own rule. For a flow with no identity to compare against, add an `enigma:allow-identity-password` note (security-policy, validation-policy).",
+    severity: "block",
+    skill: "security-policy"
+  },
+  // NOTE: no rule for the navigation conventions - nav entries carrying icons, a long nav
+  // grouped into labelled sections, and a Cmd/Ctrl+K command palette once the app has enough
+  // to hunt through. All three were measured and rejected; they live in frontend-policy's
+  // "Navigation Is Structured, Not A Growing List" and "Search & Filtering" sections only.
+  // The signature would have to be DENSITY - a file rendering many destinations - and density
+  // does not separate the app shell (where these belong) from a landing page or a docs page
+  // (where an icon per link and a palette would both be wrong). Measured over the corpus:
+  // 174 UI files, 29 with 8 or more links, and of the 4 with no search affordance every one
+  // is marketing or static docs - zero true positives, the same evidence that rejected the
+  // no-op-save and pinned-sidebar rules. Keying on a *sidebar*/*nav* filename instead found
+  // 2 candidates in the whole corpus, both terminal (ink) menus, so it has no signal either.
+  {
+    id: "fe-tracking-before-consent",
+    label: "Non-essential tracking waits for consent",
+    files: ["*.tsx", "*.jsx", "*.vue", "*.svelte", "*.astro", "*.html", "*.htm", "*.ts", "*.js", "*.mts", "*.cts"],
+    excludeFiles: [
+      "*.test.*",
+      "*.spec.*",
+      "**/tests/**",
+      "**/__tests__/**",
+      "**/stories/**",
+      "*.stories.*",
+      "*.min.js",
+      "**/dist/**",
+      "**/build/**",
+      "**/_build/**",
+      "**/node_modules/**",
+      "**/vendor/**",
+      "dist/**",
+      "build/**",
+      "_build/**",
+      "node_modules/**",
+      "vendor/**"
+    ],
+    scope: "file",
+    // The loaders and call sites of the common analytics/ads/replay vendors. Each one sets
+    // non-essential storage the moment it runs, so what matters is whether ANY consent
+    // handling exists in the same file - the gate, a Consent Mode default, or the stored
+    // decision being read. `consent` on its own clears it, deliberately generous: this rule
+    // catches the snippet pasted straight into the layout, not a considered implementation.
+    pattern: "googletagmanager\\.com|google-analytics\\.com|gtag\\(|dataLayer\\.push|connect\\.facebook\\.net|fbq\\(|mixpanel\\.|posthog\\.(?:init|capture)|amplitude\\.(?:init|getInstance)|static\\.hotjar\\.com|clarity\\.ms|cdn\\.segment\\.com",
+    absent: "consent|gdpr|cookieBanner|cookie-banner|CookieConsent|enigma:allow-no-consent",
+    message: "Analytics, ads or session replay loading with no consent gate in sight. Everything outside the strictly necessary group (session, CSRF, load balancing, the consent record) stays off until the user answers the banner - swapping the cookie for `localStorage` does not change that. Load the vendor only after the stored decision says so (or start in Consent Mode with everything denied and update on accept), make Reject as reachable as Accept, and keep the decision withdrawable. If this file genuinely runs after the gate, add an `enigma:allow-no-consent` note (security-policy, frontend-policy).",
+    severity: "block",
+    skill: "security-policy"
+  },
   {
     id: "fe-no-native-dialog",
     label: "No native browser dialogs",
@@ -856,6 +1013,43 @@ var PROJECT_CHECKS = {
 var FILE_CHECKS = {
   "proc-windows-hide": (content) => missingWindowsHide(content)
 };
+var FIXERS = {
+  "fe-name-input-capitalize": (line, file) => {
+    if (/autocapitalize/i.test(line)) return null;
+    const tags = line.match(/<input\b/gi);
+    if (!tags || tags.length !== 1) return null;
+    const attr = /\.[jt]sx$/i.test(file) ? 'autoCapitalize="words"' : 'autocapitalize="words"';
+    return line.replace(/<input\b/i, `<input ${attr}`);
+  }
+};
+function applyFixes(file, findings) {
+  const fixable = findings.filter((f) => f.line && FIXERS[f.ruleId]);
+  if (!fixable.length) return { fixed: [], remaining: findings };
+  let content;
+  try {
+    content = readFileSync(file, "utf8");
+  } catch {
+    return { fixed: [], remaining: findings };
+  }
+  const lines = content.split("\n");
+  const fixed = [];
+  for (const f of fixable) {
+    const idx = f.line - 1;
+    const before = lines[idx];
+    if (before === void 0) continue;
+    const after = FIXERS[f.ruleId](before, file);
+    if (after === null || after === before) continue;
+    lines[idx] = after;
+    fixed.push(f);
+  }
+  if (!fixed.length) return { fixed: [], remaining: findings };
+  try {
+    writeFileSync(file, lines.join("\n"));
+  } catch {
+    return { fixed: [], remaining: findings };
+  }
+  return { fixed, remaining: checkPath(file) };
+}
 var SPAWNERS = /* @__PURE__ */ new Set(["spawn", "spawnSync", "exec", "execSync", "execFile", "execFileSync"]);
 function spawnerBindings(content) {
   const names = /* @__PURE__ */ new Set();
@@ -1023,7 +1217,12 @@ function runGuardrailsHook(payload) {
   } catch {
   }
   if (!file || typeof file !== "string") return 0;
-  const findings = checkPath(file);
+  const found = checkPath(file);
+  if (!found.length) return 0;
+  const { fixed, remaining: findings } = applyFixes(file, found);
+  if (fixed.length) process.stdout.write(`enigma guardrails (fixed)
+${fixed.map((f) => `${f.file}:${f.line} (${f.ruleId})`).join("\n")}
+`);
   if (!findings.length) return 0;
   const warns = findings.filter((f) => f.severity === "warn");
   const blocks = findings.filter((f) => f.severity === "block");
@@ -1093,7 +1292,9 @@ if (isGrEntry && fileURLToPath(import.meta.url) === grEntry) {
 export {
   BUILTIN_RULES,
   FILE_CHECKS,
+  FIXERS,
   PROJECT_CHECKS,
+  applyFixes,
   checkFile,
   checkPath,
   findProjectRoot,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enigma-cli",
-  "version": "1.33.1",
+  "version": "1.33.3",
   "description": "Everything you need to work with a coding agent: install shared policy skills for Claude Code, OpenAI Codex and opencode, and set up portable git security hooks.",
   "type": "module",
   "bin": {