@chemx/starter-kit 26.10.8-344 → 26.10.10-75

package/blueprints/atoms/a-button.svelte

@@ -1,4 +1,14 @@
 <script lang="ts">
+  export interface AtomButtonProps {
+    type?: 'button' | 'submit' | 'reset';
+    disabled?: boolean;
+    ariaLabel?: string;
+    variant?: 'primary' | 'ghost' | 'glass';
+    class?: string;
+    onclick?: (e: MouseEvent) => void;
+    children?: import('svelte').Snippet;
+  }
+
   let {
     type = 'button',
     disabled = false,
@@ -7,15 +17,7 @@
     class: className = '',
     onclick,
     children
-  } = $props<{
-    type?: 'button' | 'submit' | 'reset';
-    disabled?: boolean;
-    ariaLabel?: string;
-    variant?: 'primary' | 'ghost' | 'glass';
-    class?: string;
-    onclick?: (e: MouseEvent) => void;
-    children?: import('svelte').Snippet;
-  }>();
+  } = $props<AtomButtonProps>();
 </script>
 
 <button

package/blueprints/atoms/a-button.vue

@@ -22,7 +22,8 @@ const emit = defineEmits<{
 }>();
 
 const handleClick = (event: MouseEvent) => {
-  if (props.disabled) return;
+  const isDisabled = Boolean(props.disabled);
+  if (isDisabled) return;
   emit('click', event);
 };
 </script>

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

@@ -3,10 +3,14 @@
 
   export const resolveGradeClass = (grade: string): string => {
     const g = grade.toUpperCase();
-    if (g.startsWith('A')) return 'm-chemx-badge__grade--a';
-    if (g.startsWith('B')) return 'm-chemx-badge__grade--b';
-    if (g.startsWith('C')) return 'm-chemx-badge__grade--c';
-    if (g.startsWith('D')) return 'm-chemx-badge__grade--d';
+    const isGradeA = Boolean(g.startsWith('A'));
+    if (isGradeA) return 'm-chemx-badge__grade--a';
+    const isGradeB = Boolean(g.startsWith('B'));
+    if (isGradeB) return 'm-chemx-badge__grade--b';
+    const isGradeC = Boolean(g.startsWith('C'));
+    if (isGradeC) return 'm-chemx-badge__grade--c';
+    const isGradeD = Boolean(g.startsWith('D'));
+    if (isGradeD) return 'm-chemx-badge__grade--d';
     return 'm-chemx-badge__grade--f';
   };
 

package/blueprints/molecule-capsule/m-chemx-badge/m-chemx-badge.tsx

@@ -3,10 +3,14 @@ import type { MChemxBadgeProps } from './types';
 
 export const resolveGradeClass = (grade: string): string => {
   const g = grade.toUpperCase();
-  if (g.startsWith('A')) return 'm-chemx-badge__grade--a';
-  if (g.startsWith('B')) return 'm-chemx-badge__grade--b';
-  if (g.startsWith('C')) return 'm-chemx-badge__grade--c';
-  if (g.startsWith('D')) return 'm-chemx-badge__grade--d';
+  const isGradeA = g.startsWith('A');
+  if (isGradeA) return 'm-chemx-badge__grade--a';
+  const isGradeB = g.startsWith('B');
+  if (isGradeB) return 'm-chemx-badge__grade--b';
+  const isGradeC = g.startsWith('C');
+  if (isGradeC) return 'm-chemx-badge__grade--c';
+  const isGradeD = g.startsWith('D');
+  if (isGradeD) return 'm-chemx-badge__grade--d';
   return 'm-chemx-badge__grade--f';
 };
 

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

