@chemx/starter-kit 26.10.10-75 → 26.10.19-530

package/AGENTS.md

@@ -8,7 +8,8 @@
 ## ⚡ Quick Agent Reflex Table (Token-Bounded Commands)
 | Standard Reflex | `chemx` Equivalent | Token & Architecture Advantage |
 | :--- | :--- | :--- |
-| `grep -rn "pattern" .` | `chemx q -g "pattern"` or `chemx q -g "pattern" -l` | Fixed-string search of every text file `.gitignore` allows (submodules, docs, styles, JSON, PHP); full `path:line:text` lines or line-only (-l); `--regex` opts into regex; `-- <pattern>` for a pattern starting with `-`. Uses `rg` when installed, a JS walker otherwise; the header states files searched and the engine. |
+| `grep -rn "pattern" .` | `chemx q -g "pattern" --bare` or `chemx q -g "pattern" -C 3 --bare` | Fixed-string search matching rg token-for-token (57 chars / 14 tokens per hit); add `-C <N>` to inspect surrounding code in a single turn without a second read call. |
+| `sed -n 'N,Mp' <file>` | `chemx read <file>:N-M --bare` | Verbatim slice matching sed byte-for-byte; 0 header, box or line number tokens. |
 | `git diff` | `chemx d` | Zero-context (`-U0`), auto-collapses to `--stat` if > 80 lines, micro-syncs index. |
 | `git log` | `chemx log -n 5` | One-line commit history (5 commits measured about 140 tokens on 2026-10-09, roughly 28 per commit). |
 | `find . -name "*.vue"` | `chemx f "*.vue"` | Strictly filters by `.gitignore` and ignored dirs. |
@@ -251,7 +252,7 @@ Use same-name shorthand across all languages; eliminate redundant `key: key` dup
 ### A. Named Conditions & Two-Stage Composition
 > The `if` never asks a question. The question is asked and named before the branch, and the `if` reads the answer.
 
-- Every conditional test is a named boolean: an identifier, its negation, or a call or member access whose name is an assertion (3.F). A raw comparison (`x === y`, `n >= 5`), a truthiness check on a non-boolean (`if (user)`, `if (obj.prop)`), inline compound logic (`a && b`), or a verb-named call (`RE.test(s)`, `fs.existsSync(p)`) inside the test is a violation.
+- Every conditional test is a named boolean: an identifier, its negation, a bare property read (`sale.ok`, `items.length`), or a call whose name states an assertion or a predicate (3.F: `hasItems(cart)`, `map.has(key)`, `fs.existsSync(p)`). A raw comparison (`x === y`, `n >= 5`), inline compound logic (`a && b`), or a call whose name states no predicate (`RE.test(s)`, `user.getName()`) inside the test is a violation.
 - Naming is the point, not the ceremony: it forces the question inline code hides (why `<= 0` and not `=== -1`?), and an edit to a named condition changes its definition without touching the branch.
 - **Stage 1** names each atomic concept. **Stage 2** names the decision, only when 2 or more concepts compose; a single comparison gets one name and no wrapper. Guard with early returns.
   ```typescript
@@ -276,6 +277,7 @@ Use same-name shorthand across all languages; eliminate redundant `key: key` dup
   1. **Structural primitives** (`lib/is/`: `value`, `collection`, `text`, `fs`, `type`): subject-agnostic and finite (`isAbsent`, `hasItems`, `isNonEmptyString`, `pathExists`). They import nothing, and the set does not grow. Every primitive is a TypeScript type predicate (`(x: unknown): x is string`), never a plain `boolean`, or callers lose narrowing.
   2. **Domain vocabulary** (`<subsystem>/<domain>-predicates.<ext>`, colocated with the subsystem it describes): built from Layer 1. A condition earns a domain predicate at its 2nd use; a threshold duplicated across files (`score >= 90`) silently disagrees the day one copy changes, so name it once (`isGradeA`). Promote threshold literals in predicate bodies to named constants (`score >= GRADE_A_THRESHOLD`).
   3. **Decisions**: single-use composites declared at the call site per 3.A. Never extract them: extracting every condition is *indirection masquerading as modularity* (1.A).
+- A bare property read (`sale.ok`, `items.length`) or a predicate-method call (`map.has(key)`, `fs.existsSync(p)`) is already a named condition; 3.A does not ask for a const alias of it.
 - Before naming a new predicate, search for an existing one: `chemx q -g "<likely words>"` for the literal names, plus `chemx({ action: 'q', params: { query: '<concept>', hybrid: true } })` for spelling variants. Neither finds pure synonyms (`hasNoItems` vs `isEmpty`), so also scan the predicates module of the domain. A synonym beside an existing predicate is lexicon rot.
 - Repeated filter conditions are Layer 2 candidates: extract the predicate, compose a named higher-order filter, and keep derivations declarative:
   ```typescript
