@agentvibes/guardrails 0.1.0

package/rules/as-any-escape-tsx.yml

@@ -0,0 +1,53 @@
+# ── rule body adopted from faceless-photo-lib `no-as-any` (wave 2 triage) ──
+# The two rules were duplicates; the faceless implementation is strictly better,
+# so the canon id keeps its message and takes that body. Why it is better here:
+# surface `pattern:` is compared at ast-grep's default `smart` strictness, which
+# also compares interleaved `comment` nodes — so `x as /* why */ any` slipped
+# straight through. The structural form cannot be fooled that way.
+#
+# The .tsx half of `as-any-escape`.
+#
+# ast-grep's `typescript` and `tsx` languages are DISJOINT, not nested: a rule
+# at `language: typescript` matches `.ts` and NEVER `.tsx`, so `as-any-escape`
+# was blind to every React component file. Verified by effect — byte-identical
+# content in `p.ts` and `p.tsx`, the first flagged and the second silent.
+#
+# Three ways to cover both were tried and two were rejected on measurement:
+#   - `language: [typescript, tsx]` — ast-grep refuses to parse the rule.
+#   - `languageGlobs: {tsx: ["*.ts"]}` — reassigns `.ts` to the tsx language, so
+#     EVERY remaining `language: typescript` rule goes dark. Measured corpus-wide:
+#     5 rules blinded, 6,094 findings lost against 334 gained. It would have
+#     looked like a coverage win.
+#   - two files with the SAME id — "Error: Duplicate rule id".
+# So: a separate id per language. The trailing `-tsx` is what you suppress with
+# in a .tsx file, and the finding prints the id, so copying from the output is
+# always right.
+#
+# Keep this file's `rule:` block IDENTICAL to `as-any-escape.yml`. They are one
+# rule wearing two ids because the tool has no way to say "both languages".
+id: as-any-escape-tsx
+language: tsx
+severity: error
+message: |
+  `as any` / `as unknown as` hides real type bugs that surface as runtime crashes.
+  Fix the type at the source (Zod schema, interface), use a type guard, or .parse() at the boundary.
+  See defensive-errors Rule 7.
+  Suppressing this one needs the id you see above — `ast-grep-ignore: as-any-escape-tsx`.
+  `as-any-escape` is a DIFFERENT rule (the .ts arm) and does not cover it; ast-grep
+  matches suppression ids exactly. A bare `// ast-grep-ignore` suppresses every
+  rule on the line, and a wrong id is reported back as `unused-suppression`.
+rule:
+  any:
+    # `x as any`
+    - kind: as_expression
+      has:
+        kind: predefined_type
+        regex: "^any$"
+    # `x as unknown as T` — the double-cast that launders `unknown` back to a
+    # concrete type without validating anything.
+    - kind: as_expression
+      has:
+        kind: as_expression
+        has:
+          kind: predefined_type
+          regex: "^unknown$"

package/rules/as-any-escape.yml

@@ -0,0 +1,29 @@
+# ── rule body adopted from faceless-photo-lib `no-as-any` (wave 2 triage) ──
+# The two rules were duplicates; the faceless implementation is strictly better,
+# so the canon id keeps its message and takes that body. Why it is better here:
+# surface `pattern:` is compared at ast-grep's default `smart` strictness, which
+# also compares interleaved `comment` nodes — so `x as /* why */ any` slipped
+# straight through. The structural form cannot be fooled that way.
+#
+id: as-any-escape
+language: typescript
+severity: error
+message: |
+  `as any` / `as unknown as` hides real type bugs that surface as runtime crashes.
+  Fix the type at the source (Zod schema, interface), use a type guard, or .parse() at the boundary.
+  See defensive-errors Rule 7.
+rule:
+  any:
+    # `x as any`
+    - kind: as_expression
+      has:
+        kind: predefined_type
+        regex: "^any$"
+    # `x as unknown as T` — the double-cast that launders `unknown` back to a
+    # concrete type without validating anything.
+    - kind: as_expression
+      has:
+        kind: as_expression
+        has:
+          kind: predefined_type
+          regex: "^unknown$"