@@ -18,10 +18,14 @@ const props = withDefaults(defineProps<MChemxBadgeProps>(), {
 const targetHref = computed(() => props.reportUrl || props.href);
 const gradeClass = computed(() => {
   const g = props.grade.toUpperCase();
-  if (g.startsWith('A')) return 'm-chemx-badge__grade--a';
-  if (g.startsWith('B')) return 'm-chemx-badge__grade--b';
-  if (g.startsWith('C')) return 'm-chemx-badge__grade--c';
-  if (g.startsWith('D')) return 'm-chemx-badge__grade--d';
+  const isGradeA = g.startsWith('A');
+  if (isGradeA) return 'm-chemx-badge__grade--a';
+  const isGradeB = g.startsWith('B');
+  if (isGradeB) return 'm-chemx-badge__grade--b';
+  const isGradeC = g.startsWith('C');
+  if (isGradeC) return 'm-chemx-badge__grade--c';
+  const isGradeD = g.startsWith('D');
+  if (isGradeD) return 'm-chemx-badge__grade--d';
   return 'm-chemx-badge__grade--f';
 });
 </script>

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

@@ -13,7 +13,8 @@
   const isHighValue = $derived(value > 1000);
 
   const badge = $derived.by((): SampleCardBadgeDescriptor => {
-    if (status !== 'active') {
+    const isArchived = status !== 'active';
+    if (isArchived) {
       return {
         text: status,
         className: 'm-sample-card__badge m-sample-card__badge--archived'

package/blueprints/molecule-capsule/m-sample-card.tsx

@@ -6,7 +6,8 @@ export const resolveBadgeDescriptor = (
   status: 'active' | 'archived',
   isHighValue: boolean
 ): SampleCardBadgeDescriptor => {
-  if (status !== 'active') {
+  const isArchived = status !== 'active';
+  if (isArchived) {
     return {
       text: status,
       className: 'm-sample-card__badge m-sample-card__badge--archived'

package/blueprints/molecule-capsule/m-sample-card.vue

@@ -12,7 +12,8 @@ const props = withDefaults(defineProps<MSampleCardProps>(), {
 const isHighValue = computed(() => props.value > 1000);
 
 const badge = computed((): SampleCardBadgeDescriptor => {
-  if (props.status !== 'active') {
+  const isArchived = props.status !== 'active';
+  if (isArchived) {
     return {
       text: props.status,
       className: 'm-sample-card__badge m-sample-card__badge--archived'
@@ -31,7 +32,8 @@ const badge = computed((): SampleCardBadgeDescriptor => {
 });
 
 const handleActionClick = () => {
-  if (props.onAction) props.onAction();
+  const onActionHandler = props.onAction;
+  if (onActionHandler) onActionHandler();
 };
 </script>
 

package/blueprints/workflows/chemx-audit.yml

@@ -31,13 +31,19 @@ jobs:
             npm install
           fi
 
+      # Gate on the ratchet (chemx-ratchet.json): fail only when a rule rises above its recorded
+      # baseline. Without a ratchet file the gate fails on any CRITICAL/HIGH finding; record one with
+      # `npx chemx audit --rebaseline` (full scan). Set the CHEMX_MIN_GRADE / CHEMX_MIN_SCORE repo
+      # variables to add absolute floors.
       - name: Run Chemical X Architectural Audit
+        env:
+          CHEMX_MIN_GRADE: ${{ vars.CHEMX_MIN_GRADE }}
+          CHEMX_MIN_SCORE: ${{ vars.CHEMX_MIN_SCORE }}
         run: |
-          npx --yes chemx audit \
-            --min-grade=${{ vars.CHEMX_MIN_GRADE || 'B' }} \
-            --min-score=${{ vars.CHEMX_MIN_SCORE || 80 }} \
-            --markdown \
-            --output=AUDIT_REPORT.md
+          set -- --markdown --output=AUDIT_REPORT.md
+          if [ -n "$CHEMX_MIN_GRADE" ]; then set -- "$@" "--min-grade=$CHEMX_MIN_GRADE"; fi
+          if [ -n "$CHEMX_MIN_SCORE" ]; then set -- "$@" "--min-score=$CHEMX_MIN_SCORE"; fi
+          npx --yes chemx audit "$@"
 
       - name: Upload Audit Scorecard Artifact
         if: always()
@@ -62,53 +68,16 @@ jobs:
           {
             echo "<!-- chemical-x-audit-pr-comment -->"
             if [ -n "$DISCUSSION_URL" ]; then
-              echo "> 💬 **Architectural Discussion Topic:** [View Discussion & Community Showcase](\${DISCUSSION_URL})"
+              echo "> 💬 **Architectural Discussion Topic:** [View Discussion & Community Showcase]($DISCUSSION_URL)"
               echo ""
             fi
             cat AUDIT_REPORT.md
           } > PR_COMMENT.md
 
-          EXISTING_COMMENT_ID=$(gh api "repos/\${REPO}/issues/\${PR_NUMBER}/comments" --jq '.[] | select(.body | contains("<!-- chemical-x-audit-pr-comment -->")) | .id' | head -n 1)
+          EXISTING_COMMENT_ID=$(gh api "repos/$REPO/issues/$PR_NUMBER/comments" --jq '.[] | select(.body | contains("<!-- chemical-x-audit-pr-comment -->")) | .id' | head -n 1)
 
           if [ -n "$EXISTING_COMMENT_ID" ]; then
-            gh api --method PATCH "repos/\${REPO}/issues/comments/\${EXISTING_COMMENT_ID}" -F body=@PR_COMMENT.md
+            gh api --method PATCH "repos/$REPO/issues/comments/$EXISTING_COMMENT_ID" -F body=@PR_COMMENT.md
           else
-            gh pr comment "\${PR_NUMBER}" --body-file PR_COMMENT.md
+            gh pr comment "$PR_NUMBER" --body-file PR_COMMENT.md
           fi
-
-  scaffold-smoke-test:
-    name: Framework Scaffolding Smoke Test
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v4
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 22
-      - name: Install Dependencies
-        run: npm install
-      - name: Run Test Suite
-        run: npm test
-      - name: Multi-Framework Scaffolding Smoke Test
-        run: |
-          for fw in react vue svelte; do
-            echo "Smoke testing scaffolding for framework: $fw"
-            node cli/create.js test-app-$fw --framework=$fw --yes --skip-install
-            if [ "$fw" = "react" ]; then
-              test -f test-app-react/src/components/m-sample-card/m-sample-card.tsx
-              ! ls test-app-react/src/components/m-sample-card/*.vue 2>/dev/null
-              ! ls test-app-react/src/components/m-sample-card/*.svelte 2>/dev/null
-            elif [ "$fw" = "vue" ]; then
-              test -f test-app-vue/src/components/m-sample-card/m-sample-card.vue
-              ! ls test-app-vue/src/components/m-sample-card/*.tsx 2>/dev/null
-              ! ls test-app-vue/src/components/m-sample-card/*.svelte 2>/dev/null
-            elif [ "$fw" = "svelte" ]; then
-              test -f test-app-svelte/src/components/m-sample-card/m-sample-card.svelte
-              ! ls test-app-svelte/src/components/m-sample-card/*.vue 2>/dev/null
-              ! ls test-app-svelte/src/components/m-sample-card/*.tsx 2>/dev/null
-            fi
-            echo "Framework $fw scaffolded cleanly."
-          done
-
-

package/cli/agent-json.js

@@ -0,0 +1,40 @@
+import { stripAnsi } from './terminal.js';
+
+// One serializer for every --json payload an agent reads (CLI and, via G3, MCP):
+// minified, ANSI-free, no null fields. Diagnostic lists stay arrays (so `.errors|length`
+// counts diagnostics whether there are none or many) of "file:line:col CODE message"
+// strings, each shorter than the raw tool line it replaces. A report costs at most the raw
+// output plus a fixed envelope (success, exitCode, command, durationMs, errorCount);
+// cli/agent-json.spec.js pins both bounds.
+
+const isDiagnosticRow = (item) =>
+  Boolean(item) && typeof item === 'object' && typeof item.file === 'string' && 'line' in item && 'message' in item;
+
+const isDiagnosticList = (value) => Array.isArray(value) && value.length > 0 && value.every(isDiagnosticRow);
+
+export const formatDiagnosticRow = (row) => {
+  const isWarning = String(row.severity ?? '').toUpperCase() === 'WARNING';
+  const position = [stripAnsi(row.file), row.line, row.column].filter((part) => part !== undefined && part !== null && part !== '').join(':');
+  const code = row.code ?? row.ruleId ?? row.rule ?? null;
+  const parts = [position, isWarning ? 'warning' : null, code, stripAnsi(String(row.message))];
+  return parts.filter(Boolean).join(' ');
+};
+
+const compactValue = (value) => {
+  const isString = typeof value === 'string';
+  if (isString) return stripAnsi(value);
+  if (isDiagnosticList(value)) return value.map(formatDiagnosticRow);
+  if (Array.isArray(value)) return value.map(compactValue);
+  const isPlainObject = Boolean(value) && typeof value === 'object';
+  if (!isPlainObject) return value;
+  const compacted = {};
+  for (const [key, entry] of Object.entries(value)) {
+    const isAbsent = entry === null || entry === undefined;
+    if (!isAbsent) compacted[key] = compactValue(entry);
+  }
+  return compacted;
+};
+
+export const compactAgentPayload = (payload) => compactValue(payload);
+
+export const formatAgentJson = (payload) => JSON.stringify(compactValue(payload));

package/cli/apply-edits.js

@@ -0,0 +1,195 @@
+/**
+ * applyEdits: the single mutation gate for write, patch, autofix, explode and add:*.
+ *
+ * Every edit is validated before anything touches disk:
+ *   - the path stays inside the workspace (realpath containment, symlinked parents included);
+ *   - the new text parses (Babel / SFC script blocks / JSON) unless the old text was already broken;
+ *   - no top-level declaration disappears unless the caller named it in allowRemoved;
+ *   - no other agent holds a team lock on the file.
+ * A dry run returns the same result (with an uncapped unified diff) and writes nothing.
+ * A real run writes each file atomically with a backup and rolls back the batch on failure.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { resolveSafePath } from './path-scope.js';
+import { parseSource } from './source-parse.js';
+import { buildUnifiedDiff } from './edit-diff.js';
+import { writeAtomic, removeWithBackup, restoreFromBackup } from './edit-atomic.js';
+import { findForeignLease } from './edit-locks.js';
+import { syncLeasesAfterEdit } from './team/lease-renew.js';
+import { countLines } from './line-count.js';
+
+export class EditRefusedError extends Error {
+  constructor(issues) {
+    super(issues.map((i) => `${i.file}: ${i.reason}`).join('\n'));
+    this.name = 'EditRefusedError';
+    this.issues = issues;
+  }
+}
+
+/**
+ * Declaration delta between two parses. Every top-level declaration that disappears must be
+ * named in allowRemoved (or allowRemoved === true), renames included: a patch that removes A
+ * and adds an unrelated B is exactly the wrong-block replace this gate exists to catch.
+ */
+const declarationDelta = (beforeParse, afterParse, allowRemoved) => {
+  const isComparable = beforeParse.ok && afterParse.ok && beforeParse.kind === 'babel';
+  if (!isComparable) return { removed: [], added: [], blocked: [] };
+  const beforeSet = new Set(beforeParse.declarations);
+  const afterSet = new Set(afterParse.declarations);
+  const removed = beforeParse.declarations.filter((name) => !afterSet.has(name));
+  const added = afterParse.declarations.filter((name) => !beforeSet.has(name));
+  const isAllAllowed = allowRemoved === true;
+  const allowed = new Set(Array.isArray(allowRemoved) ? allowRemoved : []);
+  const unallowed = isAllAllowed ? [] : removed.filter((name) => !allowed.has(name));
+  return { removed, added, blocked: unallowed };
+};
+
+const V8_CHECKED_EXTENSIONS = new Set(['.js', '.mjs', '.cjs']);
+
+/**
+ * V8's own syntax check (node --check on a temp copy). Babel's parse does not report every
+ * early error V8 raises at import (redeclarations, duplicate exports, bad regex flags).
+ * Returns the first SyntaxError line, or null when V8 accepts the text or the check could not run
+ * (a failure to spawn node is not treated as a syntax error).
+ */
+const v8SyntaxError = (text, absPath, parse) => {
+  const ext = path.extname(absPath);
+  const isCheckedExtension = V8_CHECKED_EXTENSIONS.has(ext);
+  if (!isCheckedExtension) return null;
+  let dir = null;
+  try {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'chemx-v8check-'));
+    // node --check on a .js file holding module syntax skips regex early errors, so the copy
+    // gets the extension that matches how Babel read the text.
+    const isModule = ext === '.mjs' || parse.programs?.[0]?.sourceType === 'module';
+    const isCommonJs = ext === '.cjs' || !isModule;
+    const checkExt = isCommonJs ? '.cjs' : '.mjs';
+    const tmp = path.join(dir, `check${checkExt}`);
+    fs.writeFileSync(tmp, text);
+    const res = spawnSync(process.execPath, ['--check', tmp], { encoding: 'utf-8', timeout: 15000 });
+    const isAccepted = Boolean(res.error) || res.status === 0;
+    if (isAccepted) return null;
+    const lines = String(res.stderr).split('\n');
+    const found = lines.find((l) => /^\w*Error: /.test(l));
+    return found || lines.find((l) => l.trim()) || 'unknown syntax error';
+  } catch {
+    return null;
+  } finally {
+    if (dir) fs.rmSync(dir, { recursive: true, force: true });
+  }
+};
+
+const lapsedIssue = (file, lease) => {
+  const at = new Date(lease.expiresAt).toISOString();
+  return `your lease on ${file} lapsed at ${at} and ${lease.queue.join(', ')} ${lease.queue.length > 1 ? 'are' : 'is'} queued for it, so it is theirs next and this edit was not made (queue: ${lease.queue.join(' > ')}; see: chemx team lock status ${file})`;
+};
+
+const lockedIssue = (file, lease) => {
+  const isLapsedOwn = Boolean(lease.lapsedOwn);
+  if (isLapsedOwn) return lapsedIssue(file, lease);
+  const purpose = lease.purpose ? ` (${lease.purpose})` : '';
+  const until = new Date(lease.expiresAt).toISOString();
+  return `locked by ${lease.lockedBy}${purpose} until ${until}; wait until ${lease.lockedBy} releases it or the lease expires (check: chemx team lock check ${file}; all locks: chemx team lock list)`;
+};
+
+const planEdit = (edit, root, options) => {
+  const absPath = resolveSafePath(edit.path, root);
+  const file = path.relative(root, absPath);
+  const isExisting = fs.existsSync(absPath);
+  const isDirectory = isExisting && fs.statSync(absPath).isDirectory();
+  if (isDirectory) return { file, absPath, issue: 'path is a directory' };
+
+  const before = isExisting ? fs.readFileSync(absPath, 'utf-8') : null;
+  const isDelete = Boolean(edit.delete);
+  const plan = { file, absPath, before, isDelete, created: !isExisting, deleted: isDelete };
+  const isDeletingNothing = isDelete && !isExisting;
+  if (isDeletingNothing) return { ...plan, issue: 'cannot delete a file that does not exist' };
+  const isMissingContent = !isDelete && typeof edit.content !== 'string';
+  if (isMissingContent) return { ...plan, issue: 'no content given' };
+
+  const after = isDelete ? '' : edit.content;
+  const lease = findForeignLease(root, absPath, options.agentId);
+  const isLocked = Boolean(lease);
+  if (isLocked) return { ...plan, issue: lockedIssue(file, lease) };
+  if (isDelete) return { ...plan, after, parse: { kind: 'n/a', ok: true }, declarations: { removed: [], added: [] } };
+
+  const afterParse = parseSource(after, absPath);
+  const beforeParse = before === null ? null : parseSource(before, absPath);
+  const wasBroken = Boolean(beforeParse) && !beforeParse.ok;
+  const isNewlyBroken = !afterParse.ok && !wasBroken;
+  if (isNewlyBroken) return { ...plan, after, issue: `result does not parse (${afterParse.error}); nothing was written` };
+
+  const v8Error = wasBroken ? null : v8SyntaxError(after, absPath, afterParse);
+  if (v8Error) return { ...plan, after, issue: `V8 rejects the result (${v8Error}); nothing was written` };
+
+  const delta = beforeParse ? declarationDelta(beforeParse, afterParse, edit.allowRemoved) : { removed: [], added: [], blocked: [] };
+  const hasBlockedRemovals = delta.blocked.length > 0;
+  if (hasBlockedRemovals) {
+    const hasAdded = delta.added.length > 0;
+    const addedNote = hasAdded ? ` (and would add ${delta.added.join(', ')})` : '';
+    return { ...plan, after, issue: `would remove top-level declaration(s) ${delta.blocked.join(', ')}${addedNote}; name them in allowRemoved (CLI: --allow-remove=${delta.blocked.join(',')}) if intended` };
+  }
+
+  const parse = { kind: afterParse.kind, ok: afterParse.ok, ...(wasBroken ? { note: 'file did not parse before this edit either, so the parse and declaration-removal checks could not run' } : {}) };
+  return { ...plan, after, parse, declarations: { removed: delta.removed, added: delta.added } };
+};
+
+const commitPlans = (plans, root) => {
+  const done = [];
+  try {
+    for (const plan of plans) {
+      const isUnchanged = !plan.isDelete && plan.before === plan.after;
+      if (isUnchanged) continue;
+      const { backup } = plan.isDelete ? removeWithBackup(plan.absPath, root) : writeAtomic(plan.absPath, plan.after, root);
+      plan.backup = backup;
+      done.push(plan);
+    }
+  } catch (err) {
+    for (const plan of done.reverse()) restoreFromBackup(plan.absPath, plan.backup);
+    throw err;
+  }
+};
+
+/**
+ * @param {Array<{ path: string, content?: string, delete?: boolean, allowRemoved?: string[]|true }>} edits
+ * @param {object} [options] { cwd, dryRun, agentId }
+ * @returns {{ dryRun: boolean, files: object[], diff: string }}
+ * @throws {EditRefusedError} When any edit is refused (nothing is written).
+ */
+export const applyEdits = (edits, options = {}) => {
+  const rawRoot = options.cwd || process.cwd();
+  const root = fs.existsSync(rawRoot) ? fs.realpathSync(rawRoot) : path.resolve(rawRoot);
+  const dryRun = Boolean(options.dryRun);
+  const plans = edits.map((edit) => planEdit(edit, root, options));
+  const issues = plans.filter((p) => p.issue).map((p) => ({ file: p.file, reason: p.issue }));
+  const hasIssues = issues.length > 0;
+  if (hasIssues) throw new EditRefusedError(issues);
+
+  const isPreview = dryRun;
+  let leaseNotes = [];
+  if (!isPreview) {
+    commitPlans(plans, root);
+    // Renew-on-edit: a live lease of the caller's on a written file gets one more TTL; a lapsed,
+    // untaken one is re-acquired and the result says so.
+    leaseNotes = syncLeasesAfterEdit(root, plans.map((p) => p.absPath), options.agentId).notes;
+  }
+
+  const files = plans.map((p) => ({
+    file: p.file,
+    absPath: p.absPath,
+    created: p.created,
+    deleted: p.deleted,
+    changed: p.isDelete || p.before !== p.after,
+    originalLines: p.before === null ? 0 : countLines(p.before),
+    newLines: p.isDelete ? 0 : countLines(p.after),
+    parse: p.parse,
+    declarations: p.declarations,
+    backup: p.backup ? path.relative(root, p.backup) : null,
+    diff: buildUnifiedDiff(p.before ?? '', p.after, { path: p.file, isNew: p.created, isDeleted: p.isDelete })
+  }));
+  const noteField = leaseNotes.length > 0 ? { leaseNotes } : {};
+  return { dryRun, files, diff: files.map((f) => f.diff).filter(Boolean).join('\n'), ...noteField };
+};

package/cli/audit/ai-slop-detector.js

@@ -1,4 +1,5 @@
 import * as t from '@babel/types';
+import { ruleTree } from '../rules.js';
 import { RULE_REGISTRY } from './rules-registry.js';
 import {
   isComponentPath,
@@ -7,12 +8,17 @@ import {
   hasAnyTypeAnnotation,
   isRedundantPassthroughReturn
 } from './rules-predicates.js';
+import { resolveCatchEscalation, resolveCatchSpan } from './shallow-catch-escalation.js';
 
 const RESIDUE_PATTERNS = [
   ['hope this', 'helps'].join(' '),
   ['feel free', 'to tweak'].join(' '),
   ['let me know', 'if you need'].join(' '),
-  ['as', 'requested'].join(' '),
+  // Assistant framing only (the phrase followed by a pause and "here"/"I"/"below",
+  // or addressed to "you"). The bare phrase in a sentence about an API client is
+  // ordinary engineering prose.
+  ['as you', 'requested'].join(' '),
+  ['as', 'requested[,.!:]\\s*(?:here|i\\b|below)'].join(' '),
   ['as an ai', 'language model'].join(' ')
 ];
 
@@ -81,19 +87,24 @@ const normalizeWords = (text) => {
 const COMMENT_LINE_START = /^\s*(?:\/\/|#|\*|--)/;
 
 const isInsideStringLiteral = (lineText, matchIndex) => {
-  if (matchIndex <= 0) return false;
-  if (COMMENT_LINE_START.test(lineText)) return false;
+  const isAtLineStart = matchIndex <= 0;
+  if (isAtLineStart) return false;
+  const isCommentLine = COMMENT_LINE_START.test(lineText);
+  if (isCommentLine) return false;
 
   let quote = null;
   for (let i = 0; i < matchIndex; i += 1) {
     const ch = lineText[i];
-    if (ch === '\\') {
+    const isEscape = ch === '\\';
+    if (isEscape) {
       i += 1;
       continue;
     }
+    const closesQuote = ch === quote;
+    const opensQuote = ch === '"' || ch === "'" || ch === '`';
     if (quote) {
-      if (ch === quote) quote = null;
-    } else if (ch === '"' || ch === "'" || ch === '`') {
+      if (closesQuote) quote = null;
+    } else if (opensQuote) {
       quote = ch;
     }
   }
@@ -104,7 +115,8 @@ export const checkSlopTextPatterns = (content, lines, relativePath, violations)
   lines.forEach((lineText, idx) => {
     for (const pat of CONVERSATIONAL_PATTERNS) {
       const hit = pat.regex.exec(lineText);
-      if (hit && !isInsideStringLiteral(lineText, hit.index)) {
+      const isRealHit = Boolean(hit && !isInsideStringLiteral(lineText, hit.index));
+      if (isRealHit) {
         const meta = RULE_REGISTRY[pat.rule];
         violations.push({
           filePath: relativePath,
@@ -122,11 +134,13 @@ export const checkSlopTextPatterns = (content, lines, relativePath, violations)
     }
 
     const trimmed = lineText.trim();
-    if (trimmed.startsWith('//') && !trimmed.startsWith('///')) {
+    const isLineComment = trimmed.startsWith('//') && !trimmed.startsWith('///');
+    if (isLineComment) {
       const commentBody = trimmed.replace(/^\/\/\s*/, '');
       const commentWords = normalizeWords(commentBody);
 
-      if (commentWords.length >= 2 && commentWords.length <= 6) {
+      const isShortComment = commentWords.length >= 2 && commentWords.length <= 6;
+      if (isShortComment) {
         let nextIdx = idx + 1;
         while (nextIdx < lines.length) {
           const nextTrim = lines[nextIdx].trim();
@@ -134,10 +148,12 @@ export const checkSlopTextPatterns = (content, lines, relativePath, violations)
             const nextWords = new Set(normalizeWords(nextTrim));
             let matchCount = 0;
             for (const cw of commentWords) {
-              if (nextWords.has(cw)) matchCount += 1;
+              const isEchoedWord = nextWords.has(cw);
+              if (isEchoedWord) matchCount += 1;
             }
             const matchRatio = matchCount / commentWords.length;
-            if (matchRatio >= 0.75) {
+            const isEcho = matchRatio >= 0.75;
+            if (isEcho) {
               const meta = RULE_REGISTRY.AI_SLOP_ECHO_COMMENT;
               violations.push({
                 filePath: relativePath,
@@ -169,15 +185,16 @@ export const createAiSlopVisitors = ({ relativePath, violations }) => {
       const isShallowCatch = isShallowCatchBody(body, t);
 
       if (isShallowCatch) {
-        const line = astPath.node.loc?.start.line || 1;
         const meta = RULE_REGISTRY.AI_SLOP_SHALLOW_CATCH;
+        const { severity, binding } = resolveCatchEscalation(astPath);
         violations.push({
           filePath: relativePath,
-          line,
-          column: astPath.node.loc?.start.column || 1,
-          hazard: 'Shallow catch paranoia wrapper (silent suppression without handling)',
+          ...resolveCatchSpan(astPath),
+          hazard: binding
+            ? `Shallow catch leaves "${binding}" unset; it is read after the try (silent undefined propagation)`
+            : 'Shallow catch paranoia wrapper (silent suppression without handling)',
           rule: 'AI_SLOP_SHALLOW_CATCH',
-          severity: meta.severity,
+          severity,
           pillar: meta.pillar,
           directive: meta.directive,
           isAiSlop: true
@@ -203,7 +220,8 @@ export const createAiSlopVisitors = ({ relativePath, violations }) => {
 
     BlockStatement(astPath) {
       const stmts = astPath.node.body;
-      if (stmts.length >= 2) {
+      const hasMultipleStatements = stmts.length >= 2;
+      if (hasMultipleStatements) {
         for (let i = 0; i < stmts.length - 1; i++) {
           const curr = stmts[i];
           const next = stmts[i + 1];
@@ -230,7 +248,8 @@ export const createAiSlopVisitors = ({ relativePath, violations }) => {
     FunctionDeclaration(astPath) {
       if (!isComponentFile) return;
       const fnName = astPath.node.id?.name?.toLowerCase();
-      if (fnName && REINVENTED_UTILS.has(fnName)) {
+      const isReinventedFn = Boolean(fnName && REINVENTED_UTILS.has(fnName));
+      if (isReinventedFn) {
         const line = astPath.node.loc?.start.line || 1;
         const meta = RULE_REGISTRY.AI_SLOP_UTILITY_REINVENTION;
         violations.push({
@@ -248,27 +267,35 @@ export const createAiSlopVisitors = ({ relativePath, violations }) => {
     },
 
     VariableDeclarator(astPath) {
-      if (!isComponentFile) return;
       const idName = astPath.node.id?.name?.toLowerCase();
-      if (!idName || !REINVENTED_UTILS.has(idName)) return;
-
+      const isReinventedName = Boolean(idName && REINVENTED_UTILS.has(idName));
       const initNode = astPath.node.init;
-      const isFunction = t.isArrowFunctionExpression(initNode) || t.isFunctionExpression(initNode);
-      if (!isFunction) return;
+      const isFunction = Boolean(initNode && (t.isArrowFunctionExpression(initNode) || t.isFunctionExpression(initNode)));
+
+      const gate = ruleTree({
+        declarator: {
+          notComponent: !isComponentFile,
+          notReinvented: !isReinventedName,
+          notFunction: !isFunction
+        }
+      }, { failFast: true });
+
+      const isReinvented = gate.ok;
+      if (!isReinvented) return;
 
       const line = astPath.node.loc?.start.line || 1;
-        const meta = RULE_REGISTRY.AI_SLOP_UTILITY_REINVENTION;
-        violations.push({
-          filePath: relativePath,
-          line,
-          column: astPath.node.loc?.start.column || 1,
-          hazard: `Inline utility reinvention "${astPath.node.id.name}" in component capsule`,
-          rule: 'AI_SLOP_UTILITY_REINVENTION',
-          severity: meta.severity,
-          pillar: meta.pillar,
-          directive: meta.directive,
-          isAiSlop: true
-        });
+      const meta = RULE_REGISTRY.AI_SLOP_UTILITY_REINVENTION;
+      violations.push({
+        filePath: relativePath,
+        line,
+        column: astPath.node.loc?.start.column || 1,
+        hazard: `Inline utility reinvention "${astPath.node.id.name}" in component capsule`,
+        rule: 'AI_SLOP_UTILITY_REINVENTION',
+        severity: meta.severity,
+        pillar: meta.pillar,
+        directive: meta.directive,
+        isAiSlop: true
+      });
     }
   };
 };