@adia-ai/adia-ui-forge 0.1.2

package/skills/adia-ui-authoring/scripts/audit-authoring-roster.mjs

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+// audit-authoring-roster.mjs — §SelfAudit enforcement for adia-ui-authoring.
+// Universal axes via the shared audit-axes lib; plus a skill-specific
+// absorbed-skill roster-currency axis.
+//
+// Usage (from anywhere):
+//   node scripts/audit-authoring-roster.mjs
+//   node scripts/audit-authoring-roster.mjs --json
+//   node scripts/audit-authoring-roster.mjs --strict
+//
+// Resolves the shared lib via ${CLAUDE_PLUGIN_ROOT}/bin/lib/audit-axes.mjs,
+// with a fallback relative to this script (skills/<name>/scripts → bin/lib).
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SKILL_DIR = path.resolve(__dirname, '..');            // skills/adia-ui-authoring
+const SKILLS_ROOT = path.resolve(SKILL_DIR, '..');          // skills/
+const PLUGIN_ROOT = process.env.CLAUDE_PLUGIN_ROOT
+  ? path.resolve(process.env.CLAUDE_PLUGIN_ROOT)
+  : path.resolve(SKILL_DIR, '..', '..');                    // plugin root
+
+const SKILL_MD = path.join(SKILL_DIR, 'SKILL.md');
+const SKILL_JSON = path.join(SKILL_DIR, 'skill.json');
+
+// Resolve the shared audit-axes library from the plugin root, falling back
+// to the script-relative location if the env var isn't set.
+const auditAxesPath = (() => {
+  const fromEnv = path.join(PLUGIN_ROOT, 'bin', 'lib', 'audit-axes.mjs');
+  if (fs.existsSync(fromEnv)) return fromEnv;
+  return path.resolve(__dirname, '..', '..', '..', 'bin', 'lib', 'audit-axes.mjs');
+})();
+
+const { runUniversalAxes, formatResults } = await import(pathToFileURL(auditAxesPath).href);
+
+// [name, expected-redirect-path or null if already-gone]. The legacy
+// skills these absorbed were never carried into this plugin, so every
+// entry is expected to be absorbed-clean (no directory present).
+const ABSORBED = [
+  ['primitive-audit',            null],
+  ['component-token-audit',      null],
+  ['llm-bridge-extension',       null],
+  ['adia-ui-code-bestpractices', null],
+  ['bespoke-shell-children',     null],
+  ['promote-inline-to-module',   null],
+];
+
+const CLEAN_STATUSES = ['absorbed-clean', 'absorbed-clean-deleted', 'redirect-ok'];
+
+function parseArgs(argv) {
+  if (argv.includes('--help') || argv.includes('-h')) {
+    console.log(`audit-authoring-roster.mjs — adia-ui-authoring §SelfAudit.
+
+USAGE
+  node scripts/audit-authoring-roster.mjs [--json] [--strict]
+
+FLAGS
+  --json     Emit findings as JSON instead of human text
+  --strict   Exit 1 on any drifting axis
+  --help     Show this help
+
+AXES (universal axes from \${CLAUDE_PLUGIN_ROOT}/bin/lib/audit-axes.mjs)
+  1  Manifest enforcement     — skill.json files[] matches disk (recursive)
+  2  Reference graph          — every markdown link inside SKILL.md resolves
+  3  Capability-menu drift    — every §ColdStartTriage row's entry reference exists
+  4  Version-literal parity   — SKILL.md frontmatter version matches skill.json
+  5  Phase-label absence      — no stale Phase N annotations in skill prose
+  6  Fence-leak detection     — no orphan fence markers
+  7  Content currency         — references cited by skill.json exist on disk
+  8  CLI helper currency      — npm scripts cited by SKILL.md (skips substrate-only)
+
+  9  Authoring-roster currency (skill-specific) — every absorbed skill has a
+     redirect SKILL.md at the expected path or is absorbed-clean (no directory).
+
+EXIT CODES
+  0   All axes clean
+  1   At least one axis drifting (with --strict)
+`);
+    process.exit(0);
+  }
+  return { json: argv.includes('--json'), strict: argv.includes('--strict') };
+}
+
+function axis9_authoringRosterCurrency() {
+  const findings = [];
+  for (const [name, redirectPath] of ABSORBED) {
+    if (redirectPath === null) {
+      const dir = path.join(SKILLS_ROOT, name);
+      if (fs.existsSync(dir)) {
+        findings.push({ type: 'unexpected-directory', message: `${name}/ exists but was claimed absorbed-and-gone`, name });
+      } else {
+        findings.push({ type: 'absorbed-clean', message: `${name}: no directory — correct`, name });
+      }
+    } else {
+      const full = path.join(PLUGIN_ROOT, redirectPath);
+      if (!fs.existsSync(full)) {
+        const dir = path.dirname(full);
+        findings.push({
+          type: fs.existsSync(dir) ? 'redirect-missing' : 'absorbed-clean-deleted',
+          message: fs.existsSync(dir)
+            ? `${name}: expected redirect at ${redirectPath} — not found`
+            : `${name}: fully deleted post-soak`,
+          name,
+        });
+      } else {
+        const txt = fs.readFileSync(full, 'utf8');
+        findings.push(
+          /status:\s*redirect/m.test(txt)
+            ? { type: 'redirect-ok', message: `${name}: redirect ok`, name }
+            : { type: 'redirect-not-tagged', message: `${name}: ${redirectPath} lacks 'status: redirect'`, name }
+        );
+      }
+    }
+  }
+  const driftCount = findings.filter(f => !CLEAN_STATUSES.includes(f.type)).length;
+  return {
+    axis: 'authoringRosterCurrency',
+    axis_num: 9,
+    status: driftCount > 0 ? 'drift' : 'ok',
+    findings,
+    summary: driftCount > 0 ? `${driftCount} absorbed-skill issue(s)` : 'all absorbed-skill entries clean',
+  };
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const ctx = { skillDir: SKILL_DIR, skillMd: SKILL_MD, skillJson: SKILL_JSON, repoRoot: PLUGIN_ROOT };
+  const { results: universal } = runUniversalAxes(ctx);
+  const axis9 = axis9_authoringRosterCurrency();
+  const allResults = [...universal, axis9];
+  const driftCount = allResults.filter(r => r.status === 'drift').length;
+
+  if (args.json) {
+    console.log(JSON.stringify({ results: allResults, driftCount }, null, 2));
+    if (args.strict && driftCount > 0) process.exit(1);
+    return;
+  }
+
+  console.log(`[audit-authoring-roster] adia-ui-authoring §SelfAudit — ${driftCount} drifting axis/axes`);
+  console.log(formatResults(allResults));
+  if (driftCount === 0) console.log('\n✓ All clean.');
+  if (args.strict && driftCount > 0) process.exit(1);
+}
+
+main();