package/rules/catch-empty-tsx.yml

@@ -0,0 +1,55 @@
+# ── rule body adopted from faceless-photo-lib `no-empty-catch` (wave 2 triage) ──
+# The two rules were duplicates; the faceless implementation is strictly better,
+# so the canon id keeps its message and takes that body. Why it is better here:
+# the old patterns covered `catch {}` and `catch (e) {}` but NOT `catch (e:
+# unknown) {}` / `catch (e: any) {}` — the type annotation is an extra named node.
+# Measured on tg-gallery + observatory + byok + faceless: 0 files lost, 1 gained,
+# and the finding now anchors on the `catch` keyword rather than the `try`.
+#
+# The .tsx half of `catch-empty`.
+#
+# ast-grep's `typescript` and `tsx` languages are DISJOINT, not nested: a rule
+# at `language: typescript` matches `.ts` and NEVER `.tsx`, so `catch-empty`
+# was blind to every React component file. Verified by effect — byte-identical
+# content in `p.ts` and `p.tsx`, the first flagged and the second silent.
+#
+# Three ways to cover both were tried and two were rejected on measurement:
+#   - `language: [typescript, tsx]` — ast-grep refuses to parse the rule.
+#   - `languageGlobs: {tsx: ["*.ts"]}` — reassigns `.ts` to the tsx language, so
+#     EVERY remaining `language: typescript` rule goes dark. Measured corpus-wide:
+#     5 rules blinded, 6,094 findings lost against 334 gained. It would have
+#     looked like a coverage win.
+#   - two files with the SAME id — "Error: Duplicate rule id".
+# So: a separate id per language. The trailing `-tsx` is what you suppress with
+# in a .tsx file, and the finding prints the id, so copying from the output is
+# always right.
+#
+# Keep this file's `rule:` block IDENTICAL to `catch-empty.yml`. They are one
+# rule wearing two ids because the tool has no way to say "both languages".
+id: catch-empty-tsx
+language: tsx
+severity: error
+message: |
+  Empty catch silently swallows errors. Either handle specifically OR log + rethrow OR
+  return an explicit discriminated failure variant.
+  See defensive-errors Rule 8.
+  Suppressing this one needs the id you see above — `ast-grep-ignore: catch-empty-tsx`.
+  `catch-empty` is a DIFFERENT rule (the .ts arm) and does not cover it; ast-grep
+  matches suppression ids exactly. A bare `// ast-grep-ignore` suppresses every
+  rule on the line, and a wrong id is reported back as `unused-suppression`.
+rule:
+  any:
+    - pattern:
+        context: "try { work(); } catch { }"
+        selector: catch_clause
+        strictness: relaxed
+    - pattern:
+        context: "try { work(); } catch (e) { }"
+        selector: catch_clause
+        strictness: relaxed
+    # `catch (e: unknown)` / `catch (e: any)` — the annotation is an extra named
+    # node, so the untyped pattern above does not cover it.
+    - pattern:
+        context: "try { work(); } catch (e: unknown) { }"
+        selector: catch_clause
+        strictness: relaxed

package/rules/catch-empty.yml

@@ -0,0 +1,31 @@
+# ── rule body adopted from faceless-photo-lib `no-empty-catch` (wave 2 triage) ──
+# The two rules were duplicates; the faceless implementation is strictly better,
+# so the canon id keeps its message and takes that body. Why it is better here:
+# the old patterns covered `catch {}` and `catch (e) {}` but NOT `catch (e:
+# unknown) {}` / `catch (e: any) {}` — the type annotation is an extra named node.
+# Measured on tg-gallery + observatory + byok + faceless: 0 files lost, 1 gained,
+# and the finding now anchors on the `catch` keyword rather than the `try`.
+#
+id: catch-empty
+language: typescript
+severity: error
+message: |
+  Empty catch silently swallows errors. Either handle specifically OR log + rethrow OR
+  return an explicit discriminated failure variant.
+  See defensive-errors Rule 8.
+rule:
+  any:
+    - pattern:
+        context: "try { work(); } catch { }"
+        selector: catch_clause
+        strictness: relaxed
+    - pattern:
+        context: "try { work(); } catch (e) { }"
+        selector: catch_clause
+        strictness: relaxed
+    # `catch (e: unknown)` / `catch (e: any)` — the annotation is an extra named
+    # node, so the untyped pattern above does not cover it.
+    - pattern:
+        context: "try { work(); } catch (e: unknown) { }"
+        selector: catch_clause
+        strictness: relaxed

