@event4u/agent-config 7.0.2 → 7.2.0

package/dist/agent-src/scripts/archive_completed_roadmaps.ts

@@ -140,14 +140,26 @@ function _inbound_ref_rewrite(
     old_rel: string,
     new_rel: string,
     dry_run: boolean,
+    tracked = true,
 ): string[] {
-    const grep = _run(['git', 'grep', '-l', '--', old_rel], root);
     const changed: string[] = [];
-    if (grep.returncode !== 0) {
-        // 1 = no matches, fine
-        return changed;
+    // Tracked repo → `git grep` (fast, index-aware). Untracked fallback (gap A)
+    // → walk the filesystem, since `git grep` only sees committed content and
+    // would miss every inbound ref in a pre-first-commit consumer.
+    let candidates: string[];
+    if (tracked) {
+        const grep = _run(['git', 'grep', '-l', '--', old_rel], root);
+        if (grep.returncode === 1) {
+            return changed; // no matches
+        }
+        candidates =
+            grep.returncode === 0
+                ? _splitlines(grep.stdout).map((l) => l.trim())
+                : _fs_grep_files(root, old_rel); // git grep unusable → fs walk
+    } else {
+        candidates = _fs_grep_files(root, old_rel);
     }
-    for (const line of _splitlines(grep.stdout)) {
+    for (const line of candidates) {
         const rel = line.trim();
         if (!rel || rel === old_rel) {
             // skip the roadmap file itself
@@ -176,14 +188,86 @@ function _replaceAll(text: string, oldStr: string, newStr: string): string {
     return text.split(oldStr).join(newStr);
 }
 
-function _git_mv(root: string, src_rel: string, dst_rel: string, dry_run: boolean): boolean {
+interface MoveResult {
+    /** the move (or dry-run no-op) succeeded */
+    ok: boolean;
+    /** the move went through `git mv` (tracked); false → plain filesystem
+     *  rename was used because the repo has no commits / the file is untracked.
+     *  The caller rewrites inbound refs on the filesystem (not via `git add`)
+     *  when this is false. */
+    tracked: boolean;
+}
+
+/**
+ * Move `src_rel` → `dst_rel`, preferring `git mv`.
+ *
+ * Untracked-safe (road-to-roadmap-archival-robustness, gap A): a consumer that
+ * closed a roadmap in a pre-first-commit / untracked working tree cannot use
+ * `git mv` (it errors). Instead of printing `git mv failed` and leaving the
+ * completed roadmap to rot in the active tree, fall back to a plain
+ * `fs.renameSync`. The TS-only enhancement post-dates the deleted Python twin
+ * (ADR-200), so there is no byte-parity obligation on this failure path.
+ */
+function _git_mv(root: string, src_rel: string, dst_rel: string, dry_run: boolean): MoveResult {
     const dst = path.join(root, dst_rel);
-    if (!dry_run) {
-        fs.mkdirSync(path.dirname(dst), { recursive: true });
-        const cp = _run(['git', 'mv', src_rel, dst_rel], root);
-        return cp.returncode === 0;
+    if (dry_run) {
+        return { ok: true, tracked: true };
+    }
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    const cp = _run(['git', 'mv', src_rel, dst_rel], root);
+    if (cp.returncode === 0) {
+        return { ok: true, tracked: true };
+    }
+    // Fallback: untracked file or a repo with no commits — plain rename.
+    try {
+        fs.renameSync(path.join(root, src_rel), dst);
+        return { ok: true, tracked: false };
+    } catch {
+        return { ok: false, tracked: false };
     }
-    return true;
+}
+
+/**
+ * Repo-relative paths of files containing `needle`, by walking the filesystem.
+ *
+ * The untracked fallback for `_inbound_ref_rewrite`: `git grep` only sees
+ * tracked content, so in a pre-first-commit consumer it misses every inbound
+ * reference. Walk the tree (skipping `.git` / `node_modules` and obvious binary
+ * trees), read text files, and match the literal path. Bounded by skipping the
+ * heavy dirs; an untracked consumer's tree is small.
+ */
+function _fs_grep_files(root: string, needle: string): string[] {
+    const SKIP = new Set(['.git', 'node_modules', '.augment', 'dist']);
+    const hits: string[] = [];
+    const walk = (dirAbs: string): void => {
+        let entries: fs.Dirent[];
+        try {
+            entries = fs.readdirSync(dirAbs, { withFileTypes: true });
+        } catch {
+            return;
+        }
+        for (const e of entries) {
+            if (e.name.startsWith('.git') || SKIP.has(e.name)) {
+                continue;
+            }
+            const abs = path.join(dirAbs, e.name);
+            if (e.isDirectory()) {
+                walk(abs);
+            } else if (e.isFile() && /\.(md|json|ya?ml|ts|js|txt)$/.test(e.name)) {
+                let text: string;
+                try {
+                    text = fs.readFileSync(abs, { encoding: 'utf-8' });
+                } catch {
+                    continue;
+                }
+                if (text.includes(needle)) {
+                    hits.push(path.relative(root, abs).split(path.sep).join('/'));
+                }
+            }
+        }
+    };
+    walk(root);
+    return hits;
 }
 
 interface ArchiveRecord {
@@ -222,12 +306,15 @@ function archive_completed(
             continue; // complete, but not this branch's work
         }
         const new_rel = `agents/roadmaps/archive/${stats.rel}`;
-        if (!_git_mv(root, old_rel, new_rel, dry_run)) {
-            process.stderr.write(`  ⚠️  git mv failed for ${old_rel}\n`);
+        const mv = _git_mv(root, old_rel, new_rel, dry_run);
+        if (!mv.ok) {
+            process.stderr.write(`  ⚠️  could not archive ${old_rel} (mv failed)\n`);
             continue;
         }
-        const refs = _inbound_ref_rewrite(root, old_rel, new_rel, dry_run);
-        if (!dry_run && refs.length) {
+        const refs = _inbound_ref_rewrite(root, old_rel, new_rel, dry_run, mv.tracked);
+        // Stage rewritten refs only in a tracked repo; an untracked consumer's
+        // files are not in the index, so the filesystem rewrite is the whole job.
+        if (!dry_run && refs.length && mv.tracked) {
             _run(['git', 'add', '--', ...refs], root);
         }
         archived.push({ roadmap: old_rel, archived_to: new_rel, refs_migrated: refs });

package/dist/agent-src/scripts/update_roadmap_progress.ts

@@ -520,9 +520,15 @@ function render(roadmaps: RoadmapStats[], bundles: Bundle[] | null = null): stri
         ' · [roadmaps/](roadmaps/) · [archive/](roadmaps/archive/) · ' +
         '[skipped/](roadmaps/skipped/) · [later/](roadmaps/later/)\n';
     lines.push(
-        '> Auto-generated by `.augment/scripts/update_roadmap_progress.ts`. ' +
-            'Do not edit — regenerated on every roadmap-create, -execute, or ' +
-            'completion change (last-modified timestamp lives in git history).\n>\n' +
+        // Honest provenance (road-to-roadmap-archival-robustness, gap C): name a
+        // regen path that exists in EVERY install, not a hardcoded
+        // `.augment/scripts/...` that a script-less / non-Augment consumer does
+        // not have. `task roadmap-progress` covers Taskfile projects; the bare
+        // script name covers the rest.
+        '> Auto-generated — do not edit. Regenerate with `task roadmap-progress` ' +
+            'or by running the `update_roadmap_progress` script for your install; ' +
+            'rewritten on every roadmap create / execute / completion change ' +
+            '(timestamp lives in git history).\n>\n' +
             header_meta,
     );
     lines.push('## Overall\n');
@@ -568,6 +574,27 @@ function render(roadmaps: RoadmapStats[], bundles: Bundle[] | null = null): stri
         }
         lines.push('');
     }
+    const unarchived = unarchived_complete(roadmaps);
+    if (unarchived.length) {
+        // Non-CI backstop (road-to-roadmap-archival-robustness, gap C): a
+        // persistent dashboard banner makes "completed but unarchived" visible
+        // without the CI `--check` gate — the consumer sees it on every regen.
+        lines.push('## ✅ Completed — pending archival\n');
+        lines.push(
+            'These roadmaps are **complete** (`count_open == 0`, ' +
+                '`count_deferred == 0`) but still sit in the active tree. They ' +
+                'should be in `agents/roadmaps/archive/`. Run the archival sweep ' +
+                '`archive_completed_roadmaps --all` (untracked-safe), or follow the ' +
+                'manual fallback documented in the `roadmap-management` skill, then ' +
+                'regenerate this dashboard.\n',
+        );
+        lines.push('| Roadmap | Done | Total |');
+        lines.push('|---|---:|---:|');
+        for (const r of unarchived) {
+            lines.push(`| [${r.rel}](roadmaps/${r.rel}) | ${r.done} | ${r.total_active} |`);
+        }
+        lines.push('');
+    }
     if (roadmaps.length === 0) {
         lines.push('_No open roadmaps._\n');
         return lines.join('\n') + '\n';

package/dist/agent-src/skills/accessibility-auditor/SKILL.md

@@ -9,6 +9,7 @@ workspaces:
   - engineering
 packs:
   - engineering-base
+token_budget_class: rich
 ---
 
 # accessibility-auditor
@@ -53,11 +54,12 @@ gets a verdict in step 5; missing one is a coverage failure.
 **Perceivable** — text alternatives for non-text (`alt`, `aria-label`),
 contrast ≥ 4.5:1 for body / 3:1 for large or UI components, no
 colour-only state ("error in red" must also be iconic or text).
-Grounded reference for palette + chart verdicts: corpus WCAG-adjusted
-token sets (`--domain color`), chart a11y grades + colorblind fallbacks
-(`--domain chart`), mobile touch/a11y rules (`--domain web`, 44pt) via
-[`design-intelligence`](../design-intelligence/SKILL.md) — cite the corpus
-row; WCAG 2.2 AA *method* stays this skill's checklists.
+Grounded reference for palette + chart verdicts: the adopted corpus's
+WCAG-adjusted token sets (`--domain color`), chart a11y grades +
+colorblind fallbacks (`--domain chart`), and mobile touch/a11y rules
+(`--domain web`, 44pt targets) via
+[`design-intelligence`](../design-intelligence/SKILL.md) — cite the
+corpus row; the WCAG 2.2 AA *method* stays this skill's own checklists.
 Widget-pattern selection (dialog, combobox, tabs, toast, table, form
 errors, drag-reorder …) grounds in the ARIA-APG corpus:
 `ground.py search --manifest
@@ -145,3 +147,16 @@ Top 3 fixes:  <ordered by user impact>
   jurisdictions.
 - Do NOT close a finding by adjusting the test instead of the UI;
   the user's experience is the ground truth, not the test report.
+
+## Why this skill is rich
+
+WCAG 2.2 AA compliance is non-negotiable detail — each success criterion
+has a specific testable condition, failure mode, and remediation path.
+The skill carries the full WCAG criterion matrix with concrete test
+procedures (not just "check contrast"), keyboard-navigation patterns
+(roving tabindex, trap management, escape-key handling), ARIA role/
+property/state tables, and screen-reader-specific edge cases per
+assistive technology. Condensing to "check contrast and add aria-labels"
+loses the test procedures that turn a vague finding into a reproducible
+failure with a specific remedy. Accessibility bugs that are described
+vaguely cannot be verified as fixed.

package/dist/agent-src/skills/ai-council/SKILL.md

@@ -35,7 +35,34 @@ Do NOT use when:
 * The artefact contains secrets that cannot be redacted with the
   bundler's pattern set → ask the user before sending.
 * The user has not configured any council member → state that and stop;
-  do not silently fall back to anything.
+  do not silently fall back to anything. **But "not configured" is
+  decided by the CLI, never by the project tree** — see the rule below.
+
+## Configuration is ALWAYS user-global
+
+```
+THE COUNCIL CONFIG IS ALWAYS USER-GLOBAL. NEVER SEARCH THE PROJECT FOR IT.
+THE ABSENCE OF A COUNCIL FILE IN A PROJECT SAYS NOTHING ABOUT WHETHER
+THE COUNCIL IS CONFIGURED. ONLY THE CLI / RESOLVER DECIDES THAT.
+```
+
+Council config lives at one place only:
+`~/.event4u/agent-config/settings/.ai-council.yml` (per
+[ADR-104](../../../docs/decisions/ADR-104-ai-council-config-global-only.md),
+superseding ADR-093). Configured **once per developer**; works in **every**
+project, worktree, and CWD — including consumer repos carrying none of this
+package's internals.
+
+Before claiming the council unavailable, run the CLI (`council:estimate`) and
+read its exit code + message. **Never** conclude "council not configured in
+this project" from missing project files: `scripts/ai_council` (package-internal,
+absent from every consumer repo), `.agent-settings.yml` (legacy block removed in
+ADR-093), or a project-local `.ai-council.yml` (never read — ADR-104). Eyeballing
+the project for these, then deciding solo instead of running the resolver, is the
+canonical failure ADR-104 stops.
+
+Only escape from user-global: `$AI_COUNCIL_CONFIG`, an explicit absolute path
+for tests / power users — still not a project search.
 
 ## When NOT to invoke — necessity self-check
 

package/dist/agent-src/skills/blade-ui/SKILL.md

@@ -133,6 +133,15 @@ current state on the next polish round.
 - Do NOT put business logic in Blade templates — use Livewire or view composers.
 - Do NOT use inline styles — use Tailwind utility classes.
 
+## Anti-slop
+
+Before shipping a Blade view, pull
+[`docs/guidelines/design-antipatterns.md`](../../../docs/guidelines/design-antipatterns.md)
+and scan Visual / Typography / Layout — the Blade markup is where side-stripe
+accents (V1), icon-tile feature cards (T3), and the centered-hero + 3-column
+template (L1/L2) concretely land. Stack-specific Tailwind class/hex bans live in
+[`tailwind-engineer`](../tailwind-engineer/SKILL.md).
+
 ## Auto-trigger keywords
 
 - Blade template

package/dist/agent-src/skills/contract-review/SKILL.md

@@ -0,0 +1,125 @@
+---
+model_tier: inherit
+name: contract-review
+description: "Use when reviewing a contract clause-by-clause from your party's side — buyer/seller/vendor/licensee. Triggers on 'review this contract', 'redline this MSA', 'is this clause a problem'."
+status: active
+tier: senior
+council_depth: deep
+domain: process
+recommended_for_user_types: [legal]
+workspaces:
+  - legal-review-prep
+packs:
+  - legal-review-prep
+trust:
+  level: advisory
+install:
+  removable: true
+---
+
+# contract-review
+
+## When to use
+
+- A contract draft (MSA / SOW / vendor / licence / partner agreement) needs a **position-aware, clause-by-clause** review — the user states their party role and the review adjusts to what *their* side should fear.
+- An existing contract is being negotiated and each load-bearing clause needs a GREEN / YELLOW / RED severity call plus a specific redline *suggestion* (not an edit).
+- A non-lawyer needs the analysis that prepares the attorney conversation: what each clause binds, where the risk concentrates, what to ask for.
+
+Do NOT use to **issue a legal opinion** (the licensed attorney decides — see `legal-safety-floor`), for the non-lawyer cognition layer that precedes a structured review (route to [`contracts-cognition`](../contracts-cognition/SKILL.md)), or for DPA / data-processing review (route to [`dpa-review`](../dpa-review/SKILL.md)).
+
+## Procedure
+
+### Step 0: Fix the party role and the jurisdiction
+
+1. The user states their **party role**: `buyer` / `seller` / `vendor` / `licensee` / `licensor` (or the contract's own term). The review is asymmetric — a cap that protects the seller exposes the buyer. If the role is missing, STOP and ask once. Do not infer from prose.
+2. Read the governing-law clause. If the contract is governed by a jurisdiction **outside EU/DE scope**, REFUSE the review: *"This is governed by <jurisdiction> — outside this pack's EU/DE scope. Consult licensed local counsel."* Never a stale guess for an out-of-scope jurisdiction.
+3. Tag the output with `Jurisdiction: EU` or `Jurisdiction: DE` — the one you reasoned under.
+
+### Step 1: Establish the position profile
+
+Read thresholds and acceptable positions from the `legal-practice-profile` (sibling skill). The skill ships **no default legal positions** — caps, notice windows, indemnity shapes, and acceptable-risk bands are the profile's, not the agent's.
+
+Until the profile is configured, emit explicit `[configure]` placeholders (e.g. *"indemnity cap acceptable band: [configure]"*) and say plainly that no position is being asserted.
+
+### Step 2: Map clauses to the risk taxonomy
+
+Walk the contract clause by clause. Classify each against a public clause-risk reference (a CUAD-style 41-category taxonomy — named as a reference; **no dataset is vendored**): liability/indemnity, term/renewal/termination, IP/licence grant, confidentiality, data, governing law, audit, exclusivity/MFN, change-of-control, payment, warranty, assignment, and the rest.
+
+For each clause, read it **from the user's party role**: *"under what scenario does this fire, and who pays when it does?"*
+
+### Step 3: Assign GREEN / YELLOW / RED per clause
+
+- **GREEN** — standard, symmetric, within (or absent-of) the profile band. A triage signal, not a clearance.
+- **YELLOW** — acceptable only with a named change, or carries role-specific risk worth surfacing.
+- **RED** — unbounded, one-way against the user's role, or contradicts a `[configure]`/profile band. Leads the redline list.
+
+### Step 4: Produce redline SUGGESTIONS (never edits)
+
+For each YELLOW/RED clause, write a specific *suggested* ask — the cap to add, the carve-out to remove, the notice window to extend — phrased as a proposal for counsel and the negotiation lead, **not** an applied edit to the document.
+
+### Step 5: Surface the open questions, refuse the final call
+
+List what the licensed attorney must decide (which clauses are counsel-led vs commercial) and the open questions the review could not resolve. Do **not** issue a sign / don't-sign verdict.
+
+### Step 6: Emit the review artifacts
+
+Produce `review-frame.md` and `redline-suggestions.md` (see Output). Every artifact carries the `Jurisdiction:` tag and the work-product line below.
+
+> ⚠️ Attorney review required on material use. This is a draft for a licensed attorney, not legal advice and not a legal conclusion.
+
+## Related Skills
+
+**WHEN to use this**
+
+- Position-aware clause-by-clause review of a contract within EU/DE scope.
+- The user knows their party role and wants per-clause severity + redline suggestions.
+
+**WHEN NOT to use this**
+
+- Mutual / one-way NDA quick read — route to [`nda-triage`](../nda-triage/SKILL.md).
+- DPA / Art. 28 / data-processing review — route to [`dpa-review`](../dpa-review/SKILL.md).
+- "Is this even a legal problem / what is this document" — route to [`legal-intake-triage`](../legal-intake-triage/SKILL.md).
+- Non-lawyer cognition that precedes a structured review — route to [`contracts-cognition`](../contracts-cognition/SKILL.md).
+
+Obeys `legal-safety-floor` (rule): no final legal call, mandatory work-product line, EU/DE-only hard refusal, machine-checkable `Jurisdiction:` tag.
+
+## When the agent should load this
+
+- "Review this contract from the buyer's side."
+- "Redline this MSA — we're the vendor."
+- "Is this indemnity clause a problem for us?"
+- "Prüf diesen Vertrag aus unserer Sicht durch."
+- "Worauf müssen wir als Lizenznehmer achten?"
+
+## Output
+
+1. **`review-frame.md`** — party role, `Jurisdiction:` tag, position profile read (or `[configure]` placeholders), per-clause table with GREEN/YELLOW/RED severity + risk-taxonomy category + the firing scenario from the user's side. Carries the work-product line.
+2. **`redline-suggestions.md`** — per YELLOW/RED clause, the specific suggested ask (cap / carve-out / notice window), phrased as a proposal for counsel — never an applied edit; plus the open questions and counsel-led vs commercial-led split. Carries the work-product line.
+
+## Gotcha
+
+- The review is **asymmetric**: a GREEN for the seller can be a RED for the buyer. Re-run severity against the stated party role, never against "the contract" in the abstract.
+- Severity is a triage signal, never a clearance — a GREEN clause is not a sign-off, and the agent never issues the sign / don't-sign call.
+- The skill ships **no default positions**. A severity asserted without a profile band or a `[configure]` placeholder is a fabricated legal position — surface the gap, don't fill it.
+- Out-of-scope governing law is a hard refusal, not a best-effort guess — a stale read of a jurisdiction the pack doesn't cover is worse than no read.
+- Suggested redlines are proposals, not edits. Applying changes to the document silently strips the attorney's review gate.
+
+## Do NOT
+
+- Do NOT issue a final legal call (sign / don't-sign / safe / unsafe) — surface analysis + open questions; the licensed attorney decides.
+- Do NOT invent thresholds or acceptable positions — read them from `legal-practice-profile` or emit `[configure]`.
+- Do NOT review a contract governed by an out-of-scope jurisdiction — refuse and route to licensed local counsel.
+- Do NOT emit any artifact without the `Jurisdiction:` tag and the verbatim attorney work-product line in the body.
+- Do NOT apply redlines as edits — emit them as suggestions only.
+
+## Runnable example
+
+Vendor-side review of a customer-drafted MSA, governed by German law.
+
+- Step 0 — party role = `vendor`; governing law = Germany → in scope. `Jurisdiction: DE`.
+- Step 1 — `legal-practice-profile` not yet configured → indemnity-cap band, notice-window floor, and acceptable-liability shape all emitted as `[configure]`; output states no position is asserted.
+- Step 2 — clauses mapped: uncapped IP indemnity (liability/indemnity), 3-year auto-renewal / 90-day notice (term/renewal), MFN buried in pricing schedule (exclusivity/MFN), unilateral audit right (audit).
+- Step 3 — severity from vendor's side: uncapped IP indemnity → **RED**; auto-renewal + short notice → **YELLOW**; MFN → **RED** (forecloses portfolio pricing); audit right → YELLOW.
+- Step 4 — redline suggestions: cap IP indemnity at `[configure]`× ACV with carve-outs; extend notice to `[configure]` days, reduce renewal to 1 year; strike MFN or limit to identical SKU; bound audit frequency + notice.
+- Step 5 — open questions: is the IP-indemnity carve-out scope counsel-led (yes); auto-renewal window is commercial-led. No sign / don't-sign verdict.
+- Step 6 — emit `review-frame.md` + `redline-suggestions.md`, each tagged `Jurisdiction: DE` and carrying the attorney work-product line.

package/dist/agent-src/skills/contract-review/evals/triggers.json

@@ -0,0 +1,17 @@
+{
+    "skill": "contract-review",
+    "last_eval": "2026-06-24",
+    "description": "5 should-trigger + 5 should-not-trigger. Should-trigger covers DE+EN phrasings for position-aware clause-by-clause review of a contract (EU/DE). Should-not-trigger covers near-miss neighbours: NDA triage (nda-triage), DPA review (dpa-review), 'is this a legal problem' triage (legal-intake-triage), and non-legal contract-of-work.",
+    "queries": [
+        { "q": "review this vendor MSA against our position as the buyer", "trigger": true },
+        { "q": "clause-by-clause review of this SaaS subscription agreement with redline suggestions", "trigger": true },
+        { "q": "prüfe diesen Vertrag klauselweise aus unserer Sicht als Lizenznehmer", "trigger": true },
+        { "q": "GREEN/YELLOW/RED review of this services agreement, we're the seller", "trigger": true },
+        { "q": "welche Klauseln in diesem Liefervertrag sind für uns riskant?", "trigger": true },
+        { "q": "is this NDA standard enough to just sign?", "trigger": false },
+        { "q": "review this data processing agreement against GDPR Art. 28", "trigger": false },
+        { "q": "is this even a legal problem or can we proceed?", "trigger": false },
+        { "q": "set up our legal playbook and jurisdiction", "trigger": false },
+        { "q": "review my pull request for code quality", "trigger": false }
+    ]
+}

package/dist/agent-src/skills/dashboard-design/SKILL.md

@@ -23,11 +23,17 @@ Do NOT use when:
 
 ## Procedure: Design a dashboard
 
-Ground chart-type choice in the adopted data-viz corpus, not memory:
-`ground.py search --manifest <skills-root>/design-intelligence/data/manifest.json
---domain chart "<data shape>"` → best chart type, when-NOT-to-use, volume
-threshold, a11y grade + colorblind fallback, library recommendation
-([`design-intelligence`](../design-intelligence/SKILL.md)).
+1. **Inspect the data sources** — Identify which signals already exist (logs, metrics, app queries) and where they live (Grafana / Loki / app DB) before designing a new panel.
+2. **Pick the surface** — Use the decision tables below to choose Grafana, app dashboard, or embed; document audience and refresh cadence.
+3. **Draft the layout** — Sketch panels, choose visualization per signal (RED / USE / Golden Signals), define filters and thresholds.
+   **Ground the chart-type choice** in the adopted data-viz corpus instead
+   of memory: `ground.py search --manifest
+   <skills-root>/design-intelligence/data/manifest.json --domain chart
+   "<data shape>"` returns the best chart type, when-NOT-to-use, data-volume
+   threshold, a11y grade + colorblind fallback, and a library
+   recommendation per row (see
+   [`design-intelligence`](../design-intelligence/SKILL.md)).
+4. **Implement and verify** — Build the dashboard, load realistic data, and confirm every panel answers a named question for the named audience.
 
 | Domain | Technology | Purpose |
 |---|---|---|
@@ -120,6 +126,16 @@ Config required: `allow_embedding = true`, `cookie_samesite = none` (cross-origi
 - Do NOT mix ops metrics with business KPIs on the same dashboard.
 - Do NOT show admin data without tenant scoping.
 
+## Anti-slop
+
+Dashboards have their own signature tell: the **hero-metric template** (giant
+number + small label + a row of stats + gradient) is L1 in
+[`docs/guidelines/design-antipatterns.md`](../../../docs/guidelines/design-antipatterns.md).
+Pull the catalog and check L1–L3 (hero-metric, identical-card grids, monotonous
+spacing) before finalizing the layout — a dashboard is product-mode
+(`docs/guidelines/design-modes.md`): design serves the task, so favour data
+density and earned familiarity over decorative variance.
+
 ## Auto-trigger keywords
 
 - dashboard

package/dist/agent-src/skills/design-intelligence/SKILL.md

@@ -9,6 +9,7 @@ workspaces:
   - engineering
 packs:
   - frontend-design
+token_budget_class: rich
 trust:
   level: professional
 install:
@@ -48,6 +49,80 @@ Provenance + licenses: [`ATTRIBUTION.md`](ATTRIBUTION.md); manifest:
   layout pattern / chart type / icon system fits this product.
 - Stack-idiom lookup before writing UI code (`--stack` axis).
 
+## Cross-task design memory — read DESIGN.md / PRODUCT.md first
+
+Before running the corpus grounding or producing any design brief, check
+the project root for `DESIGN.md` and/or `PRODUCT.md` (written by
+`design-system-capture`). If they exist:
+
+1. Read `DESIGN.md` — apply its captured visual decisions (radius, shadows,
+   motion, spacing) as **project constraints** that take precedence over
+   corpus suggestions. The corpus fills gaps; DESIGN.md overrides.
+2. Read `PRODUCT.md` — note interaction patterns that affect the design
+   (e.g., destructive-action policy, empty-state approach) so the brief
+   is consistent with existing product conventions.
+3. After generating the design brief: if a decision was made that isn't yet
+   in DESIGN.md (e.g., chose a specific shadow for a new elevated surface),
+   flag it for capture: *"Suggest adding to DESIGN.md: elevated surface shadow = …"*
+
+Boundary vs `brand-to-tokens`/`.tokens.json`:
+- `.tokens.json` = primitive definitions (gray-700 = #374151)
+- `DESIGN.md` = usage decisions (elevated surfaces use the gray-700 shadow, 8px radius)
+Both are consumed; DESIGN.md takes precedence for usage questions.
+
+## Register — brand vs product
+
+Determine the design register before grounding (see
+[`docs/guidelines/design-modes.md`](../../../docs/guidelines/design-modes.md)):
+**brand mode** ("the impression IS the product" — marketing, landing, consumer
+first-impression) prioritizes distinctive selection; **product mode** ("design
+serves the task" — dashboard, admin, workflow) prioritizes earned familiarity
+and accessibility. The register changes which corpus selections are appropriate
+(distinctive palette/typography in brand mode; predictable, semantic in product
+mode). State the register in the Design Read line below.
+
+## Design Read — articulate intent before generating
+
+Before producing any design brief or making any style selection, emit one
+line that declares the design read:
+
+```
+Reading this as: <page-kind> for <audience>, <vibe> language, leaning <design-system>.
+```
+
+Examples:
+- `Reading this as: SaaS dashboard for internal ops teams, functional language, leaning Radix/shadcn.`
+- `Reading this as: marketing landing for B2C consumer product, playful editorial, leaning custom tokens.`
+- `Reading this as: admin panel for technical users, dense/utilitarian language, leaning data-grid primitives.`
+
+**If context is incomplete:** state so and proceed exploratory — *"Design context incomplete: no audience defined; proposing exploratory direction, expect revision after audience is clarified."* Do NOT block on missing context; do NOT prompt the user with a gate; state the gap and continue.
+
+**Anti-Default Discipline — first-impulse check:** Before committing to any design direction, verify you are NOT defaulting to:
+- Purple/violet + cyan-on-dark gradient palette (AI color cliché)
+- Centered hero over a dark gradient mesh with a single CTA
+- Three equal-weight feature cards in a grid
+- Inter or Space Grotesk as the uncritical body font choice
+- "Premium consumer" cream/sand background + brass/clay accents
+
+If any of these was the first impulse, name a different direction or explicitly justify why this brief genuinely calls for it.
+
+## Honesty / real-system grounding
+
+When the brief maps to an official design system (Material Design, Fluent,
+Carbon, Polaris, GOV.UK, shadcn, Tailwind UI, Radix, etc.):
+
+1. **Install the real package** — do not hand-recreate its CSS or components.
+   Surface the install command for the project's package manager (the
+   system's official package, e.g. the shadcn CLI or the `@mui/material`
+   distribution) and link the canonical documentation URL.
+2. **Never label an approximation as the official system.** If generating
+   approximate CSS for a system the project does not yet depend on, label it
+   explicitly: *"Approximation of Material Design elevation — not the official
+   `@mui/material` package; install the package for production use."*
+3. **If no official system is relevant:** pick a deliberate creative direction
+   (see Design Read above); never fall back to an unnamed generic aesthetic
+   (per `source-discovery-gate`: real source before guessing).
+
 ## Procedure: Produce a grounded design brief (`ui-design-brief` rebound)
 
 1. **Ground** (one call — engine runs the manifest's plan
@@ -170,6 +245,27 @@ guidance + docs URLs from here instead of memory.
 - Keep queries product-shaped ("fintech dashboard", "luxury e-commerce
   mobile") — the detect map routes generic words to `style`.
 
+## Anti-slop discipline
+
+Before finalizing any design brief, cross-check against
+[`docs/guidelines/design-antipatterns.md`](../../../docs/guidelines/design-antipatterns.md)
+— especially the Color (C1–C5), Typography (T7–T8), and Layout (L1–L2) sections.
+If the grounded corpus selection lands on a pattern in the catalog, either invoke
+the override condition or adjust the selection. Run the AI-slop originality
+self-test (catalog § "The AI-slop originality self-test") on the chosen aesthetic
+direction before emitting `design_confirmed`.
+
+## Why this skill is rich
+
+This skill carries 11 tabular CSVs (161-row UI-reasoning decision map,
+WCAG-adjusted color token sets, 84 styles, 73 font pairings, 25 chart rules, UX/
+react/mobile guidelines) plus 16 prose design-language specs and a 10-category
+pre-delivery checklist. Agents need to see the full corpus to make grounded
+selections — condensing to a summary destroys the evidence trail ("corpus
+row 47 justifies the palette choice") that the skill's output contract requires.
+Compressing the 16 design-language specs into fragments makes the style
+selection unreproducible and audit-unfriendly.
+
 ## Policies
 
 - Upstream MIT + Apache-2.0 obligations: [`ATTRIBUTION.md`](ATTRIBUTION.md).