package/skills/adia-ui-authoring/scripts/build-canonical-pattern-index.mjs

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+/**
+ * build-canonical-pattern-index.mjs — Auto-build canonical-pattern-index.md
+ *
+ * Walks apps/, catalog/, and playgrounds/ for `.contents.html` files and
+ * emits a grouped markdown index used by Mode 8 (composite-demo-protocol.md)
+ * Phase 2 (Canonical Survey).
+ *
+ * Run from the framework monorepo root (the dirs it scans — apps/, catalog/,
+ * playgrounds/ — are monorepo roots):
+ *
+ *   node scripts/build-canonical-pattern-index.mjs
+ *
+ * The output `references/canonical-pattern-index.md` is checked in so agents
+ * reading the skill always see the current state without running the script
+ * first. REPO_ROOT defaults to the current working directory; OUTPUT is
+ * resolved relative to this script (into the skill's own references/).
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = process.env.REPO_ROOT
+  ? path.resolve(process.env.REPO_ROOT)
+  : process.cwd();
+const OUTPUT = path.join(__dirname, '..', 'references', 'canonical-pattern-index.md');
+
+const ROOTS = [
+  { path: 'apps/saas/app', label: 'SaaS app dashboards' },
+  { path: 'apps/genui/app', label: 'GenUI app routes' },
+  { path: 'apps/user-flow/app', label: 'User-flow templates' },
+  { path: 'catalog/ui-patterns/app', label: 'UI-pattern atomics (catalog)' },
+  { path: 'catalog/page-shells/app', label: 'Page-shell templates (catalog)' },
+  { path: 'playgrounds', label: 'Playgrounds' },
+];
+
+function walkContentsHtml(root) {
+  const results = [];
+  const abs = path.join(REPO_ROOT, root);
+  if (!fs.existsSync(abs)) return results;
+  function recurse(dir) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        recurse(full);
+      } else if (entry.name.endsWith('.contents.html')) {
+        results.push(path.relative(REPO_ROOT, full));
+      }
+    }
+  }
+  recurse(abs);
+  return results.sort();
+}
+
+function lineCount(rel) {
+  try {
+    return fs.readFileSync(path.join(REPO_ROOT, rel), 'utf8').split('\n').length;
+  } catch {
+    return 0;
+  }
+}
+
+function inferUiType(rel) {
+  const segments = rel.split('/');
+  const slug = segments[segments.length - 2] ?? '';
+
+  // Heuristics — categorize by slug fragments
+  if (/billing|invoice|payment|plan-picker|subscription/i.test(slug)) return 'billing';
+  if (/dashboard|kpi|metrics|admin-dashboard/i.test(slug)) return 'dashboard';
+  if (/settings|preferences|notification/i.test(slug)) return 'settings';
+  if (/onboarding|welcome|first-action/i.test(slug)) return 'onboarding-wizard';
+  if (/registration|sign-up|profile/i.test(slug)) return 'registration-wizard';
+  if (/sign-in|password|mfa|otp|oauth|forgot|reset/i.test(slug)) return 'auth-flow';
+  if (/error|404|500|forbidden|locked|expired|deleted/i.test(slug)) return 'error-page';
+  if (/email-change|verify|callback/i.test(slug)) return 'auth-flow';
+  if (/integration|connector|api/i.test(slug)) return 'integrations-list';
+  if (/members|users|team/i.test(slug)) return 'list-with-detail';
+  if (/security|privacy/i.test(slug)) return 'settings';
+  if (/marketing|hero|cta|landing/i.test(slug)) return 'marketing';
+  if (/agent|reasoning|trace/i.test(slug)) return 'agent-activity';
+  if (/chat|conversation|message/i.test(slug)) return 'chat';
+  if (/editor|code|preview/i.test(slug)) return 'editor';
+  if (/kanban|board/i.test(slug)) return 'kanban';
+  if (/table|grid|data/i.test(slug)) return 'data-table';
+  if (/command|palette|search/i.test(slug)) return 'command';
+  if (/funnel|conversion|step/i.test(slug)) return 'multi-step-funnel';
+  if (/modal|confirm|destructive/i.test(slug)) return 'overlay';
+  if (/profile-card|user-card/i.test(slug)) return 'list-with-detail';
+  if (/feed|activity|timeline/i.test(slug)) return 'feed';
+  if (/render|stream|css-channel|a2ui/i.test(slug)) return 'demo-playground';
+  return 'other';
+}
+
+const UI_TYPE_ORDER = [
+  'billing', 'dashboard', 'settings', 'auth-flow', 'onboarding-wizard',
+  'registration-wizard', 'list-with-detail', 'integrations-list', 'agent-activity',
+  'chat', 'editor', 'kanban', 'data-table', 'command', 'overlay',
+  'multi-step-funnel', 'feed', 'marketing', 'error-page', 'demo-playground', 'other',
+];
+
+const UI_TYPE_GUIDANCE = {
+  billing: 'Billing dashboards (current plan, invoices, payment methods, usage). Lift card-ui + section + col-ui + field-ui chain from billing.contents.html.',
+  dashboard: 'Admin dashboards (KPI grids, overview cards). Lift grid-ui responsive columns from admin-dashboard.contents.html.',
+  settings: 'Settings pages (preferences, security, appearance). Lift card-ui per setting group + col-ui spacing.',
+  'auth-flow': 'Authentication flows (sign-in, MFA, OAuth, password reset). Lift single-column form layout from sign-in.contents.html siblings.',
+  'onboarding-wizard': 'Onboarding multi-step wizards. Lift step-progress + section + cta-row pattern.',
+  'registration-wizard': 'Registration multi-step flows. Lift wizard step + form composition.',
+  'list-with-detail': 'List + detail compositions (entity rows + drawer/modal detail). Lift entity-item + drawer pattern.',
+  'integrations-list': 'Searchable integration/connector grids. Lift grid-ui + card-ui + empty-state-inside-card pattern.',
+  'agent-activity': 'Agent activity / reasoning feeds. Lift activity-feed scroll + collapsed-reasoning pattern.',
+  chat: 'Chat surfaces (thread, composer, sidebar). Lift chat-streaming-surface composition.',
+  editor: 'Editor panes (code, preview, toolbar). Lift editor-shell composition.',
+  kanban: 'Kanban / column-based boards. Lift kanban-board-3col pattern.',
+  'data-table': 'Data tables with badges/inline actions. Lift users-table-badge composition.',
+  command: 'Command palette / global search. Lift command-palette overlay pattern.',
+  overlay: 'Modals, drawers, popovers. Lift destructive-confirm-modal pattern for confirmations.',
+  'multi-step-funnel': 'Multi-step conversion funnels. Lift conversion-funnel-6step composition.',
+  feed: 'Activity / event feeds. Lift activity-feed composition.',
+  marketing: 'Marketing pages, hero CTAs. Lift marketing-hero-cta composition.',
+  'error-page': 'Error states (404, 500, forbidden, expired). Lift centered single-card error pattern.',
+  'demo-playground': 'Internal demo + playground surfaces. Use these as reference for composition style; not always production-grade.',
+  other: 'Misc canonicals. Inspect contents.html to determine UI type.',
+};
+
+function buildMarkdown(grouped) {
+  const lines = [
+    '# Canonical Pattern Index — survey targets for Mode 8 (composite-demo-protocol.md)',
+    '',
+    '**Auto-generated** by `scripts/build-canonical-pattern-index.mjs`. Do not edit by hand — re-run the build script after adding new canonicals to `apps/`, `catalog/`, or `playgrounds/`.',
+    '',
+    `**Total canonical \`.contents.html\` files**: ${grouped.totalFiles}`,
+    '',
+    '## How to use this index',
+    '',
+    '1. From Phase 1 of [composite-demo-protocol.md](composite-demo-protocol.md), name the UI type.',
+    '2. Find the matching section below.',
+    '3. Read every `.contents.html` listed (or the closest 2-3 if the section has many).',
+    '4. Extract primitive composition per Phase 3 of the protocol.',
+    '5. Cite the path in your demo\'s `<!-- Pattern source: ... -->` comment.',
+    '',
+    '---',
+    '',
+  ];
+
+  for (const uiType of UI_TYPE_ORDER) {
+    const files = grouped.byType[uiType];
+    if (!files || files.length === 0) continue;
+    lines.push(`## ${uiType} (${files.length})`);
+    lines.push('');
+    lines.push(`> ${UI_TYPE_GUIDANCE[uiType]}`);
+    lines.push('');
+    for (const f of files) {
+      const lc = lineCount(f.path);
+      lines.push(`- \`${f.path}\` — ${lc} lines (from ${f.root})`);
+    }
+    lines.push('');
+  }
+
+  lines.push('---');
+  lines.push('');
+  lines.push('## Maintenance');
+  lines.push('');
+  lines.push('Re-build this index:');
+  lines.push('');
+  lines.push('```bash');
+  lines.push('node scripts/build-canonical-pattern-index.mjs');
+  lines.push('```');
+  lines.push('');
+  lines.push('If a heuristic misclassifies a path (the file lands in `other` or the wrong UI type), update the `inferUiType()` regex in `scripts/build-canonical-pattern-index.mjs`.');
+  lines.push('');
+  return lines.join('\n');
+}
+
+function main() {
+  const grouped = { byType: {}, totalFiles: 0 };
+
+  for (const { path: rootPath, label } of ROOTS) {
+    const files = walkContentsHtml(rootPath);
+    for (const f of files) {
+      const uiType = inferUiType(f);
+      (grouped.byType[uiType] ??= []).push({ path: f, root: label });
+      grouped.totalFiles++;
+    }
+  }
+
+  const md = buildMarkdown(grouped);
+  fs.writeFileSync(OUTPUT, md);
+  console.log(`Wrote ${OUTPUT}`);
+  console.log(`  ${grouped.totalFiles} canonical .contents.html files indexed`);
+  for (const uiType of UI_TYPE_ORDER) {
+    const count = (grouped.byType[uiType] || []).length;
+    if (count > 0) console.log(`    ${uiType}: ${count}`);
+  }
+}
+
+main();

package/skills/adia-ui-authoring/skill.json

@@ -0,0 +1,45 @@
+{
+  "name": "adia-ui-authoring",
+  "version": "1.9.2",
+  "description": "Author or modify code INSIDE the adia-ui (@adia-ai) monorepo — primitives in packages/web-components/, composite shells in packages/web-modules/, inline page content promoted to reusable modules, composite/module demos (.examples.html, .contents.html), the @adia-ai/llm bridge, the trait catalog, .a2ui.json sidecars, yaml SoTs — clearing the four-axis contract before review and VERIFYING against the built/rendered artifact (build:components --verify, the primitive's demo page, the rendered-DOM probe), never 'looks done'. Use whenever the user wants to ADD A NEW PRIMITIVE / MODIFY A COMPONENT / FIX A YAML / PROMOTE INLINE TO MODULE / UPDATE A SHELL / AUTHOR A DEMO FOR A COMPOSITE OR MODULE / COMPOSE EXAMPLES.HTML / EXTEND THE LLM BRIDGE — the work happens on packages/* source, not on consumer code. Triggers on 'add a primitive', 'modify table-ui yaml', 'author a new web-module shell', 'trait catalog regenerated wrong', 'promote inline CSS to a module', 'audit the four-axis contract', '.a2ui.json sidecar is stale', 'set up LLM-bridge surface', 'author a demo for X', 'compose examples.html for Y', any edit under packages/web-modules/**/*.examples.html or **/*.contents.html. Does NOT trigger for: composing screens FROM existing primitives in consumer/app code (the adia-ui-factory plugin), cutting a release (adia-ui-release), generation-pipeline internals (adia-ui-a2ui), scoring generated UI quality (adia-ui-gen-review), broad cross-surface QA (adia-ui-dogfood). Absorbs primitive-audit + component-token-audit + code-bestpractices + bespoke-shell-children + promote-inline-to-module + llm-bridge-extension.",
+  "status": "stable",
+  "authors": ["kim.granlund"],
+  "codeowners": [],
+  "tags": ["adia-ui", "web-components", "web-modules", "design-system", "component-authoring", "tokens", "light-dom", "scope-css", "lifecycle", "form-associated", "shell-patterns", "inline-to-module", "llm-bridge", "composite-demo"],
+  "depends_on": [],
+  "peer_skills": ["adia-ui-release", "adia-ui-a2ui", "adia-ui-llm", "adia-ui-gen-review", "adia-ui-dogfood", "ui-audit-coherence", "analyze-css", "ui-build-components"],
+  "environment": {
+    "portable": false,
+    "requires": ["the adia-ui (@adia-ai) framework monorepo with packages/web-components/, packages/web-modules/, packages/llm/, packages/a2ui/, and the component-token-contract spec"],
+    "rationale": "Every mode operates on monorepo-specific source layout, build scripts, and the four-axis contract; it does not apply to consumer repos."
+  },
+  "files": [
+    "SKILL.md",
+    "CHANGELOG.md",
+    "skill.json",
+    "references/primitive-audit.md",
+    "references/authoring-cycle.md",
+    "references/code-style.md",
+    "references/api-contract.md",
+    "references/yaml-contract.md",
+    "references/css-patterns.md",
+    "references/lifecycle-patterns.md",
+    "references/shell-patterns.md",
+    "references/module-promotion.md",
+    "references/token-contract.md",
+    "references/llm-bridge.md",
+    "references/teach-protocol.md",
+    "references/composite-demo-protocol.md",
+    "references/canonical-pattern-index.md",
+    "references/common-gotchas.md",
+    "references/anti-patterns.md",
+    "references/worked-example.md",
+    "scripts/audit-authoring-roster.mjs",
+    "scripts/build-canonical-pattern-index.mjs",
+    "evals/routing-corpus.json",
+    "evals/adversarial-design-plan-gates.json",
+    "assets/case-studies/maxtokens-32768-discovery.md",
+    "assets/case-studies/admin-shell-decomposition.md",
+    "assets/case-studies/theme-panel-promotion.md"
+  ]
+}

package/skills/adia-ui-dogfood/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog — adia-ui-dogfood
+
+## [0.1.0] stable — 2026-06-03
+
+**MINOR** — first cut as a plugin skill. Ported from the framework monorepo's maintainer skill `dogfood-sweep`, renamed and de-repo'd: absolute paths stripped, shared-infra references rewritten to `${CLAUDE_PLUGIN_ROOT}/...`, the component visual probe bundled at `scripts/analyze.mjs` (repo-root resolved from `$ADIA_REPO_ROOT` / cwd, not a path relative to the install), instance data dropped. No procedural changes to the 6 modes.
+
+SKILL.md carries all 6 modes inline (component visual probe / app-shell QA / HTML typo sweep / native-primitive leak / admin-shell composition / component anatomy + card header), with a cold-start triage menu, §Plan-Execute-Verify, §SelfAudit, §Teach, and §FileMap added to match the rollup-family conventions. Modes 2 / 4 / 5 drive **repo-local** audit scripts that ship in the monorepo (`scripts/dev/audit-app-shells.mjs`, `audit-native-primitive-leak.mjs`, `audit-shell-composition.mjs`); modes 3 / 6 use inline shell snippets.
+
+### Reconstructed history (pre-port)
+
+- Added probe #6 (missing component CSS detection) to mode 1 after the swap-to-primitive-but-forget-the-link class slipped past a real PR. The bug class: an agent uses `<button-ui>` markup but forgets the `<link rel="stylesheet">` for the button component CSS; the element registers, the markup looks right, and the control renders unstyled.
+
+- Native-primitive-leak audit (mode 4) intent-marker detection window widened from 80 → 200 chars after a peer agent found that realistic preceding-line comments (indent + comment prefix + reason text + closing `-->` + newline) sat at exactly the 80-char boundary and were not detected.
+
+- Mode 6 (Component Anatomy + Card Header Sweep) added: card-ui `<header><div>` wrapper anti-pattern + missing anatomy sections per the anatomy-sweep gate's expectations.
+
+- Mode 1 (component visual probe via Chromium) was the initial skill. Modes 2–5 were absorbed from the substrate-side `scripts/dev/audit-*.mjs` work over multiple cycles. The skill grew its 6-mode catalog organically.

package/skills/adia-ui-dogfood/README.md

@@ -0,0 +1,62 @@
+# adia-ui-dogfood
+
+Six-mode static + visual QA sweep for the adia-ui framework substrate. The agent-facing skill body — all six modes, triage rules, fix recipes, and verify targets — is in `SKILL.md`. This README covers the one bundled script.
+
+## The component visual probe (`scripts/analyze.mjs`)
+
+Walks every `site/components/*` demo page in headless Chromium and runs visual-correctness probes that type-checks and tests don't catch:
+
+| # | Probe | Bug class it detects |
+| --- | --- | --- |
+| 1 | Zero-area | Element collapsed (parent `display:none`, toolbar overflow spilled it, layout glitch) |
+| 2 | Transparent fill | `[data-swatch]` / variant pill / button / chart indicator whose computed bg is `rgba(0,0,0,0)` — fallback token doesn't resolve (the chart-legend `--chart-N` class) |
+| 3 | Empty control | `input-ui` / `search-ui` whose `connected()` should have stamped internals but didn't |
+| 4 | Synonym-attr / synonym-slot drift | Markers from the attribute-api-migration convention (`avatar-ui[name]`, `grid-ui[cols]`, `card-ui [slot=meta]`, etc.) |
+| 5 | Alert flex-row | `alert-ui` with multiple bare `<text-ui>` children (need `<col-ui slot="content">` wrap) |
+| 6 | Missing component CSS / unstyled popover | a `*-ui` tag on the page with no matching stylesheet loaded; an open popover with transparent bg + zero padding |
+| 7 | Console | Every `console.error` + `console.warn` during page load + 800ms settling |
+
+Output: a severity-ranked markdown report at `docs/reports/dogfooding-YYYY-MM-DD.md` under the repo root.
+
+## Run locally
+
+Run from the framework monorepo checkout (the script resolves the repo root from `$ADIA_REPO_ROOT` if set, else the current working directory):
+
+```bash
+# Terminal 1
+npm run dev
+
+# Terminal 2 (S = ${CLAUDE_PLUGIN_ROOT}/skills/adia-ui-dogfood/scripts/analyze.mjs)
+node "$S"                       # full sweep
+node "$S" --filter chart-legend # one page
+node "$S" --port 5174           # custom port
+node "$S" --out /tmp/r.md       # custom path
+```
+
+Exit code: **1** if any **critical** finding, **0** otherwise. CI-friendly.
+
+## Schedule as a remote agent
+
+The script is the data gatherer. A scheduled agent wraps it with git orchestration: check out the repo, start the dev server, run the script, triage findings, commit/PR. The full agent procedure — env setup, the 3-question triage gate, the ≤5-fix-per-PR blast-radius cap, the verify gate, and the PR shape — is documented in `SKILL.md` (§ Component Dogfood + §Plan-Execute-Verify). Weekly cadence is a reasonable default; pages drift slowly.
+
+Hard rules carried from the source skill:
+
+- Never touch a component's deprecation-handler string when sweeping the attribute it deprecates.
+- Never edit historic MIGRATION GUIDE sections; only the active version section.
+- Don't fix more than 5 critical findings in one PR — leave the rest for follow-up so humans can review fix shape before scaling.
+
+## False positives + tuning
+
+The probes are intentionally narrow. Known places where "transparent fill" is by design (and shouldn't be added to `COLORED_SELECTORS`):
+
+- `tag-ui` without a variant (`muted` / default) — bg is correctly `--a-bg-muted`, not transparent.
+- `button-ui[variant=ghost]` — transparent by design.
+- `[data-swatch]` for `chart-legend-ui[shape=dashed]` — intentionally transparent bg + colored `border-top`. The probe handles this case.
+
+If a finding is a known false positive, add the parent component or selector to the skip-list rather than removing it from `COLORED_SELECTORS` (preserves coverage on the canonical case).
+
+## When to revisit the probe set
+
+- New component ships → add to `STAMP_CONTRACTS` if it has internal stamping logic.
+- New synonym-attribute drift class documented in the attribute-api-migration convention → add to `DRIFT_MARKERS`.
+- A class of bugs slips past the analyzer in a real PR → add a probe for that bug class first, _then_ fix it. Test for the test.