package/rules/classname-not-composed.yml

@@ -0,0 +1,28 @@
+id: classname-not-composed
+language: tsx
+severity: error
+message: |
+  className built by string interpolation or a ternary. Class strings are a
+  vocabulary, not text to concatenate: compose them with `cn(...)` so
+  conflicting utilities resolve predictably, or — better — select a variant
+  prop on the UI component that owns those classes.
+    ❌ className={`card ... ${isOver ? "ring-2 ring-accent" : ""}`}
+    ✅ className={cn("card ...", isOver && "ring-2 ring-accent")}
+    ✅ <Card selected={isOver} />
+  See the ui-components skill (style vocabulary is centralized).
+rule:
+  all:
+    # A bare `className={$EXPR}` pattern does not parse standalone — a JSX
+    # attribute is not a valid program — so it needs context + selector.
+    - pattern:
+        context: '<a className={$EXPR} />'
+        selector: jsx_attribute
+    - has:
+        stopBy: end
+        any:
+          - kind: template_string
+          - kind: ternary_expression
+  not:
+    has:
+      stopBy: end
+      pattern: cn($$$)

package/rules/classname-visual-identity.yml

@@ -0,0 +1,34 @@
+id: classname-visual-identity
+language: tsx
+severity: warning
+message: |
+  Visual-identity utilities (colour, ring, shadow, radius, opacity, animation,
+  type scale) written in an app component. Those classes are the design
+  language — they belong to the UI component that owns them, selected through a
+  variant prop, not scattered across screens.
+    ❌ <button className="rounded-lg bg-red-500/20 px-2 text-red-200">
+    ✅ <Button tone="danger" size="sm">
+  Layout utilities (flex, grid, gap-*, p-*, w-*, items-*) stay legal here —
+  layout is per-screen composition, not identity. See the ui-components skill.
+  If this genuinely has no UI-component home yet, suppress with a justification.
+ignores:
+  - '**/packages/ui/**'
+  - '**/components/ui/**'
+  - '**/src/ui/**'
+  - '**/*.test.tsx'
+  - '**/*.stories.tsx'
+rule:
+  all:
+    # Matched by kind, not by pattern, so that BOTH attribute forms are covered:
+    # className="..." (plain string) and className={...} (expression container).
+    - kind: jsx_attribute
+    - has:
+        kind: property_identifier
+        regex: '^className$'
+    - has:
+        stopBy: end
+        any:
+          - kind: string_fragment
+            regex: '(^|[\s"''`:])(bg-|ring-|shadow-|animate-|rounded-|opacity-|backdrop-|text-(xs|sm|base|lg|xl|[2-9]xl|red|green|amber|blue|slate|gray|zinc|white|black)|border-(red|green|amber|blue|slate|gray|zinc|white|black))'
+          - kind: string_fragment
+            regex: 'text-tg-|bg-tg-|ring-tg-|border-tg-'

package/rules/demo-mode-by-default-ts.yml