@@ -416,6 +418,7 @@ Raw inline `style="..."` attributes are strictly prohibited. Visual styling flow
 - Long strings of utility shorthand recreate the exact cognitive noise and AI context degradation of inline styles.
 - Decouple visual styling into scoped classes via `@apply` or centralized SCSS mixins (`@include glass;`).
 - Templates must read like a clean, semantic outline rather than an unreadable wall of styling shorthand.
+- Class strings must stay where Tailwind looks (`TAILWIND_UNSCANNED_CLASS_STRING`): in a Tailwind v3 project, a string of 3 or more utility classes in a `.js`, `.ts`, `.mjs` or `.cjs` file that no `content` glob of `tailwind.config` matches is purged from production CSS. Move it into a template or a file the globs scan, or add the file pattern to `content`. The rule reads the config as text and stays silent for Tailwind v4 or a config whose `content` list is not literal.
 
 ### C. Wrapper Atoms & Explicit Slot Forwarding
 - Never use dynamic slot iteration with `v-for="(_, slot) in $slots"` in wrapper components.

package/README.md

@@ -180,7 +180,7 @@ chemx build --json
 
 #### One gate rule
 
-The pre-commit hook (`chemx audit --staged-delta`), the ratchet step of `chemx verify` (`chemx-ratchet.json`), `chemx team task done` and the `introducedViolations` list in `patch`/`write` results share one rule: a change fails when any rule's violation count rises in a file, at any severity. A commit the hook accepts therefore cannot turn the ratchet step red. `CHEMX_SKIP_PRECOMMIT=1` skips only the hook; `chemx verify` still applies the rule. On failure the hook prints each new hazard as `RULE@file:line`. Guarantees, non-guarantees and the specs that prove parity are in [docs/audit-gates.md](docs/audit-gates.md).
+The pre-commit hook (`chemx audit --staged-delta`), the base delta gate (`chemx audit --delta-base=<ref>`, `chemx verify --changed --base=<ref>`), the ratchet step of `chemx verify` (`chemx-ratchet.json`), `chemx team task done` and the `introducedViolations` list in `patch`/`write` results share one rule: a change fails when any rule's violation count rises in a file, at any severity. A commit the hook accepts therefore cannot turn the ratchet step red. The base delta gate scores only the files a branch changed against their merge-base, so a branch that fixes one rule stays green even while the trunk is over the ratchet on other rules. `CHEMX_SKIP_PRECOMMIT=1` skips only the hook; `chemx verify` still applies the rule. On failure the hook prints each new hazard as `RULE@file:line`. Guarantees, non-guarantees and the specs that prove parity are in [docs/audit-gates.md](docs/audit-gates.md).
 
 #### Interactive audit navigator
 
@@ -335,6 +335,7 @@ Chemical X audits more than one language. The table below lists the extensions i
 2. **Tier 2: Deep Language-Specific Analyzers**
    * **Babel Engine:** Deep AST inspection for JS/TS/Vue/Svelte (runs on JS, TS, Vue and Svelte files only).
    * **Control Flow & Guard Disciplines (`CONTROL_FLOW_CASCADE_GUARDS`, `CONTROL_FLOW_SILENT_GUARD`):** Flags silent bare returns in side-effecting code, and detects cascading early-return clusters (>= 3 guards), recommending extraction into `ruleTree` with 1-line callback aborts (Directive 3.H).
+   * **Tailwind content coverage (`TAILWIND_UNSCANNED_CLASS_STRING`):** In a Tailwind v3 project, flags a string literal of 3 or more utility classes (2 or more of them Tailwind-shaped) in a `.js`, `.ts`, `.mjs` or `.cjs` file that no `content` glob of `tailwind.config` covers, since Tailwind purges classes it never scans. The config is read as text and never imported; Tailwind v4, a missing config or a non-literal `content` list keep the rule silent. HIGH, Directive 5.B. `options.tailwindContent` overrides the globs for tests.
    * **C# / Clean Architecture Analyzer:** Flags empty `catch (Exception) {}` blocks, simulated delays (`Task.Delay`), and monolithic controllers.
    * **Swallowed catches (`ERROR_SWALLOWED_EXCEPTION`, `AI_SLOP_SHALLOW_CATCH`):** Each swallowing catch site reports once, as `ERROR_SWALLOWED_EXCEPTION` when the error is discarded or `AI_SLOP_SHALLOW_CATCH` when it is only logged to the console. Both are MEDIUM by default. A JS/TS catch escalates to HIGH when a `let` or `var` assigned in the try is read after it with no default or check first (silent `undefined` propagation); C# findings stay MEDIUM. Mark an intentional swallow with a `chemx-allow: best-effort <reason>` comment on the line above the catch, on the catch line, inside its body, or after the try block's closing brace when `catch` starts the next line. Only comments count (never string literals), and the reason is mandatory: an annotation without one is still flagged and its hazard says so.
 

