@event4u/agent-config 6.0.0 → 7.0.0

package/dist/agent-src/skills/corpus-grounding/scripts/schema_validator.ts

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+/**
+ * corpus-grounding · schema_validator — manifest contract (interface v1).
+ *
+ * TypeScript twin of `src/skills/corpus-grounding/scripts/schema_validator.py`
+ * (ADR-200 Python→TS migration). Validates a domain's plug-in manifest
+ * (`manifest.json`) against the schema-agnostic contract from ADR-061 §3. Each
+ * domain declares its OWN axes — the validator checks structure + provenance
+ * discipline, never a uniform schema.
+ *
+ * Pure stdlib, no network. Standalone skill script — no `_lib` imports.
+ * Interface contract: SKILL.md § Interface contract.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { pyRepr } from './bm25_search.js';
+
+export const MANIFEST_VERSION = 1;
+
+/** Output sophistication tiers (ADR-061 §3). */
+export const TIERS = ['lookup-only', 'conditional-grounding', 'constraint-emission'] as const;
+
+const _REQUIRED_TOP = ['manifest_version', 'domain', 'tier', 'domains'] as const;
+const _REQUIRED_PROVENANCE = ['owner', 'refresh_cadence', 'upstream'] as const;
+const _REQUIRED_DOMAIN_KEYS = ['file', 'search_cols', 'output_cols'] as const;
+const _REQUIRED_REASONING_KEYS = ['file', 'match_column', 'plan'] as const;
+
+/** A decoded manifest — heterogeneous JSON object. */
+export type Manifest = Record<string, unknown>;
+
+/** Raised when a manifest violates the v1 contract (Python ManifestError). */
+export class ManifestError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'ManifestError';
+    }
+}
+
+// ── Python-parity helpers ───────────────────────────────────────────────────
+
+/** Python truthiness: '', 0, 0.0, [], {}, None, False are falsy. */
+function _pyTruthy(value: unknown): boolean {
+    if (value === null || value === undefined || value === false) {
+        return false;
+    }
+    if (value === true) {
+        return true;
+    }
+    if (typeof value === 'number') {
+        return value !== 0;
+    }
+    if (typeof value === 'string') {
+        return value.length > 0;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    if (typeof value === 'object') {
+        return Object.keys(value).length > 0;
+    }
+    return true;
+}
+
+/** Python `isinstance(x, dict)` — a plain JSON object (not array, not null). */
+function _isDict(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/** Python `repr(x)` for the JSON value shapes a manifest carries. */
+function _repr(value: unknown): string {
+    if (typeof value === 'string') {
+        return pyRepr(value);
+    }
+    if (value === null || value === undefined) {
+        return 'None';
+    }
+    if (value === true) {
+        return 'True';
+    }
+    if (value === false) {
+        return 'False';
+    }
+    if (typeof value === 'number') {
+        // Integral JSON numbers print as ints (repr(2) -> "2").
+        return String(value);
+    }
+    return String(value);
+}
+
+/** Render the TIERS tuple the way Python's f-string interpolates it. */
+function _tiersRepr(): string {
+    return `(${TIERS.map((t) => pyRepr(t)).join(', ')})`;
+}
+
+// ── manifest loading + validation ───────────────────────────────────────────
+
+/** Load + validate a manifest. Raises ManifestError on violation. */
+export function load_manifest(p: string): Manifest {
+    if (!fs.existsSync(p)) {
+        throw new ManifestError(`Manifest not found: ${p}`);
+    }
+    let data: unknown;
+    try {
+        data = JSON.parse(fs.readFileSync(p, 'utf-8'));
+    } catch (exc) {
+        // Python: json.JSONDecodeError → ManifestError(f"... {path}: {exc}").
+        throw new ManifestError(`Manifest is not valid JSON: ${p}: ${_jsonErr(exc)}`);
+    }
+    const errors = validate_manifest(data);
+    if (errors.length > 0) {
+        throw new ManifestError(
+            `Manifest contract violations in ${p}:\n  - ${errors.join('\n  - ')}`,
+        );
+    }
+    const manifest = data as Manifest;
+    // Python: str(path.resolve().parent) — resolve() follows symlinks.
+    manifest._manifest_dir = path.dirname(pyResolve(p));
+    return manifest;
+}
+
+/** Return a list of contract violations (empty = valid). */
+export function validate_manifest(data: unknown): string[] {
+    const errors: string[] = [];
+    if (!_isDict(data)) {
+        return ['manifest must be a JSON object'];
+    }
+
+    for (const key of _REQUIRED_TOP) {
+        if (!(key in data)) {
+            errors.push(`missing required key: ${pyRepr(key)}`);
+        }
+    }
+    if (errors.length > 0) {
+        return errors;
+    }
+
+    if (data.manifest_version !== MANIFEST_VERSION) {
+        errors.push(`manifest_version ${_repr(data.manifest_version)} unsupported (engine speaks v${MANIFEST_VERSION})`);
+    }
+    if (!(TIERS as readonly string[]).includes(data.tier as string)) {
+        errors.push(`tier ${_repr(data.tier)} not in ${_tiersRepr()}`);
+    }
+
+    const domains = data.domains;
+    if (!_isDict(domains) || Object.keys(domains).length === 0) {
+        errors.push('domains must be a non-empty object');
+    } else {
+        for (const name of Object.keys(domains)) {
+            const cfg = domains[name];
+            if (!_isDict(cfg)) {
+                errors.push(`domains.${name} must be an object`);
+                continue;
+            }
+            for (const key of _REQUIRED_DOMAIN_KEYS) {
+                if (!(key in cfg)) {
+                    errors.push(`domains.${name} missing ${pyRepr(key)}`);
+                }
+            }
+            for (const key of ['search_cols', 'output_cols']) {
+                if (key in cfg && (!Array.isArray(cfg[key]) || (cfg[key] as unknown[]).length === 0)) {
+                    errors.push(`domains.${name}.${key} must be a non-empty list`);
+                }
+            }
+        }
+    }
+
+    const default_domain = data.default_domain;
+    if (_pyTruthy(default_domain) && _isDict(domains) && !(String(default_domain) in domains)) {
+        errors.push(`default_domain ${_repr(default_domain)} not in domains`);
+    }
+
+    const detect = data.detect;
+    if (detect !== undefined && detect !== null) {
+        if (!_isDict(detect)) {
+            errors.push('detect must be an object of domain → keyword list');
+        } else if (_isDict(domains)) {
+            for (const name of Object.keys(detect)) {
+                const kws = detect[name];
+                if (!(name in domains) && name !== '_stack') {
+                    errors.push(`detect.${name} references unknown domain`);
+                }
+                if (!Array.isArray(kws)) {
+                    errors.push(`detect.${name} must be a list of keywords`);
+                }
+            }
+        }
+    }
+
+    const reasoning = data.reasoning;
+    if (reasoning !== undefined && reasoning !== null) {
+        if (data.tier === 'lookup-only') {
+            errors.push('reasoning block present but tier is lookup-only');
+        }
+        if (!_isDict(reasoning)) {
+            errors.push('reasoning must be an object');
+        } else {
+            for (const key of _REQUIRED_REASONING_KEYS) {
+                if (!(key in reasoning)) {
+                    errors.push(`reasoning missing ${pyRepr(key)}`);
+                }
+            }
+            const plan = reasoning.plan;
+            if (plan !== undefined && plan !== null) {
+                if (!_isDict(plan)) {
+                    errors.push('reasoning.plan must be an object of domain → max_results');
+                } else if (_isDict(domains)) {
+                    for (const name of Object.keys(plan)) {
+                        if (!(name in domains)) {
+                            errors.push(`reasoning.plan.${name} references unknown domain`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    const stacks = data.stacks;
+    if (stacks !== undefined && stacks !== null) {
+        if (!_isDict(stacks)) {
+            errors.push('stacks must be an object of stack-id → csv path');
+        } else if (!('stack_cols' in data)) {
+            errors.push('stacks present but stack_cols missing');
+        }
+    }
+
+    // Provenance discipline (ADR-061 §6) — a corpus without an owner rots.
+    for (const key of _REQUIRED_PROVENANCE) {
+        if (!(key in data)) {
+            errors.push(`missing provenance key: ${pyRepr(key)} (ADR-061 §6)`);
+        }
+    }
+    const upstream = data.upstream;
+    if (_isDict(upstream)) {
+        for (const key of ['repo', 'sha', 'last_checked']) {
+            if (!(key in upstream)) {
+                errors.push(`upstream missing ${pyRepr(key)}`);
+            }
+        }
+    } else if (upstream !== undefined && upstream !== null) {
+        errors.push('upstream must be an object {repo, sha, last_checked}');
+    }
+
+    const retriever = data.retriever;
+    if (retriever !== undefined && retriever !== null && !['bm25', 'structured', 'hybrid'].includes(retriever as string)) {
+        errors.push(`retriever ${_repr(retriever)} unknown`);
+    }
+
+    return errors;
+}
+
+/**
+ * Resolve a corpus file path relative to the manifest's directory.
+ *
+ * Refuses absolute paths and parent-escapes — corpus files live beside their
+ * manifest by contract (runtime-safety: read-only, local).
+ */
+export function resolve_data_path(manifest: Manifest, relative: string): string {
+    // Python: rel = Path(relative); rel.is_absolute() or ".." in rel.parts.
+    if (path.isAbsolute(relative) || _pathParts(relative).includes('..')) {
+        throw new ManifestError(`corpus path must be manifest-relative: ${pyRepr(relative)}`);
+    }
+    const base = (manifest._manifest_dir as string | undefined) ?? '.';
+    const data_dir = (manifest.data_dir as string | undefined) ?? '.';
+    if (path.isAbsolute(data_dir) || _pathParts(data_dir).includes('..')) {
+        throw new ManifestError(`data_dir must be manifest-relative: ${pyRepr(data_dir)}`);
+    }
+    // Python: (base / dd / rel).resolve() — resolve() follows symlinks.
+    return pyResolve(path.join(base, data_dir, relative));
+}
+
+/** Mirror pathlib Path(p).parts for the relative-path containment check. */
+function _pathParts(p: string): string[] {
+    return p.split(/[\\/]/u).filter((seg) => seg !== '' && seg !== '.');
+}
+
+/**
+ * Mirror pathlib `Path(p).resolve()` (strict=False): make absolute, then
+ * resolve symlinks in the longest existing ancestor and append the
+ * non-existent suffix. On macOS this turns `/var/...` into `/private/var/...`,
+ * matching the Python error / file paths byte-for-byte.
+ */
+function pyResolve(p: string): string {
+    const abs = path.resolve(p);
+    let cur = abs;
+    const suffix: string[] = [];
+    for (;;) {
+        try {
+            const real = fs.realpathSync.native(cur);
+            return suffix.length > 0 ? path.join(real, ...suffix) : real;
+        } catch {
+            const parent = path.dirname(cur);
+            if (parent === cur) {
+                return abs;
+            }
+            suffix.unshift(path.basename(cur));
+            cur = parent;
+        }
+    }
+}
+
+/** Best-effort JSON parse-error text for the ManifestError message. */
+function _jsonErr(exc: unknown): string {
+    if (exc instanceof Error) {
+        return exc.message;
+    }
+    return String(exc);
+}

package/dist/agent-src/skills/database/SKILL.md

@@ -16,10 +16,11 @@ packs:
 
 > **Grounded corpus (Tier-1 consultation):** symptom → index/strategy
 > decisions come grounded — `ground.py search --manifest
-> <skills-root>/database/data/manifest.json "<symptom>"` → root cause,
-> strategy, good-code sketch, anti-pattern, verification probe (EXPLAIN
-> expectation). Corpus: [`data/query-tuning.csv`](data/query-tuning.csv)
-> (PostgreSQL 16 / MySQL 8-derived).
+> <skills-root>/database/data/manifest.json "<symptom>"` returns root
+> cause, strategy, good-code sketch, anti-pattern, and the verification
+> probe (EXPLAIN expectation). Corpus:
+> [`data/query-tuning.csv`](data/query-tuning.csv) (PostgreSQL 16 /
+> MySQL 8-derived).
 
 ## When to use
 
@@ -79,6 +80,27 @@ Re-run `EXPLAIN` and confirm improved plan.
 | Wrong connection | `api_database` vs `customer_database` — verify |
 | Inventing pivot tables | Check if they actually exist |
 
+### Dump to the Evidence Report (source-discovery)
+
+When the task touches schema-driven work, this dump **is** the DB surface of the
+[`source-discovery`](../source-discovery/SKILL.md) discipline. Record it to the
+gitignored session cache with provenance, framework-neutral (MySQL / Postgres /
+SQLite; ORM-agnostic):
+
+- Capture **tables, columns, types, primary/foreign/unique keys, indexes,
+  relations**, and the derived **filter/sort/group-ability** — each with
+  `observed_at` / `source` (`migration:line` or the introspection command).
+- **In-codebase = local, read fresh, no card.** A schema defined by repo
+  migrations / models / ORM / app code (including schemaless stores the app
+  controls — Mongoose / Prisma / Firestore rules) is always resolved locally and
+  re-read each task. The **migration is intended truth, the live DB is actual** —
+  surface any divergence as a drift signal.
+- **Only negative facts graduate to a committed card** (`agents/knowledge/`):
+  "searched, column/table does not exist" after an exhausted search. Positive
+  structure stays in the session Evidence Report, re-read fresh — never a card.
+- A **DB-not-in-codebase** (vendor SaaS / partner / legacy, schema not in the
+  repo and not app-controlled) is the only DB that may be card-worthy.
+
 ## Conventions
 
 → See guideline `php/database.md` for indexing, transactions, migrations, multi-connection patterns.

package/dist/agent-src/skills/decision-record/SKILL.md

@@ -1,7 +1,7 @@
 ---
 model_tier: high
 name: decision-record
-description: "Use when locking a trade-off, structuring an ADR draft, or wiring supersession chains — frames options · trade-offs · consequences before the file is written by `adr-create`."
+description: "Use when choosing between alternatives with trade-offs — X-or-Y decisions (pattern vs pattern, strategy vs strategy) — frames options · trade-offs · consequences; ADR draft via `adr-create`."
 status: active
 tier: senior
 domain: process

package/dist/agent-src/skills/decision-record/evals/triggers.json

@@ -0,0 +1,17 @@
+{
+  "skill": "decision-record",
+  "last_eval": "2026-06-16",
+  "description": "5 should-trigger + 5 should-not-trigger. Seeded from the RDP `decision` discipline rows in tests/reasoning-layer-eval/trigger-fixtures.json (choice among alternatives with real tradeoffs -> decision ledger; escalate to ADR only when cross-task/structural). Should-not covers tasks with no alternatives to weigh (mechanical / single-path).",
+  "queries": [
+    { "q": "should we use the Action pattern or a Service class for this workflow?", "trigger": true },
+    { "q": "should we adopt Redis or Postgres for the rate-limiter store? weigh the tradeoffs", "trigger": true },
+    { "q": "pick a migration strategy for the column rename: expand-contract or big-bang", "trigger": true },
+    { "q": "do we put authorization in middleware or a policy layer here?", "trigger": true },
+    { "q": "choose between optimistic and pessimistic locking for the checkout flow", "trigger": true },
+    { "q": "use the existing UserRepository to load the user", "trigger": false },
+    { "q": "add a created_at timestamp column to the orders table", "trigger": false },
+    { "q": "rename the variable usr to user in this function", "trigger": false },
+    { "q": "import the logger and log the request id", "trigger": false },
+    { "q": "format this file with the project formatter", "trigger": false }
+  ]
+}

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

@@ -0,0 +1,179 @@
+---
+model_tier: high
+name: decision-review
+description: "Use to audit a past architectural decision — did the chosen option hold up, what assumptions drifted, should the ADR be superseded? Backward review only; does not lock new choices."
+source: package
+domain: process
+workspaces:
+  - engineering
+packs:
+  - analysis-workbench
+lifecycle: active
+trust:
+  level: professional
+  confidence: medium
+  human_review_required: false
+install:
+  default: false
+  removable: true
+---
+
+# decision-review
+
+> Audit a past architectural decision: restate what was chosen and why,
+> compare the original assumptions against reality now, and produce a
+> verdict (still valid / needs amendment / superseded). Ends with a
+> `historical-patterns` memory candidate per the
+> [Analysis Memory Loop](../../../docs/contracts/analysis-memory-loop.md).
+>
+> **Direction:** backward (did it hold?) not forward (which option?).
+> For forward flow, use [`decision-record`](../decision-record/SKILL.md).
+> For filing the ADR file, use [`adr-create`](../adr-create/SKILL.md).
+
+## When to use
+
+- Revisiting a past architectural decision: "Did ADR-042 still make
+  sense given what we learned?"
+- A prior ADR is being cited as precedent and its validity should be
+  checked before relying on it.
+- A post-mortem or retrospective surfaces that an earlier choice may
+  have contributed to problems.
+- Preparation for a supersession: confirm the old decision actually
+  needs replacing before writing a new ADR.
+
+Do NOT use when:
+
+- Making or locking a **new** decision — use
+  [`decision-record`](../decision-record/SKILL.md) (which builds the
+  options matrix and locks the choice).
+- The ask is to file or number the ADR file — use
+  [`adr-create`](../adr-create/SKILL.md).
+- No prior decision or ADR exists to review — nothing to audit.
+
+## Procedure
+
+### 1. Locate and inspect the decision
+
+Identify the ADR in `docs/decisions/` (flat, `ADR-NNN-<slug>.md`) or
+`docs/adrs/<area>/` (per-area, `NNNN-<slug>.md`), or a logged
+decision in `agents/decisions/`. If the user named the decision
+informally, check the index for the slug before reading. Read the
+full file before proceeding.
+
+### 2. Restate: what was decided and why
+
+Extract and restate in your own words:
+
+- **Chosen option** — what was picked.
+- **Context then** — the forcing function that made the decision
+  necessary.
+- **Assumptions** — the explicit and implicit priors the decision
+  rested on (load, team size, vendor stability, regulatory state,
+  tech maturity, cost, etc.).
+- **Alternatives rejected** — why each runner-up lost.
+
+This restatement is the baseline. Later steps compare against it.
+
+### 3. Compare to reality now
+
+For each assumption identified in step 2, classify:
+
+| Assumption | Status | Evidence |
+|---|---|---|
+| *e.g. "vendor X is stable"* | held / broke / unknown | *e.g. "vendor deprecated API in v3"* |
+
+Also list **new information** that did not exist when the decision
+was made (new tooling, changed requirements, post-mortem learnings,
+usage data).
+
+Hindsight discipline: judge each assumption against the **information
+available at the time it was made**, not against the outcome alone.
+A decision can be correct given the information then and still need
+revision now.
+
+### 4. Verdict
+
+One of three:
+
+- **Still valid** — assumptions largely held; no amendment needed.
+  Document the validation date so future reviewers know it was checked.
+- **Needs amendment** — core decision stands but one or more
+  consequences or constraints must be updated. Recommend the specific
+  amendment and suggest filing a narrow ADR or addendum.
+- **Superseded** — the chosen option no longer serves the original
+  goal or a new forcing function invalidates it. Name the successor
+  option. Recommend handing off to
+  [`decision-record`](../decision-record/SKILL.md) (to lock the new
+  choice) then [`adr-create`](../adr-create/SKILL.md) (to file the
+  superseding ADR with `supersedes: ADR-NNN`).
+
+### 5. Memory write-back (dedup-first)
+
+Before drafting a new candidate, call `retrieve()` over the same
+key-space (decision area, affected paths):
+
+- **Match found** — propose a `frequency` / `supersedes` **update**
+  to the existing entry. Do not create a duplicate.
+- **No match** — draft a new `historical-patterns` candidate per the
+  [Analysis Memory Loop § 1](../../../docs/contracts/analysis-memory-loop.md):
+
+```jsonc
+{
+  "type": "historical-patterns",
+  "summary": "<one-line pattern: what held or broke>",
+  "evidence_paths": ["docs/decisions/ADR-NNN-<slug>.md"],
+  "decision_surface": ["<area1>", "<area2>"],
+  "last_validated": "YYYY-MM-DD",
+  "review_after_days": 90,
+  "applicable_scope": "project"
+}
+```
+
+Surface the draft to the user via `/memory propose`. Never
+auto-promote. If the candidate fails the admission gate (< 2
+distinct evidence paths AND < 3 future decisions in
+`decision_surface`), surface the gap and suggest deferring or
+strengthening evidence.
+
+## Output
+
+1. **Decision restatement** — chosen option, context then, assumptions, alternatives rejected.
+2. **Assumption-drift table** — each assumption: held / broke / unknown, with evidence.
+3. **New information** not available at decision time.
+4. **Verdict** — still valid / needs amendment / superseded — with rationale.
+5. *(optional)* **Memory candidate** — `historical-patterns` draft or update proposal.
+
+## Do NOT
+
+- Re-litigate a decision that the verdict confirms is still valid.
+  Acknowledge it, note the validation date, stop.
+- Duplicate [`decision-record`](../decision-record/SKILL.md)'s options
+  matrix and trade-off table — this skill reads the old matrix; it does
+  not rebuild one unless the verdict is "superseded" and a new decision
+  process is needed.
+- Auto-promote memory candidates — the human drives promotion per the
+  [Analysis Memory Loop](../../../docs/contracts/analysis-memory-loop.md).
+- Issue a "superseded" verdict without naming the successor option or
+  recommending the forward path to `decision-record` + `adr-create`.
+
+## Gotchas
+
+- **Backward vs forward:** `decision-review` asks "did the chosen
+  option hold up?" — `decision-record` asks "which option should we
+  pick?" Conflating them produces a partial analysis: either a
+  verdict without a replacement plan, or a replacement plan without
+  understanding what broke.
+- **Hindsight bias:** a decision made with the information available
+  then can be correct even if the outcome was poor. State what was
+  known at the time; avoid framing a correct past decision as wrong
+  because newer facts exist.
+- **Stale memory entries:** if `retrieve()` returns entries in
+  `skipped` (stale — age > `review_after_days`), surface them to
+  the user; do not silently use stale entries as if they were current.
+
+## See also
+
+- [`decision-record`](../decision-record/SKILL.md) — forward flow: lock a new choice.
+- [`adr-create`](../adr-create/SKILL.md) — file the ADR after a decision is locked.
+- [`blameless-post-mortem`](../blameless-post-mortem/SKILL.md) — incident review; may hand off to decision-review when a prior architectural choice is implicated.
+- [`docs/contracts/analysis-memory-loop.md`](../../../docs/contracts/analysis-memory-loop.md) — produce → propose → promote → retrieve contract.

package/dist/agent-src/skills/defense-in-depth/SKILL.md

@@ -152,6 +152,6 @@ BEFORE adding the 5th guard:
 
 ## Provenance
 
-- Adopted from: `Microck/ordinary-claude-skills@8f5c83174f7aa683b4ddc7433150471983b93131:skills_all/defense-in-depth/SKILL.md` (MIT, © 2025 Microck).
+- Adopted from: an external reference (MIT, © 2025 an external reference).
 - Provenance registry: `agents/settings/contexts/skills-provenance.yml` (entry: `defense-in-depth`).
 - Iron-Law floor: `non-destructive-by-default`, `verify-before-complete`, `skill-quality`.

package/dist/agent-src/skills/description-assist/SKILL.md

@@ -126,7 +126,7 @@ Only after the user picks:
 
 * Edit the frontmatter in `.agent-src.uncondensed/{kind}/{name}.{md,SKILL.md}`.
 * Re-copy / re-sync as the target artifact's writing skill prescribes.
-* Run `python3 scripts/skill_linter.py {path}` — must report 0 FAIL.
+* Run `./scripts-run src/scripts/skill_linter {path}` — must report 0 FAIL.
 * Report the diff and exit.
 
 ### 6. Max two rounds

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

@@ -82,7 +82,7 @@ Provenance + licenses: [`ATTRIBUTION.md`](ATTRIBUTION.md); manifest:
 ### Font fallback (no google-fonts index — by design)
 
 The 745 KB Google-Fonts index was rejected (ADR-061 §8): it duplicates a
-public API. When a requested font is outside `typography.csv`'s 73
+public API. When a requested font is outside `font-pairings-reference.csv`'s 73
 pairings: query `https://fonts.google.com/specimen/<Family>` (or the
 `webfonts` API) for metadata, OR propose the nearest curated pairing and
 say why. Never invent pairing metadata.

package/dist/agent-src/skills/design-intelligence/data/manifest.json

@@ -1,4 +1,26 @@
 {
+  "upstream": {
+    "sha": "b7e3af80f6e331f6fb456667b82b12cade7c9d35",
+    "repo": "https://github.com/nextlevelbuilder/ui-ux-pro-max-skill",
+    "last_checked": "2026-06-07",
+    "last_eval": {
+      "date": "2026-06-16",
+      "model": "claude-sonnet-4-5",
+      "router": "anthropic",
+      "sha_at_eval": "b7e3af80f6e331f6fb456667b82b12cade7c9d35",
+      "precision": 1,
+      "recall": 1,
+      "true_positive": 5,
+      "false_positive": 0,
+      "false_negative": 0,
+      "true_negative": 5,
+      "floor": {
+        "min_precision": 0.8,
+        "min_recall": 1
+      },
+      "passed": true
+    }
+  },
   "manifest_version": 1,
   "domain": "frontend-design",
   "tier": "conditional-grounding",
@@ -149,7 +171,7 @@
       "max_results": 3
     },
     "typography": {
-      "file": "typography.csv",
+      "file": "font-pairings-reference.csv",
       "search_cols": [
         "Font Pairing Name",
         "Category",
@@ -454,11 +476,6 @@
   "default_category": "General",
   "owner": "package-maintainer",
   "refresh_cadence": "quarterly",
-  "upstream": {
-    "repo": "https://github.com/nextlevelbuilder/ui-ux-pro-max-skill",
-    "sha": "b7e3af80f6e331f6fb456667b82b12cade7c9d35",
-    "last_checked": "2026-06-07"
-  },
   "stacks": {
     "react": "stacks/react.csv",
     "nextjs": "stacks/nextjs.csv",

package/dist/agent-src/skills/design-intelligence/evals/triggers.json

@@ -1,5 +1,6 @@
 {
   "skill": "design-intelligence",
+  "last_eval": "2026-06-16",
   "description": "5 should-trigger + 5 should-not-trigger queries. Should-trigger covers the ui-design-brief rebound + selection questions; should-not-trigger covers audit, implementation, a11y-method, and token-authoring neighbors.",
   "queries": [
     {"q": "which design style fits a luxury e-commerce shop?", "trigger": true},

package/dist/agent-src/skills/design-tokens/evals/triggers.json

@@ -1,5 +1,6 @@
 {
   "skill": "design-tokens",
+  "last_eval": "2026-06-16",
   "description": "5 should-trigger + 5 should-not-trigger queries. Should-trigger covers token authoring, generation, and discipline linting; should-not-trigger covers value selection, Tailwind usage discipline, and component work.",
   "queries": [
     {"q": "set up a design token system with light and dark mode", "trigger": true},