@@ -0,0 +1,76 @@
+# ── the .ts half of `demo-mode-by-default` ─────────────────────────────
+#
+# Same disjoint-language problem the `-tsx` twins solve, running the other way:
+# `demo-mode-by-default` is `language: tsx`, so it matched `.tsx` and NEVER
+# `.ts`. Verified by effect — an `initialState()` returning `{ mode: "demo" }`
+# flagged as `s.tsx` and completely silent as `s.ts`.
+#
+# That is the wrong half to be blind in. An `initialState` / `defaultState`
+# function returning a demo source lives in a plain `.ts` store, reducer or
+# config file at least as often as in a component, and this is the rule guarding
+# `fake-data.md` — "NEVER make a demo/fixture/mock source the DEFAULT". A rule
+# that stops at the component boundary is not guarding that.
+#
+# Costs nothing to close: 0 sites across all 69 repos under ~/gits/github,
+# counted BY RULE ID. (Counting every finding the config emits instead counts
+# `unused-suppression` and reads 205 — that mistake was made and caught.) And
+# the 0 is clean rather than broken: the rule fires on a known positive.
+#
+# Keep this file's `rule:` block IDENTICAL to `demo-mode-by-default.yml`.
+#
+# A fixture/demo/mock source chosen as the DEFAULT data source.
+#
+# The failure this encodes: apps/substrate-app shipped with
+#   function initialState(boot, narrow): State { … mode: { kind: "demo" }, … }
+# so the deployed site always opened on in-memory fixtures that accepted writes
+# and forgot them at reload. The owner worked in it for days and lost the issues
+# he had filed (2026-08-07).
+#
+# Scoped deliberately narrow — only the positions that decide what the app STARTS
+# on: an `initialState`-family function, a DEFAULT_/INITIAL_ binding, or the
+# initial argument of useState/useReducer. A demo literal inside a `.with(...)`
+# match arm is the correct pattern (an explicit flag selecting the sandbox) and is
+# excluded.
+#
+# Validated against the real pre-fix store.tsx: 1 hit at the exact declaration,
+# 0 on the fixed version, 0 across substrate-app, tg-gallery webapp and
+# agent-workbench web.
+id: demo-mode-by-default-ts
+language: typescript
+severity: error
+message: "A fixture/demo/mock source is the DEFAULT here. The default must be the real source; the sandbox belongs behind an explicit flag."
+note: |
+  The default data source must be the real one. Put the sandbox behind an
+  explicit opt-in (`?mode=demo`, a flag, a separate entry) whose absence means
+  real, and make writes that cannot persist FAIL rather than report success.
+  See the fake-data-boundaries skill.
+  Suppressing this one needs the id you see above — `ast-grep-ignore: demo-mode-by-default-ts`.
+  `demo-mode-by-default` is a DIFFERENT rule (the .tsx arm) and does not cover it.
+rule:
+  all:
+    - kind: pair
+    - has:
+        field: key
+        regex: '^(kind|mode|backend|source|dataSource|driver|adapter|transport|client)$'
+    - has:
+        field: value
+        regex: '^.(demo|mock|fixture|fake|stub|sample|seed).$'
+    - not:
+        inside:
+          stopBy: end
+          any:
+            - pattern: $OBJ.with($$$WARGS)
+            - pattern: $OBJ.when($$$WARGS)
+    - inside:
+        stopBy: end
+        any:
+          - kind: function_declaration
+            has:
+              field: name
+              regex: '^(initialState|createInitialState|defaultState|makeInitialState|initState|createDefaultState)$'
+          - kind: variable_declarator
+            has:
+              field: name
+              regex: '^(INITIAL_STATE|DEFAULT_STATE|INITIAL_MODE|DEFAULT_MODE|DEFAULT_BACKEND|initialState|defaultState)$'
+          - pattern: useState($$$ARGS)
+          - pattern: useReducer($$$ARGS)

package/rules/demo-mode-by-default.yml