package/blueprints/_vitest.config.svelte.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config';
+import { svelte } from '@sveltejs/vite-plugin-svelte';
+
+export default defineConfig({
+  plugins: [svelte()],
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['**/*.spec.ts', '**/*.test.ts']
+  }
+});

package/blueprints/_vitest.config.vue.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config';
+import vue from '@vitejs/plugin-vue';
+
+export default defineConfig({
+  plugins: [vue()],
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    include: ['**/*.spec.ts', '**/*.test.ts']
+  }
+});

package/blueprints/molecule-capsule/index.svelte.ts

@@ -0,0 +1,2 @@
+export { default as MSampleCard } from './m-sample-card.svelte';
+export type { MSampleCardProps, SampleCardBadgeDescriptor } from './types';

package/blueprints/molecule-capsule/index.vue.ts

@@ -0,0 +1,2 @@
+export { default as MSampleCard } from './m-sample-card.vue';
+export type { MSampleCardProps, SampleCardBadgeDescriptor } from './types';

package/blueprints/molecule-capsule/m-chemx-badge/index.svelte.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export { default as MChemxBadge } from './m-chemx-badge.svelte';
+export { default } from './m-chemx-badge.svelte';

package/blueprints/molecule-capsule/m-chemx-badge/index.vue.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export { default as MChemxBadge } from './m-chemx-badge.vue';
+export { default } from './m-chemx-badge.vue';

package/blueprints/molecule-capsule/m-sample-card.spec.svelte.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { render } from 'svelte/server';
+import MSampleCard from './m-sample-card.svelte';
+
+describe('m-sample-card: MSampleCard Component', () => {
+  it('renders title, formatted value, and standard badge correctly', () => {
+    const { body } = render(MSampleCard, {
+      props: { title: 'Core Subscription', subtitle: 'Monthly compute tier', value: 750 }
+    });
+
+    expect(body).toContain('class="m-sample-card"');
+    expect(body).toContain('Core Subscription');
+    expect(body).toContain('Monthly compute tier');
+    expect(body).toContain('$750');
+    expect(body).toContain('m-sample-card__badge--standard');
+    expect(body).not.toContain('m-sample-card__action');
+  });
+
+  it('renders high-value modifier when numeric value exceeds 1000', () => {
+    const { body } = render(MSampleCard, { props: { title: 'Enterprise Cluster', value: 2500 } });
+
+    expect(body).toContain('Enterprise Cluster');
+    expect(body).toContain('$2,500');
+    expect(body).toContain('m-sample-card__badge--high-value');
+  });
+
+  it('renders the action button only when onAction is given', () => {
+    const { body } = render(MSampleCard, { props: { title: 'Actionable Unit', value: 1200, onAction: () => undefined } });
+
+    expect(body).toContain('m-sample-card__action');
+    expect(body).toContain('Action');
+  });
+});

package/blueprints/shims-svelte.d.ts

@@ -0,0 +1,3 @@
+// Svelte ships the `*.svelte` module declaration; this reference loads it for every tsc run,
+// including one where no .ts file imports from 'svelte' itself.
+/// <reference types="svelte" />

package/cli/audit/base-delta.js