@@ -0,0 +1,54 @@
+# A fixture/demo/mock source chosen as the DEFAULT data source.
+#
+# The failure this encodes: apps/substrate-app shipped with
+#   function initialState(boot, narrow): State { … mode: { kind: "demo" }, … }
+# so the deployed site always opened on in-memory fixtures that accepted writes
+# and forgot them at reload. The owner worked in it for days and lost the issues
+# he had filed (2026-08-07).
+#
+# Scoped deliberately narrow — only the positions that decide what the app STARTS
+# on: an `initialState`-family function, a DEFAULT_/INITIAL_ binding, or the
+# initial argument of useState/useReducer. A demo literal inside a `.with(...)`
+# match arm is the correct pattern (an explicit flag selecting the sandbox) and is
+# excluded.
+#
+# Validated against the real pre-fix store.tsx: 1 hit at the exact declaration,
+# 0 on the fixed version, 0 across substrate-app, tg-gallery webapp and
+# agent-workbench web.
+id: demo-mode-by-default
+language: tsx
+severity: error
+message: "A fixture/demo/mock source is the DEFAULT here. The default must be the real source; the sandbox belongs behind an explicit flag."
+note: |
+  The default data source must be the real one. Put the sandbox behind an
+  explicit opt-in (`?mode=demo`, a flag, a separate entry) whose absence means
+  real, and make writes that cannot persist FAIL rather than report success.
+  See the fake-data-boundaries skill.
+rule:
+  all:
+    - kind: pair
+    - has:
+        field: key
+        regex: '^(kind|mode|backend|source|dataSource|driver|adapter|transport|client)$'
+    - has:
+        field: value
+        regex: '^.(demo|mock|fixture|fake|stub|sample|seed).$'
+    - not:
+        inside:
+          stopBy: end
+          any:
+            - pattern: $OBJ.with($$$WARGS)
+            - pattern: $OBJ.when($$$WARGS)
+    - inside:
+        stopBy: end
+        any:
+          - kind: function_declaration
+            has:
+              field: name
+              regex: '^(initialState|createInitialState|defaultState|makeInitialState|initState|createDefaultState)$'
+          - kind: variable_declarator
+            has:
+              field: name
+              regex: '^(INITIAL_STATE|DEFAULT_STATE|INITIAL_MODE|DEFAULT_MODE|DEFAULT_BACKEND|initialState|defaultState)$'
+          - pattern: useState($$$ARGS)
+          - pattern: useReducer($$$ARGS)

package/rules/direct-store-import.yml

@@ -0,0 +1,118 @@
+# ── G1, rule 3 of 3: reaching past the store boundary ──────────────────
+#
+# Scoped to decision D1 (report §8): the global `rootStore` is a module-level
+# singleton imported DIRECTLY at screen level — that is now the sanctioned
+# channel, and this rule must not fight it. What stays banned is reaching past
+# it: pulling a store CLASS into a component file, or grabbing one slice-store
+# singleton so the component depends on an implementation instead of a model
+# handed down as a prop.
+#
+# So the rule keys on the imported BINDING, not on the directory alone:
+#
+#   import { rootStore } from "…/stores/rootStore"     legal   (D1)
+#   import { galleryStore } from "…/stores/gallery"    flagged (slice store)
+#   import { GalleryStore } from "…/stores/gallery"    flagged (store class)
+#   import { useStore } from "…/stores/StoreContext"   ignored (access hook)
+#   import type { IGalleryModel } from "…/stores/…"    ignored (C40 contract)
+#
+# NEAR-TERM SCOPE, stated plainly: "component file" is approximated by `.tsx`,
+# and screens are not distinguished from leaf components — so a screen importing
+# a page-store class is flagged alongside a leaf component doing the same. The
+# real boundary needs the manifest's `screens` glob from `.agentvibes/project.toml`
+# (report §8), which arrives with the `@agentvibes/guardrails` package. Until
+# then this rule is the pragmatic half: it catches slice-store and store-class
+# imports anywhere in `.tsx`, and leaves `rootStore` alone everywhere.
+#
+# `*.view.tsx` is stricter — a view may not touch a store by ANY route,
+# `rootStore` included. That needs a different `files:` glob, which ast-grep
+# scopes per rule file, so it lives in `view-imports-store.yml`.
+id: direct-store-import
+# A screen MUST import its page-store class — `usePageStore(() => new
+# GalleryPageStore(rootStore, slug))` is report §8's prescribed shape — so this
+# rule does not apply to files the repo declares as screens via
+# `[verify] screens` in .agentvibes/project.toml. Without that declaration
+# nothing changes and screens keep needing a justified suppression
+# (is-7067a0b8).
+metadata:
+  appliesTo: not-screens
+language: tsx
+severity: error
+files:
+  - '**/*.tsx'
+ignores:
+  # A test constructing a store directly is the PRESCRIBED shape, not a breach:
+  # report §8 puts `new GalleryPageStore(fakeRoot, "slug")` with no render at
+  # the centre of why the store is "отдельный легко тестируемый". Without this,
+  # 15 of observatory's 21 hits were tests doing exactly the right thing.
+  - '**/*.test.tsx'
+  - '**/*.spec.tsx'
+  - '**/__tests__/**'
+  # The composition root wires dependencies once before the first render —
+  # `initRootStore(deps)` in report §8. Observatory's `main.tsx` picks its data
+  # source here, which is also where fake-data.md REQUIRES the choice to be made.
+  - '**/main.tsx'
+  # A gallery, storybook or preview harness legitimately builds stores over
+  # fixtures — fake-data.md carves this out explicitly ("Fixtures are legitimate
+  # where the artifact IS the components"). 29 such files in the park today.
+  - '**/showcase/**'
+  - '**/*.stories.tsx'
+utils:
+  type-only-import:
+    any:
+      - pattern: import type { $$$S } from $SRC
+      - pattern: import type $D from $SRC
+      - pattern: import type * as $NS from $SRC
+      - all:
+          - kind: import_statement
+          - has:
+              stopBy: end
+              kind: named_imports
+          - not:
+              has:
+                stopBy: end
+                all:
+                  - kind: import_specifier
+                  - not:
+                      regex: '^type\s'
+message: |
+  A store class or slice-store singleton imported straight into a component
+  file. The component is now welded to one implementation: it cannot be
+  rendered in a test, a story or a second screen without dragging that store
+  in with it.
+  Take the data as a prop — a `model` typed by the view-model interface the
+  store implements (`IXxxModel`) — and let the screen do the reading. The
+  global `rootStore` imported at screen level is legal (decision D1); this is
+  about everything reached past it.
+  `import type { IXxxModel } from ".../stores/..."` is the compliant shape and
+  does not fire. See the mobx-models and mobx-components skills.
+rule:
+  all:
+    - kind: import_statement
+    - has:
+        field: source
+        has:
+          stopBy: end
+          kind: string_fragment
+          regex: '(^|/)stores?(/|$)'
+    # A binding whose name says "store", excluding the two legal ones: the
+    # global singleton (D1) and the `use…Store` access hooks.
+    - has:
+        stopBy: end
+        all:
+          - kind: identifier
+          - regex: 'Store$'
+          - not:
+              regex: '^rootStore$'
+          - not:
+              regex: '^use[A-Z]'
+          # X7 again, one level down: `import { NOTIFICATION_KINDS, type
+          # NotificationSettingsStore }` is a value import, so the whole-statement
+          # type check above does not exclude it — but the store name in it is
+          # still just a type. Observatory's NotificationsSettingsView.tsx was
+          # flagged for exactly this before the clause existed.
+          - not:
+              inside:
+                kind: import_specifier
+                regex: '^type\s'
+    - not:
+        matches: type-only-import

package/rules/discriminator-ternary.yml