@@ -0,0 +1,89 @@
+/**
+ * Delta gate against a base ref (#6091): each changed source file's working-tree content
+ * is audited against the same file at the base, and the gate fails only when a rule's
+ * violation count rises in a file, at any severity (gate-delta.js, the rule the pre-commit
+ * hook and the ratchet apply). Hazards the base already has never count, so a change that
+ * fixes one rule is not held red by other rules the repo-wide ratchet fails on.
+ *
+ * The base is merge-base(<ref>, HEAD) when there is one, the same starting point
+ * `verify --changed --base=<ref>` uses to list changed files; otherwise <ref> itself.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadProjectConfig } from '../config/index.js';
+import { isSourceFilePath } from '../audit-preflight-git.js';
+import { evaluateChanges, formatSites } from './gate-delta.js';
+import { gitText, parseNameStatus, changeFromContents } from './staged-delta.js';
+
+const DIFF_ARGS = ['diff', '--name-status', '-z', '-M', '--diff-filter=ACMR', '--relative'];
+
+/** { label, rev } for an existing commit-ish, null when `baseRef` names none. A leading `-` is never a ref. */
+const resolveBase = (cwd, baseRef) => {
+  const isOptionLike = typeof baseRef !== 'string' || baseRef === '' || baseRef.startsWith('-');
+  if (isOptionLike) return null;
+  const commit = gitText(cwd, ['rev-parse', '--verify', '--quiet', `${baseRef}^{commit}`]);
+  const isMissing = commit === null;
+  if (isMissing) return null;
+  const mergeBase = gitText(cwd, ['merge-base', baseRef, 'HEAD']);
+  return { label: baseRef, rev: (mergeBase ?? commit).trim() };
+};
+
+/** Untracked, non-ignored source files: new content in the working tree that git diff does not list. */
+const listUntrackedSources = (cwd) =>
+  (gitText(cwd, ['ls-files', '--others', '--exclude-standard', '-z']) ?? '')
+    .split('\0')
+    .filter((file) => file !== '' && isSourceFilePath(file))
+    .map((file) => ({ file, basePath: null, isRename: false }));
+
+/** Changed source files vs `rev` as { file, basePath, isRename }, paths relative to `cwd`; a file is listed once. */
+const listBaseSources = (cwd, rev) => {
+  const tracked = parseNameStatus(gitText(cwd, [...DIFF_ARGS, rev, '--']) ?? '');
+  const seen = new Set(tracked.map((entry) => entry.file));
+  return [...tracked, ...listUntrackedSources(cwd).filter((entry) => !seen.has(entry.file))];
+};
+
+const readWorkingTree = (cwd, file) => {
+  const absPath = path.join(cwd, file);
+  const isFile = fs.statSync(absPath, { throwIfNoEntry: false })?.isFile() === true;
+  return isFile ? fs.readFileSync(absPath, 'utf-8') : null;
+};
+
+const toChange = (cwd, rev, entry, config) => {
+  const afterText = readWorkingTree(cwd, entry.file);
+  const isReadable = afterText !== null;
+  if (!isReadable) return null;
+  const baseText = entry.basePath ? gitText(cwd, ['show', `${rev}:./${entry.basePath}`]) ?? '' : '';
+  return changeFromContents(cwd, entry, { baseText, afterText, config });
+};
+
+/**
+ * Per-rule delta of the working tree against `baseRef`. `options.config` replaces the project
+ * config loaded from `cwd` and `rawArgs` (verify passes the one it already holds).
+ *
+ * @returns {{ isPassing: boolean, base: string, rev?: string, checked: number, files: object[], baseMissing?: boolean, error?: string }}
+ * An unknown ref never throws and never passes: it returns baseMissing with isPassing false, so
+ * a typo cannot turn the gate green.
+ */
+export const evaluateBaseDelta = (cwd = process.cwd(), baseRef, rawArgs = [], options = {}) => {
+  const resolved = resolveBase(cwd, baseRef);
+  const isMissing = resolved === null;
+  if (isMissing) return { isPassing: false, base: baseRef ?? null, checked: 0, files: [], baseMissing: true, error: `unknown base revision "${baseRef ?? ''}"` };
+  const config = options.config ?? loadProjectConfig(cwd, rawArgs);
+  const entries = listBaseSources(cwd, resolved.rev);
+  const changes = entries.map((entry) => toChange(cwd, resolved.rev, entry, config)).filter(Boolean);
+  return { ...evaluateChanges(changes), base: resolved.label, rev: resolved.rev, checked: changes.length };
+};
+
+/** The delta as the compact block `verify --json` carries: rising rules and one `RULE@file:line [SEVERITY]` per new hazard. */
+export const summarizeBaseDelta = (delta) => ({
+  base: delta.base,
+  passing: delta.isPassing,
+  checked: delta.checked,
+  ...(delta.error ? { error: delta.error } : {}),
+  files: delta.files.map((entry) => ({
+    file: entry.file,
+    ...(entry.renamedFrom ? { renamedFrom: entry.renamedFrom } : {}),
+    increases: entry.increases.map(({ rule, severity, before, after }) => ({ rule, severity, before, after })),
+    sites: formatSites(entry)
+  }))
+});