@@ -0,0 +1,70 @@
+# PROMOTED to canon in wave 2 from PPA `r4-ternary-on-discriminator` (rule-triage).
+#
+# The only one of the 11 PPA R-rules that was actually firing (18 hits in the
+# audit), and the triage question was whether it duplicates something canon
+# already has. Measured on tg-gallery + observatory, it does not — the three
+# rules partition the space cleanly:
+#
+#   kind-if-without-match   27 hits   `if` on a discriminator
+#   jsx-ternary            105 hits   ternary whose branches are JSX
+#   this rule               18 hits   ternary on a discriminator yielding VALUES
+#
+#   r4 ∩ jsx-ternary = 0        r4 ∩ kind-if-without-match = 0
+#
+# The `not` clause below makes that disjointness structural rather than lucky:
+# a ternary with a JSX branch belongs to `jsx-ternary` and is skipped here, so
+# the two can never double-report the same line with the same fix.
+#
+# What it actually finds is the terse option-unwrap —
+# `m.kind === "some" ? m.value : []` — which reads fine until the union grows a
+# third member and the `:` branch silently absorbs it.
+id: discriminator-ternary
+language: tsx
+severity: warning
+utils:
+  # A JSX subtree, however many redundant parens wrap it. Same helper
+  # `jsx-ternary` uses, so the two rules agree on what "a JSX branch" means.
+  is-jsx:
+    any:
+      - kind: jsx_element
+      - kind: jsx_self_closing_element
+      - all:
+          - kind: parenthesized_expression
+          - has:
+              matches: is-jsx
+message: |
+  A ternary branching on a discriminator field. Both arms are written, so
+  nothing breaks today — what breaks is the next variant: widen the union and
+  the `:` branch silently absorbs it, with no build error anywhere.
+    m.kind === "some" ? m.value : []
+    → match(m).with({ kind: "some" }, ({ value }) => value).with({ kind: "none" }, () => []).exhaustive()
+  Match the value, not a boolean derived from it — that is what turns adding a
+  variant into a type error.
+  Related but different: `kind-if-without-match` covers the `if` spelling, and
+  `jsx-ternary` covers ternaries that render JSX. This rule deliberately stands
+  down when a branch is JSX so the two never report the same line twice.
+  See defensive-errors Rule 1 & 2.
+rule:
+  all:
+    - kind: ternary_expression
+    - has:
+        field: condition
+        kind: binary_expression
+        all:
+          - has:
+              field: operator
+              regex: '^(===|!==)$'
+          - has:
+              field: left
+              kind: member_expression
+              has:
+                field: property
+                regex: '^(kind|status|state|type|provider|providerId|reason|mode|variant|tag)$'
+    - not:
+        any:
+          - has:
+              field: consequence
+              matches: is-jsx
+          - has:
+              field: alternative
+              matches: is-jsx

package/rules/hardcoded-url-in-component.yml

@@ -0,0 +1,44 @@
+# PROMOTED to canon in wave 2 from PPA `r1a-hardcoded-url-in-component` (rule-triage).
+#
+# Promoted because it enforces a rule that is already house-wide rather than
+# PPA-local: CLAUDE.md's "No localhost" section — every service URL comes from
+# the dev CLI, never a literal, and the legacy proxy zone is retired for new
+# code. A URL baked into a component is also the thing that
+# makes a component un-reusable and un-testable, which is the same boundary
+# `ui-imports-app-store` guards from the other side.
+#
+# Only 2 hits across tg-gallery + observatory — a clean ratchet on new code
+# rather than a cleanup campaign. The PPA original pointed at
+# `apps/ppa/lib/constants/urls.ts`; the message below states the destination
+# generically.
+id: hardcoded-url-in-component
+language: tsx
+severity: warning
+files:
+  - '**/components/**/*.ts'
+  - '**/components/**/*.tsx'
+  - '**/screens/**/*.ts'
+  - '**/screens/**/*.tsx'
+ignores:
+  - '**/__tests__/**'
+  - '**/*.test.ts'
+  - '**/*.test.tsx'
+  - '**/showcase/**'
+  - '**/*.stories.tsx'
+message: |
+  A hardcoded URL in a component file. The component now knows which
+  environment it is in, so it cannot be rendered in a test, a story or a second
+  deployment without editing it — and a URL that moves has to be found by grep
+  rather than changed in one place.
+  Put it in a constants module and read it from there (or from a store computed
+  when it varies at runtime). Service URLs in this codebase come from
+  the dev CLI, never a literal — see the house "No localhost" rule, which
+  also retires the legacy proxy zone for new code.
+  Documentation links and `xmlns` schema URLs are the honest exceptions;
+  suppress those with a reason.
+rule:
+  all:
+    - kind: string
+    - regex: '^["'']https?://'
+    - not:
+        regex: 'w3\.org|schema\.org|json-schema\.org'