package/cli/audit/gate-verdict.js

@@ -27,6 +27,17 @@ export const evaluateGateVerdict = ({ violations, ratchetEval }) => {
   return { isPassing: !hasSevereViolation, basis: 'severity', regressions: [], adopted: [], note: ratchetEval.message ?? null };
 };
 
+/**
+ * The verdict of `verify --changed --base=<ref>` (#6091): the per-rule delta against the base
+ * decides, at any severity, and the repo-wide ratchet and the severity gate are not consulted.
+ * `delta` is an evaluateBaseDelta result.
+ */
+export const evaluateDeltaVerdict = (delta) => {
+  const risen = delta.files.length;
+  const note = delta.baseMissing ? delta.error : `${risen} changed file(s) raise a rule's violation count vs ${delta.base}`;
+  return { isPassing: delta.isPassing, basis: 'delta', regressions: [], adopted: [], note: delta.isPassing ? null : note };
+};
+
 const PARTIAL_SCAN_EVAL = {
   status: 'partial',
   regressions: [],

package/cli/audit/hook-shape-validator.js

@@ -1,14 +1,40 @@
 import * as t from '@babel/types';
 import { RULE_REGISTRY } from './rules-registry.js';
 
-const VERB_PREFIX_REGEX = /^(add|remove|toggle|set|get|fetch|load|save|delete|clear|reset|refresh|update|create|edit|send|sync|init|setup|dispose|trigger|post|put|patch|apply|dismiss|select|deselect|filter|sort|search|open|close|show|hide|start|stop|cancel|execute|run|retry|submit|validate|mutate|next|prev|step|increment|decrement|insert|upsert|drop|enable|disable|register|unregister|login|logout|checkout|publish|archive|discard|confirm|undo|redo|claim|complete|acquire|release|download|upload|export|import|handle|play|pause|resume|seek|unlock|restore|advance|focus|notify|broadcast|copy|format)([A-Z0-9_].*)?$/;
+export const HOOK_ACTION_VERBS = [
+  'abort', 'accept', 'acquire', 'activate', 'add', 'advance', 'align', 'animate', 'append', 'apply',
+  'approve', 'archive', 'assign', 'attach', 'begin', 'bind', 'boot', 'broadcast', 'build', 'calculate',
+  'cancel', 'center', 'check', 'checkout', 'choose', 'claim', 'clear', 'clone', 'close', 'collapse',
+  'complete', 'compute', 'conceal', 'confirm', 'connect', 'convert', 'copy', 'create', 'deactivate', 'debounce',
+  'decline', 'decrement', 'defer', 'delete', 'dequeue', 'deselect', 'detach', 'disable', 'discard', 'disconnect',
+  'dismiss', 'dispatch', 'dispose', 'download', 'drag', 'draw', 'drop', 'duplicate', 'edit', 'emit',
+  'enable', 'end', 'enqueue', 'ensure', 'evict', 'execute', 'expand', 'export', 'fetch', 'fill',
+  'filter', 'finalize', 'finish', 'fit', 'flag', 'flip', 'flush', 'focus', 'follow', 'fork',
+  'format', 'generate', 'get', 'go', 'grant', 'halt', 'handle', 'hide', 'highlight', 'hydrate',
+  'import', 'increment', 'init', 'insert', 'invalidate', 'invite', 'join', 'jump', 'kill', 'launch',
+  'leave', 'link', 'load', 'lock', 'log', 'login', 'logout', 'mark', 'maximize', 'measure',
+  'merge', 'minimize', 'mount', 'move', 'mutate', 'mute', 'navigate', 'next', 'notify', 'open',
+  'parse', 'patch', 'pause', 'persist', 'pick', 'pin', 'play', 'poll', 'pop', 'populate',
+  'post', 'prefetch', 'prepare', 'prepend', 'prev', 'preview', 'print', 'publish', 'purge', 'push',
+  'put', 'queue', 'read', 'record', 'redirect', 'redo', 'refetch', 'refresh', 'register', 'reject',
+  'release', 'reload', 'remove', 'rename', 'render', 'reorder', 'replace', 'reply', 'report', 'reposition',
+  'request', 'reset', 'resize', 'resolve', 'restart', 'restore', 'resume', 'retry', 'revalidate', 'reveal',
+  'revoke', 'rewind', 'rotate', 'run', 'save', 'scan', 'schedule', 'scroll', 'search', 'seed',
+  'seek', 'select', 'send', 'set', 'setup', 'share', 'show', 'shuffle', 'shutdown', 'skip',
+  'snap', 'sort', 'spawn', 'split', 'start', 'step', 'stop', 'stroke', 'submit', 'subscribe',
+  'swap', 'sync', 'throttle', 'toggle', 'track', 'transform', 'translate', 'trigger', 'unbind', 'undo',
+  'unfollow', 'unlink', 'unlock', 'unmount', 'unmute', 'unpin', 'unregister', 'unsubscribe', 'unwatch', 'update',
+  'upload', 'upsert', 'validate', 'verify', 'wait', 'watch', 'write', 'zoom',
+];
+
+const VERB_PREFIX_REGEX = new RegExp(`^(${HOOK_ACTION_VERBS.join('|')})([A-Z0-9_].*)?$`);
 
 const STATUS_HEURISTIC_REGEX = /^(is[A-Z]|has[A-Z]|can[A-Z]|should[A-Z])|.*(Error|Status)$/;
 const STATUS_EXACT_NAMES = new Set(['status', 'error', 'loading', 'pending', 'ready']);
 const ACTION_WRAPPER_KEYS = new Set(['actions', 'handlers', 'methods', 'operations']);
 
 const RAW_DOM_REF_REGEX = /^(dom|element|container|input|button|target|root|node)?Ref$|.*(Element|Node|Dom)Ref$/i;
-const INTERMEDIATE_VAL_REGEX = /^(temp|draft|raw|partial|interim|scratch|memoized)([A-Z_].*)?$/i;
+const INTERMEDIATE_VAL_REGEX = /^(temp|draft|raw|partial|interim|scratch|memoized)([A-Z0-9_].*)?$/;
 const UNGROUPED_CALLBACK_REGEX = /^(on[A-Z]|callback$|.*Callback$)/;
 
 const MUTUALLY_EXCLUSIVE_STATUSES = new Set([

package/cli/audit/lexicon-predicates.js

@@ -1,7 +1,9 @@
 /**
  * The named-condition lexicon from AGENTS.md 3.A and 3.F, as AST predicates.
- * A conditional test passes when it is an identifier, its negation, or a call or
- * member access whose name is an assertion (prefix followed by its subject).
+ * A conditional test passes when it is an identifier, its negation, a member
+ * chain with no operators (a property read is already a name), or a call whose
+ * callee name is an assertion, a standard predicate method, or carries a
+ * predicate word (`fs.existsSync(p)`, `map.has(key)`).
  */
 import * as t from '@babel/types';
 
@@ -13,6 +15,21 @@ export const ASSERTION_PREFIXES = [
 
 const ASSERTION_NAME = new RegExp(`^(?:${ASSERTION_PREFIXES.join('|')})[A-Z0-9_$]`);
 const TRANSPARENT_MEMBERS = new Set(['value', 'current']);
+
+/** Standard-library methods that return a boolean by name alone (`test` is deliberately absent). */
+export const PREDICATE_METHODS = new Set([
+  'has', 'includes', 'some', 'every', 'startsWith', 'endsWith',
+  'isArray', 'isNaN', 'isFinite', 'isInteger', 'isSafeInteger'
+]);
+
+/** Words that make a verb-named call read as a question (`existsSync`, `isPathValid`). */
+export const PREDICATE_WORDS = new Set([
+  'exists', 'equals', 'matches', 'valid', 'ok', 'enabled', 'disabled', 'active',
+  'visible', 'hidden', 'ready', 'empty', 'defined', 'present', 'loaded', 'done',
+  'complete', 'dirty', 'stale', 'expired', 'pending', 'selected', 'checked',
+  'open', 'closed', 'locked', 'found', 'known', 'allowed', 'blocked', 'accepted',
+  'passed', 'failed'
+]);
 const ERRORISH_WORDS = new Set([
   'err', 'error', 'errors', 'fail', 'fails', 'failed', 'failure', 'exception',
   'invalid', 'rejected', 'fault', 'denied'
@@ -50,11 +67,27 @@ const isAssertionMember = (member) => {
   return isAssertionName(propName);
 };
 
-const isAssertionCall = (call) => {
+const isMemberNode = (n) => t.isMemberExpression(n) || t.isOptionalMemberExpression(n);
+const isCallNode = (n) => t.isCallExpression(n) || t.isOptionalCallExpression(n);
+
+const isPredicateName = (name) => isAssertionName(name) || PREDICATE_METHODS.has(name) ||
+  splitNameWords(name).some((word) => PREDICATE_WORDS.has(word));
+
+const isPredicateCall = (call) => {
   const callee = unwrapExpression(call.callee);
-  if (t.isIdentifier(callee)) return isAssertionName(callee.name);
-  const isMemberCallee = t.isMemberExpression(callee) || t.isOptionalMemberExpression(callee);
-  return isMemberCallee && isAssertionName(memberPropertyName(callee));
+  if (t.isIdentifier(callee)) return isPredicateName(callee.name);
+  return isMemberNode(callee) && isPredicateName(memberPropertyName(callee));
+};
+
+/** A chain of reads and calls rooted at a name, with no operator anywhere along it. */
+const isPlainChain = (node) => {
+  const expr = unwrapExpression(node);
+  if (!expr) return false;
+  const isRoot = t.isIdentifier(expr) || t.isThisExpression(expr) || t.isSuper(expr) || t.isMetaProperty(expr);
+  if (isRoot) return true;
+  if (isMemberNode(expr)) return isPlainChain(expr.object);
+  if (isCallNode(expr)) return isPlainChain(expr.callee);
+  return false;
 };
 
 /** True when a test reads a named boolean per AGENTS.md 3.A. */
@@ -64,10 +97,8 @@ export const isNamedCondition = (node) => {
   if (t.isIdentifier(expr)) return true;
   const isNegation = t.isUnaryExpression(expr, { operator: '!' });
   if (isNegation) return isNamedCondition(expr.argument);
-  const isMember = t.isMemberExpression(expr) || t.isOptionalMemberExpression(expr);
-  if (isMember) return isAssertionMember(expr);
-  const isCall = t.isCallExpression(expr) || t.isOptionalCallExpression(expr);
-  if (isCall) return isAssertionCall(expr);
+  if (isMemberNode(expr)) return isPlainChain(expr) || isAssertionMember(expr);
+  if (isCallNode(expr)) return isPredicateCall(expr);
   return false;
 };
 

package/cli/audit/rule-revisions.js

@@ -12,7 +12,7 @@
  * a rule without a bump fails the suite. At runtime a baseline also records every
  * registered rule's revision, so a rule it never saw is adopted, not a regression.
  */
-export const RULESET_VERSION = 5;
+export const RULESET_VERSION = 6;
 
 export const RULE_REVISIONS = Object.freeze({
   // Ruleset 2: the 40-year canon rules (a3a1ac9, 9461ed2).
@@ -36,7 +36,9 @@ export const RULE_REVISIONS = Object.freeze({
   ERROR_SWALLOWED_EXCEPTION: 4,
   AI_SLOP_SHALLOW_CATCH: 4,
   // Ruleset 5: cascading guard detection and domain validator extraction (Directive 3.H).
-  CONTROL_FLOW_CASCADE_GUARDS: 5
+  CONTROL_FLOW_CASCADE_GUARDS: 5,
+  // Ruleset 6: Tailwind content-glob coverage (review 2026-10-15).
+  TAILWIND_UNSCANNED_CLASS_STRING: 6
 });
 
 export const resolveRuleRevision = (rule) => RULE_REVISIONS[rule] ?? 1;

package/cli/audit/rules-registry.js

@@ -232,6 +232,12 @@ export const RULE_REGISTRY = {
     needs: 'light',
     directive: 'Avoid text-* utility classes on FontAwesome icons; use color prop or CSS'
   },
+  TAILWIND_UNSCANNED_CLASS_STRING: {
+    pillar: PILLARS.PILLAR_5,
+    severity: 'HIGH',
+    needs: 'standard',
+    directive: 'Move Tailwind class strings into a template or a file the Tailwind content globs scan, or add the file pattern to content'
+  },
   TYPOGRAPHY_EM_DASH: {
     pillar: PILLARS.PILLAR_7,
     severity: 'LOW',

package/cli/audit/rules.js

@@ -15,6 +15,7 @@ import { checkTemplateRenderDepth } from './render-depth.js';
 import { parseSfc, isSfcFile } from '../sfc/sfc-parse.js';
 import { COVERAGE_KINDS, recordFileCoverage } from './coverage.js';
 import { parseScriptAsts, runAstPasses } from './ast-passes.js';
+import { runTailwindUnscannedPass } from './tailwind-unscanned.js';
 
 export { PILLARS, RULE_REGISTRY, createHookShapeRegistry };
 
@@ -91,6 +92,7 @@ const collectRawViolations = (content, filePath, relativePath, options, ruleConf
       coverageKind = COVERAGE_KINDS.PARSE_ERROR;
     } else {
       runAstPasses(parsed.asts, { relativePath, violations, ruleConfig, options, code });
+      runTailwindUnscannedPass(parsed.asts, { filePath, relativePath, violations, options });
     }
   }
 
@@ -101,8 +103,10 @@ const collectRawViolations = (content, filePath, relativePath, options, ruleConf
 };
 
 /**
- * Audits one file. options: { config, fast, patternRegistry, hookRegistry, coverage, fingerprint }
- * (fingerprint: a Forge collector from cli/forge/fingerprint-visitors.js, or null to skip Forge).
+ * Audits one file. options: { config, fast, patternRegistry, hookRegistry, coverage, fingerprint, cwd, tailwindContent }
+ * (fingerprint: a Forge collector from cli/forge/fingerprint-visitors.js, or null to skip Forge;
+ * cwd: the project root for the Tailwind content probe; tailwindContent: content globs overriding
+ * tailwind.config, or null to silence TAILWIND_UNSCANNED_CLASS_STRING).
  * Violations pass through chemx-allow annotations, dedup and per-rule config.
  */
 export const auditCode = (content, filePath, relativePath, options = {}) => {

package/cli/audit/staged-delta.js

@@ -12,18 +12,19 @@ import { loadProjectConfig } from '../config/index.js';
 import { isSourceFilePath } from '../audit-preflight-git.js';
 import { evaluateChanges } from './gate-delta.js';
 
-const gitText = (cwd, args) => {
+export const gitText = (cwd, args) => {
   const result = spawnSync('git', args, { cwd, encoding: 'utf-8', maxBuffer: 64 * 1024 * 1024 });
   return result.status === 0 ? result.stdout : null;
 };
 
 /**
- * Staged additions, copies, modifications and renames as { file, basePath }. A rename
- * (git mv plus edits) is compared with HEAD at its old path, so it can neither slip
- * past the gate nor count its inherited hazards as new. `-z` keeps odd paths intact.
+ * Additions, copies, modifications and renames from `git diff --name-status -z -M --diff-filter=ACMR`
+ * output as { file, basePath, isRename }. A rename (git mv plus edits) is compared with the base at
+ * its old path, so it can neither slip past a gate nor count its inherited hazards as new; a copy is
+ * new content and has no base. `-z` keeps odd paths intact. Shared by the staged and the base-ref gate.
  */
-const listStagedSources = (cwd) => {
-  const fields = (gitText(cwd, ['diff', '--cached', '--name-status', '-z', '-M', '--diff-filter=ACMR']) ?? '').split('\0');
+export const parseNameStatus = (output) => {
+  const fields = output.split('\0');
   const entries = [];
   let i = 0;
   while (i < fields.length && fields[i]) {
@@ -39,15 +40,23 @@ const listStagedSources = (cwd) => {
   return entries.filter((entry) => isSourceFilePath(entry.file));
 };
 
-const toChange = (cwd, { file, basePath, isRename }, config) => {
+const listStagedSources = (cwd) =>
+  parseNameStatus(gitText(cwd, ['diff', '--cached', '--name-status', '-z', '-M', '--diff-filter=ACMR']) ?? '');
+
+/** One evaluateChanges entry: `baseText` audited as the before state, `afterText` as the after state of `file`. */
+export const changeFromContents = (cwd, { file, basePath, isRename }, { baseText, afterText, config }) => {
   const absPath = path.join(cwd, file);
-  const staged = gitText(cwd, ['show', `:${file}`]) ?? '';
-  const base = basePath ? gitText(cwd, ['show', `HEAD:${basePath}`]) ?? '' : '';
-  const before = auditCode(base, absPath, file, { config });
-  const after = auditCode(staged, absPath, file, { config });
+  const before = auditCode(baseText, absPath, file, { config });
+  const after = auditCode(afterText, absPath, file, { config });
   return isRename ? { file, renamedFrom: basePath, before, after } : { file, before, after };
 };
 
+const toChange = (cwd, entry, config) => {
+  const afterText = gitText(cwd, ['show', `:${entry.file}`]) ?? '';
+  const baseText = entry.basePath ? gitText(cwd, ['show', `HEAD:${entry.basePath}`]) ?? '' : '';
+  return changeFromContents(cwd, entry, { baseText, afterText, config });
+};
+
 /**
  * Hazard increases in `currentViolations` over the committed HEAD version of `relPath` (empty base
  * when the file is new). Returns [] when there is no HEAD commit to compare with, so callers