@event4u/agent-config 6.0.0 → 7.0.0

package/dist/agent-src/skills/brand-audit/SKILL.md

@@ -0,0 +1,67 @@
+---
+model_tier: inherit
+name: brand-audit
+description: "Audit how a brand is currently expressed across touchpoints and flag drift from its defined tokens, voice, and strategy. Use to inventory and critique an existing brand before changing it."
+domain: engineering
+personas:
+  - brand-strategist
+workspaces:
+  - engineering
+packs:
+  - brand
+trust:
+  level: professional
+install:
+  removable: true
+execution:
+  type: manual
+---
+
+# brand-audit
+
+Method skill. Inventories current brand expression across touchpoints and flags drift against defined brand tokens, voice, and strategy. For the UI surface it leans on `existing-ui-audit` rather than re-implementing component inventory. Output is a drift findings list — not a redesign.
+
+## When to use
+
+- Before a rebrand or brand refresh — establish the baseline first.
+- When auditing brand consistency across touchpoints (web, decks, docs, ads, copy).
+- To create an evidence base before running `brand-strategy`.
+- When "is this on-brand?" needs a systematic answer across many assets, not a gut call.
+
+## Procedure
+
+1. **Gather the source of truth.** Collect the consumer brand's defined tokens (palette, type scale, logo rules), voice profile, and strategy doc if they exist. Consumer brand definition is authoritative; corpus defaults are gap-fill only.
+2. **Inventory current expression per touchpoint.** Cover logo usage, colour palette, typography, voice/copy tone, imagery style, and iconography across the relevant surfaces (site, app, decks, marketing, docs).
+3. **UI surface.** Invoke `existing-ui-audit` for UI component inventory. Do not re-implement it here — take its output as an input to this audit.
+4. **Compare observed vs. defined.** For each touchpoint value, check it against the matching token or voice rule.
+5. **Classify each finding.** Three buckets: `on-brand` (matches the defined token), `drift` (observed value diverges from the token), `undefined` (no token exists to audit against — this is a governance gap, not automatically wrong).
+6. **Rank drift findings** by visibility (how prominent the touchpoint is) multiplied by frequency (how often it appears). Surface the top items first.
+7. **Verify completeness.** Confirm every inventoried touchpoint is classified (`on-brand` / `drift` / `undefined`) — the audit is complete only when the classified count equals the inventoried count, and `existing-ui-audit` has run for every in-scope UI surface. Ensure each drift finding cites BOTH the defined value and the observed value; a finding missing either side is not yet verified.
+8. **Output the findings list** (see Output format). Do not redesign or author replacements — hand drift findings to `brand-identity` or `brand-strategy`.
+
+## Output format
+
+1. **Source-of-truth summary** — what brand tokens, voice rules, and strategy exist and where they were found (or "none defined" if absent).
+2. **Drift findings** — table-style list: `touchpoint | defined value | observed value | severity (high/medium/low)`.
+3. **Undefined gaps** — values with no token to check against; listed separately so they can feed a token-creation pass.
+4. **Ranked top drift** — ordered list of the highest-severity drift items to fix first, with a one-line rationale per item.
+
+## Do NOT
+
+- Redesign or author replacement assets — that is `brand-identity` work, not audit work.
+- Re-implement UI component inventory — call `existing-ui-audit` and consume its output.
+- Invent a "correct" value where none is defined — mark the finding `undefined` and surface it as a governance gap.
+- Treat corpus defaults as the consumer's source of truth — consumer brand definition always wins.
+
+## Gotcha
+
+- `undefined` is a real finding. A value with no token to check against is a governance gap that deserves its own section, not a pass.
+- Drift severity is visibility times frequency, not personal taste. A rarely-seen off-palette icon ranks lower than a wrong primary colour used on every page header.
+- Consumer brand tokens outrank any corpus default. If the consumer has defined a token, audit against that; ignore what the corpus suggests.
+
+## See also
+
+- [`existing-ui-audit`](../existing-ui-audit/SKILL.md) — the UI-surface inventory this skill reuses.
+- [`brand-strategy`](../brand-strategy/SKILL.md) — where drift findings feed a refreshed strategy.
+- [`brand-identity`](../brand-identity/SKILL.md) — defines the tokens audited against.
+- [`brand`](../brand/SKILL.md) — the corpus of brand defaults (gap-fill only).

package/dist/agent-src/skills/brand-audit/evals/triggers.json

@@ -0,0 +1,17 @@
+{
+  "skill": "brand-audit",
+  "last_eval": "2026-06-16",
+  "description": "5 should-trigger + 5 should-not-trigger. Should-trigger covers auditing/inventorying current brand expression and flagging drift. Should-not covers near-miss neighbors.",
+  "queries": [
+    {"q": "audit our brand consistency across the site and decks", "trigger": true},
+    {"q": "is our brand applied consistently — find where we drift", "trigger": true},
+    {"q": "inventory how the logo and colours are used today across all touchpoints", "trigger": true},
+    {"q": "baseline our current brand expression before the refresh", "trigger": true},
+    {"q": "where does our copy drift from the brand voice", "trigger": true},
+    {"q": "define a new brand strategy from scratch", "trigger": false, "note": "strategy definition -> brand-strategy"},
+    {"q": "generate a new logo for us", "trigger": false, "note": "generation -> logo-generation"},
+    {"q": "audit just the UI components to find reuse opportunities", "trigger": false, "note": "UI component inventory -> existing-ui-audit"},
+    {"q": "emit our brand tokens as CSS custom properties", "trigger": false, "note": "emission -> brand-to-tokens"},
+    {"q": "validate this single banner asset against the token spec in CI", "trigger": false, "note": "automated validation gate -> brand-consistency rule"}
+  ]
+}

package/dist/agent-src/skills/brand-identity/SKILL.md

@@ -0,0 +1,101 @@
+---
+model_tier: inherit
+name: brand-identity
+description: "Define a brand identity constraint set from a confirmed strategy — colour story, type story, logo direction, imagery direction. Defines the tokens that token emission and asset generation consume."
+domain: engineering
+personas:
+  - design-director
+workspaces:
+  - engineering
+packs:
+  - brand
+trust:
+  level: professional
+install:
+  removable: true
+execution:
+  type: manual
+---
+
+# brand-identity
+
+Grounding + Method skill. Turns a confirmed brand strategy into an identity constraint set: colour story, type story, logo direction, imagery direction. It DEFINES tokens and constraints — it does not render marks. Dependency direction: pack-brand (B) exports constraints; pack-ai-image (A) consumes them. `brand-to-tokens` emits the DTCG token file from these constraints. `logo-generation` and `brand-asset-generation` generate the actual marks from these constraints. Never invert that direction.
+
+## When to use
+
+- After `brand-strategy` is confirmed (archetype, voice, positioning settled).
+- When deriving the colour story, type story, logo direction, or imagery direction for a project.
+- Before running `brand-to-tokens` to emit the DTCG token file.
+- Before handing constraints to `logo-generation` or `brand-asset-generation` in pack-ai-image.
+
+## Procedure
+
+1. **Receive the confirmed strategy** — archetype, voice, positioning, and target sector from `brand-strategy`. Refuse to proceed if strategy is still a draft.
+
+2. **Ground the colour story** via the brand corpus:
+
+```bash
+python3 <skills-root>/corpus-grounding/scripts/ground.py search \
+  --manifest <skills-root>/brand/data/manifest.json \
+  "<archetype + sector>" --domain color --json
+```
+
+   Read `confidence` and `evidence_gap` from the response. Record both verbatim in the output. Derive colour roles (primary, secondary, neutral, accent) and direction (temperature, contrast ratio floor, emotional register).
+
+3. **Ground the type story** via:
+
+```bash
+python3 <skills-root>/corpus-grounding/scripts/ground.py search \
+  --manifest <skills-root>/brand/data/manifest.json \
+  "<archetype + sector>" --domain typography --json
+```
+
+   Output is a pairing-filter + heading/body class labels, not concrete tokens. Hand this filter to `typography-system` for the actual type tokens.
+
+4. **Ground the logo direction** via:
+
+```bash
+python3 <skills-root>/corpus-grounding/scripts/ground.py search \
+  --manifest <skills-root>/brand/data/manifest.json \
+  "<archetype + sector>" --domain logo --json
+```
+
+   Capture mark style, form language, and vector requirement. Note: any mark that the consumer may need in editable form MUST be specified as editable vector (SVG/AI), not raster.
+
+5. **Derive imagery direction** from archetype and sector context: subject matter, mood, composition style, colour treatment, and what to avoid.
+
+6. **Assemble the identity constraint set** — the structured seed for downstream skills. Record confidence and evidence_gap verbatim from all three corpus calls.
+
+7. **Human confirms** the constraint set before any downstream step runs.
+
+8. **Export** — hand off: `brand-to-tokens` receives the colour + type constraints and emits `.tokens.json` (DTCG); `logo-generation` and `brand-asset-generation` receive the logo direction and imagery direction. Direction of flow: B (pack-brand) -> A (pack-ai-image).
+
+## Output format
+
+1. **Colour story** — roles (primary, secondary, neutral, accent) with direction (temperature, contrast floor, register), cited from corpus with confidence score.
+2. **Type story** — heading class and body class derived from the archetype pairing-filter; note that concrete tokens come from `typography-system`, not from this skill.
+3. **Logo direction** — mark style, form language, vector requirement (editable SVG/AI where needed), and any explicit exclusions.
+4. **Imagery direction** — subject matter, mood, composition style, colour treatment, and anti-patterns to avoid.
+5. **Confidence + evidence_gap** — verbatim from all corpus calls; flag any domain where evidence_gap is high before the human confirmation step.
+6. **Handoff note** — which constraints go to `brand-to-tokens` (colour + type) and which go to the generation skills in pack-ai-image (logo direction + imagery direction).
+
+## Do NOT
+
+- Generate the actual marks here — that is `logo-generation` and `brand-asset-generation`.
+- Invert the dependency direction — generation lives in pack-ai-image (A), not in pack-brand (B).
+- Ship a raster as a final logo where the consumer needs an editable vector mark.
+- Override an existing set of brand tokens on a live project without explicit user confirmation.
+
+## Gotcha
+
+- Identity DEFINES constraints; generation CONSUMES them. Keep the B->A direction in every handoff note.
+- A type story is a pairing-filter plus heading/body class labels — the concrete type tokens (scale, weight, line-height) come from `typography-system`, not from this skill.
+- Vector-vs-raster is a real decision for any mark: confirm with the user before recording the logo direction, because raster is irreversible for downstream editing needs.
+
+## See also
+
+- [`brand-strategy`](../brand-strategy/SKILL.md) — supplies the confirmed strategy.
+- [`brand-to-tokens`](../brand-to-tokens/SKILL.md) — emits the DTCG token source of truth.
+- [`typography-system`](../typography-system/SKILL.md) — turns the type story into type tokens.
+- [`logo-generation`](../logo-generation/SKILL.md) — generates marks from this identity (pack-ai-image).
+- [`brand`](../brand/SKILL.md) — the corpus grounded against.

package/dist/agent-src/skills/brand-identity/evals/triggers.json

@@ -0,0 +1,17 @@
+{
+  "skill": "brand-identity",
+  "last_eval": "2026-06-16",
+  "description": "5 should-trigger + 5 should-not-trigger. Should-trigger covers defining the identity constraint set (colour story, type story, logo direction) from a strategy. Should-not covers near-miss neighbors.",
+  "queries": [
+    {"q": "define the colour story for our brand based on this archetype", "trigger": true},
+    {"q": "what type story fits a challenger archetype in the fintech sector", "trigger": true},
+    {"q": "give me a logo direction for our identity — what mark style and form language fits", "trigger": true},
+    {"q": "assemble the brand identity constraint set from our confirmed strategy", "trigger": true},
+    {"q": "what imagery direction should we use for our brand — subject matter, mood, composition", "trigger": true},
+    {"q": "who is our brand for and how should we position it in the market", "trigger": false, "note": "strategy -> brand-strategy"},
+    {"q": "generate the actual logo image for our brand", "trigger": false, "note": "generation -> logo-generation"},
+    {"q": "emit the colour tokens as CSS variables and a DTCG JSON file", "trigger": false, "note": "emission -> brand-to-tokens"},
+    {"q": "pick a font pairing for a modern SaaS product with no brand frame yet", "trigger": false, "note": "style path -> typography-system"},
+    {"q": "check whether this asset is on-brand and consistent with our guidelines", "trigger": false, "note": "validation -> brand-consistency rule"}
+  ]
+}

package/dist/agent-src/skills/brand-strategy/SKILL.md

@@ -0,0 +1,83 @@
+---
+model_tier: inherit
+name: brand-strategy
+description: "Ground a brand strategy from the corpus — archetype, opposable positioning, voice and tone, messaging framework. Use to decide who a brand is for, what it stands for, and how it sounds."
+domain: engineering
+personas:
+  - brand-strategist
+workspaces:
+  - engineering
+packs:
+  - brand
+trust:
+  level: professional
+install:
+  removable: true
+execution:
+  type: manual
+---
+
+# brand-strategy
+
+Grounding skill. Consults the brand corpus to surface archetype, positioning, voice/tone, and messaging constraints. Output is a constraint set the human confirms — never final brand copy — then handed to brand-identity and brand-to-tokens.
+
+## When to use
+
+- Deciding brand archetype, opposable positioning, voice/tone, or messaging framework before any identity work begins.
+- Before invoking brand-identity — the confirmed constraint set is its required input.
+- When a brief lacks a named audience, an opposable difference, or supporting proof.
+- When a brand refresh or extension needs grounding before token changes.
+
+## Procedure
+
+1. **Pressure-test the brief.** Is the audience named (not "everyone")? Is the difference opposable (could a competitor claim the opposite)? Is there at least one proof point? If any are missing, challenge — do not proceed on a vague brief.
+
+2. **Ground via the corpus.** Run the corpus engine for each required domain. Start with archetype, then voice, then messaging:
+
+```bash
+python3 <skills-root>/corpus-grounding/scripts/ground.py search \
+  --manifest <skills-root>/brand/data/manifest.json \
+  "<sector + audience + intent>" --domain archetype --json
+```
+
+   Repeat with `--domain voice` and `--domain messaging`. Each call returns ranked rows with `confidence` and `evidence_gap`.
+
+3. **Read confidence and evidence gaps.** Before trusting any row, read `confidence` and every `evidence_gap` entry verbatim. Low-confidence rows must be surfaced as gaps — never silently promoted.
+
+4. **Draft the constraint set.** Produce:
+   - An **opposable positioning statement** naming the audience AND a difference a competitor could legitimately claim the opposite of.
+   - A **voice profile**: 3-5 traits, each with a do and a don't.
+   - A **chosen messaging framework** (problem-solution, jobs-to-be-done, category creation, etc.) with a rationale sentence.
+
+5. **Surface gaps and low-confidence calls.** Name every evidence gap and every row below the confidence threshold. Flag where the corpus was thin.
+
+6. **Human confirms.** Present the full constraint set. Wait for confirmation before handing off. Do not proceed autonomously.
+
+7. **Hand off.** Pass the confirmed constraint set to brand-identity (identity execution) and brand-to-tokens (DTCG token emission).
+
+## Output format
+
+1. Named archetype cited to the corpus row (domain, row id, confidence).
+2. One-line opposable positioning statement (audience + difference).
+3. Voice profile: 3-5 traits, each with a do/don't pair, plus chosen messaging framework with rationale.
+4. Confidence label (High / Medium / Low) and every `evidence_gap` from the corpus verbatim.
+
+## Do NOT
+
+- Author final taglines, brand names, or headlines as decided output — those are identity artifacts.
+- Invent values or traits absent from the corpus or the consumer's existing brand.
+- Accept a brief with no named audience, no opposable difference, and no proof point.
+- Override the consumer's existing brand tokens or voice — they are the source of truth; this skill grounds net-new or refresh decisions only.
+
+## Gotcha
+
+- The corpus grounds pre-action selection, not validation. Post-production consistency checking belongs to brand-consistency, not here.
+- "Premium + approachable + innovative" is three briefs, not one. Force the trade-off before drafting a positioning statement.
+- An empty corpus result is legitimate signal — surface the gap and ask whether to proceed with a thin foundation or pause for more evidence.
+
+## See also
+
+- [`brand`](../brand/SKILL.md) — the corpus this skill grounds against.
+- [`brand-identity`](../brand-identity/SKILL.md) — consumes the confirmed strategy.
+- [`brand-to-tokens`](../brand-to-tokens/SKILL.md) — emits the DTCG token source of truth.
+- [`corpus-grounding`](../corpus-grounding/SKILL.md) — the shared engine.

package/dist/agent-src/skills/brand-strategy/evals/triggers.json

@@ -0,0 +1,17 @@
+{
+  "skill": "brand-strategy",
+  "last_eval": "2026-06-16",
+  "description": "5 should-trigger + 5 should-not-trigger. Should-trigger covers grounding brand strategy (archetype, positioning, voice, messaging). Should-not covers near-miss neighbors.",
+  "queries": [
+    {"q": "which brand archetype fits a B2B SaaS startup targeting mid-market ops teams", "trigger": true},
+    {"q": "write an opposable positioning statement for our challenger brand", "trigger": true},
+    {"q": "define the voice and tone profile for our brand — what do we sound like and what do we never say", "trigger": true},
+    {"q": "which messaging framework should we use — jobs-to-be-done or category creation", "trigger": true},
+    {"q": "who is this brand actually for and what makes us different from the obvious competitors", "trigger": true},
+    {"q": "what UI style and colour palette should the dashboard use", "trigger": false, "note": "frontend style grounding -> design-intelligence"},
+    {"q": "generate a logo image for our new product line", "trigger": false, "note": "asset generation -> logo-generation"},
+    {"q": "emit our brand colours as CSS custom properties and a DTCG token file", "trigger": false, "note": "token emission -> brand-to-tokens / design-tokens"},
+    {"q": "check whether this landing page copy is consistent with our brand voice", "trigger": false, "note": "validation -> brand-consistency rule"},
+    {"q": "audit how consistently our brand is applied across our marketing site and product", "trigger": false, "note": "audit -> brand-audit"}
+  ]
+}

package/dist/agent-src/skills/brand-to-tokens/SKILL.md

@@ -0,0 +1,102 @@
+---
+model_tier: inherit
+name: brand-to-tokens
+description: "Derive a DTCG .tokens.json source of truth from confirmed brand decisions, emit CSS vars + Tailwind via design-tokens, and export locked brand deck templates. Use to turn a brand identity into tokens."
+domain: engineering
+personas: []
+workspaces:
+  - engineering
+packs:
+  - brand
+trust:
+  level: professional
+install:
+  removable: true
+execution:
+  type: manual
+---
+
+# brand-to-tokens
+
+> The brand→token derivation — the **first consumer demand** that closes the
+> ADR-061 §8 deferral. Takes a confirmed [`brand-identity`](../brand-identity/SKILL.md)
+> constraint set and produces a DTCG `.tokens.json` **source of truth**, then
+> hands it to the [`design-tokens`](../design-tokens/SKILL.md) toolchain to emit
+> CSS vars + Tailwind. The same `.tokens.json` is the export that pack-ai-image
+> brand-asset generation and the greenfield scaffold seed consume (B → A;
+> contract: [`brand-token-consumption`](../../../docs/contracts/brand-token-consumption.md)).
+
+## When to use
+
+- A confirmed brand identity (colour story, type story, spacing) needs to become
+  a maintained token system.
+- A consumer asks to "turn the brand into tokens / CSS variables / a theme."
+- Before pack-ai-image brand-asset generation or a greenfield scaffold needs the
+  `.tokens.json` export.
+
+## Procedure
+
+1. **Take the confirmed brand-identity constraint set** — colour story (roles +
+   values), type story (heading/body classes), spacing/radius intent. If a
+   consumer brand profile already registers values, those win
+   ([`brand-source-of-truth`](../../rules/brand-source-of-truth.md)).
+2. **Author `.tokens.json`** on the `design-tokens` 3-layer DTCG model
+   (`$value` / `$type`): brand palette → `primitive.color.*`; brand roles
+   (primary, accent, surface, destructive) → `semantic.color.*` referencing the
+   primitives; per-widget needs → `component.*`. Add `dark.semantic.*` overrides.
+   Type tokens come from [`typography-system`](../typography-system/SKILL.md)
+   stage-2 (archetype → pairing-filter), added under the `typography` section.
+3. **Generate** CSS vars + Tailwind through the toolchain:
+
+   ```bash
+   python3 <skills-root>/design-tokens/scripts/tokens.py generate \
+     --config .tokens.json -o assets/design-tokens.css
+   python3 <skills-root>/design-tokens/scripts/tokens.py generate \
+     --config .tokens.json --format tailwind
+   ```
+
+4. **Validate** — `python3 <skills-root>/design-tokens/scripts/tokens.py
+   validate --dir src/` until clean (exit 0 is the evidence); convert
+   hardcoded values to `var(--token)`.
+5. **Export the deck templates** — emit the locked-variable brand deck
+   templates from [`templates/`](templates/) — `marp-brand-deck.md.example`
+   (copy to `.md` to use) and `reveal-brand-deck.yaml` — substituting the brand
+   variables from `.tokens.json`. No render engine is owned (decision 7); the
+   templates feed the user's own deck tool.
+6. **Publish `.tokens.json`** as the source of truth other surfaces read
+   (pack-ai-image generation, greenfield scaffold) per the consumption contract.
+
+## Output format
+
+1. `.tokens.json` — DTCG 3-layer (primitive → semantic → component) + `dark.semantic` + `typography`, every value `{$value, $type}`.
+2. Generated `design-tokens.css` + the Tailwind `theme.extend` snippet.
+3. `validate` evidence — exit 0, or the `token_violation` findings handed to polish.
+4. The exported brand deck templates (Marp + reveal) with brand variables locked from the tokens.
+
+## Gotcha
+
+- **`.tokens.json` is the single source — never hand-edit the generated CSS or a
+  consumer-side copy.** pack-ai-image generation and the greenfield scaffold read
+  this file; a hand-edited downstream copy silently drifts from the brand.
+- **Derive, do not invent.** Every token traces to a brand-identity decision or
+  the consumer's existing brand; a value with no brand provenance is off-brand
+  ([`brand-consistency`](../../rules/brand-consistency.md) will flag it).
+- Deck templates **lock** brand variables — never inline a raw hex/font in a
+  template; reference the token so the deck stays on-brand when tokens change.
+
+## Do NOT
+
+- Do NOT generate marks or assets here — this skill emits tokens + templates;
+  [`logo-generation`](../logo-generation/SKILL.md) / `brand-asset-generation`
+  generate the marks from the tokens (B → A, never inverted).
+- Do NOT hand-edit generated CSS — `.tokens.json` is the source.
+- Do NOT let components reference primitives directly — semantic layer between.
+- Do NOT own a slide-render engine — export validated templates only (decision 7).
+
+## See also
+
+- [`brand-identity`](../brand-identity/SKILL.md) — supplies the constraint set this skill derives tokens from.
+- [`design-tokens`](../design-tokens/SKILL.md) — the DTCG toolchain that emits CSS/Tailwind from `.tokens.json`.
+- [`typography-system`](../typography-system/SKILL.md) — brand-aware stage-2 supplies the type tokens.
+- [`brand-token-consumption`](../../../docs/contracts/brand-token-consumption.md) — the read contract pack-ai-image and greenfield scaffold consume.
+- [`brand-consistency`](../../rules/brand-consistency.md) — validates emitted artifacts against this token source of truth.

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

@@ -0,0 +1,17 @@
+{
+  "skill": "brand-to-tokens",
+  "last_eval": "2026-06-16",
+  "description": "5 should-trigger + 5 should-not-trigger. Should-trigger covers deriving a DTCG .tokens.json source of truth from brand decisions and emitting CSS/Tailwind + deck templates. Should-not covers near-miss neighbors: generic token authoring without a brand frame, defining (not emitting) identity, generation, validation, and a deck-render engine.",
+  "queries": [
+    {"q": "turn our confirmed brand identity into design tokens", "trigger": true},
+    {"q": "derive a .tokens.json source of truth from the brand colours and type", "trigger": true},
+    {"q": "emit the brand as CSS variables and a Tailwind theme", "trigger": true},
+    {"q": "export brand deck templates with the brand variables locked", "trigger": true},
+    {"q": "generate the brand token system that pack-ai-image will consume", "trigger": true},
+    {"q": "author a generic 3-layer token system for this app (no brand)", "trigger": false, "note": "generic token authoring with no brand frame -> design-tokens"},
+    {"q": "define the colour story and type story for the brand", "trigger": false, "note": "defining the identity constraint set -> brand-identity"},
+    {"q": "generate a logo from these brand tokens", "trigger": false, "note": "asset generation -> logo-generation (pack-ai-image)"},
+    {"q": "check this component is using the brand tokens", "trigger": false, "note": "validation -> brand-consistency rule"},
+    {"q": "render this brand deck to PDF / build a slide engine", "trigger": false, "note": "no render engine is owned (decision 7) — templates only"}
+  ]
+}

package/dist/agent-src/skills/brand-to-tokens/templates/marp-brand-deck.md.example

@@ -0,0 +1,46 @@
+---
+# Marp brand deck template — locked brand variables.
+# Every visual value below references a brand token from .tokens.json
+# (var(--token)). Do NOT inline raw hex/fonts — that breaks brand sync.
+# Render with the user's own Marp tooling; no engine is owned here.
+marp: true
+theme: brand
+paginate: true
+style: |
+  :root {
+    --brand-bg: var(--semantic-color-background);
+    --brand-fg: var(--semantic-color-foreground);
+    --brand-primary: var(--semantic-color-primary);
+    --brand-accent: var(--semantic-color-accent);
+    --brand-font-heading: var(--typography-heading-font-family);
+    --brand-font-body: var(--typography-body-font-family);
+  }
+  section {
+    background: var(--brand-bg);
+    color: var(--brand-fg);
+    font-family: var(--brand-font-body);
+  }
+  h1, h2 {
+    font-family: var(--brand-font-heading);
+    color: var(--brand-primary);
+  }
+  strong { color: var(--brand-accent); }
+---
+
+# [Brand Name]
+
+Subtitle in the brand voice — replace with confirmed positioning line.
+
+---
+
+## Section title
+
+- Body copy in the brand body font, brand foreground colour.
+- **Emphasis** uses the brand accent token, never a raw hex.
+
+---
+
+## Closing
+
+Call to action in the brand voice. All colour and type come from
+`.tokens.json` via `var(--token)` — change the tokens, the deck restyles.

package/dist/agent-src/skills/brand-to-tokens/templates/reveal-brand-deck.yaml

@@ -0,0 +1,32 @@
+# reveal.js brand deck template — locked brand variables.
+# Values reference brand tokens from .tokens.json; the consumer's reveal
+# build injects assets/design-tokens.css so var(--token) resolves.
+# No render engine is owned here (decision 7) — this configures the user's reveal.
+deck:
+  title: "[Brand Name]"
+  # Inject the generated brand token stylesheet so var(--token) resolves.
+  css:
+    - assets/design-tokens.css
+  theme: brand
+
+# Brand variables are LOCKED to tokens — never inline a raw hex/font.
+brand:
+  background: "var(--semantic-color-background)"
+  text: "var(--semantic-color-foreground)"
+  heading: "var(--semantic-color-primary)"
+  accent: "var(--semantic-color-accent)"
+  font_heading: "var(--typography-heading-font-family)"
+  font_body: "var(--typography-body-font-family)"
+
+reveal:
+  controls: true
+  progress: true
+  transition: fade
+
+slides:
+  - heading: "[Brand Name]"
+    body: "Positioning line in the brand voice."
+  - heading: "Section title"
+    body: "Body copy in the brand body font; emphasis uses the accent token."
+  - heading: "Closing"
+    body: "Call to action. Restyle the whole deck by changing .tokens.json."

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

@@ -1,5 +1,6 @@
 {
   "skill": "canvas-design",
+  "last_eval": "2026-06-16",
   "description": "5 should-trigger + 5 should-not-trigger queries. Should-trigger asks for static visual art (poster / cover / marketing visual). Should-not-trigger near-misses share design vocabulary but route elsewhere (fe-design, tailwind-engineer, voice-and-tone-design, release-comms).",
   "queries": [
     {"q": "Need a launch poster for next week's release announcement — A3 print, minimal style", "trigger": true},

package/dist/agent-src/skills/check-refs/SKILL.md

@@ -10,7 +10,7 @@ execution:
   allowed_tools: []
   command:
     - python3
-    - src/scripts/check_references.py
+    - src/scripts/check_references.ts
 workspaces:
   - agent-config-maintainer
 packs:
@@ -48,11 +48,11 @@ Invoke the skill through the runtime dispatcher so the `execution:` block in
 this skill's frontmatter governs the call:
 
 ```bash
-python3 scripts/runtime_dispatcher.py run --skill check-refs
+./scripts-run src/scripts/runtime_dispatcher run --skill check-refs
 ```
 
 The dispatcher resolves the request, the shell handler runs
-`python3 src/scripts/check_references.py`, captures stdout/stderr, and returns a
+`python3 src/scripts/check_references.ts`, captures stdout/stderr, and returns a
 typed `ExecutionResult`.
 
 ### 3. Verify the result
@@ -64,7 +64,7 @@ Check the returned `ExecutionResult`:
   line, and the offending ref, then fix the source or update the target
 - `status: timeout` → the checker exceeded `timeout_seconds` — investigate
 - `status: error` → interpreter or script missing — confirm `python3` and
-  `src/scripts/check_references.py` are available at the repository root
+  `src/scripts/check_references.ts` are available at the repository root
 
 ## Output format
 
@@ -87,7 +87,7 @@ Check the returned `ExecutionResult`:
 
 ## Do NOT
 
-- Do NOT invoke `src/scripts/check_references.py` directly when the intent is to
+- Do NOT invoke `src/scripts/check_references.ts` directly when the intent is to
   verify the runtime path — always go through the dispatcher so the
   `ExecutionResult` is produced and inspectable
 - Do NOT raise `timeout_seconds` to mask a slowdown — investigate which part

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

@@ -113,14 +113,7 @@ The checks below are stack-agnostic. For framework-specific conventions (PSR-12
 
 ### The response pattern
 
-When receiving code review feedback, follow this sequence:
-
-1. **READ** — Complete feedback without reacting.
-2. **UNDERSTAND** — Restate the requirement in your own words (or ask if unclear).
-3. **VERIFY** — Check the suggestion against codebase reality.
-4. **EVALUATE** — Is it technically sound for THIS codebase?
-5. **RESPOND** — Technical acknowledgment or reasoned pushback.
-6. **IMPLEMENT** — One item at a time, test each.
+Constraint: **understand each comment fully before touching code, verify it against codebase reality, and implement one item at a time (test each).** Restate anything ambiguous in your own words — or ask. Push back with technical reasoning when a suggestion is unsound for *this* codebase rather than complying reflexively.
 
 If **any item is unclear**, STOP — do not implement anything yet. Items may be related;
 partial understanding leads to wrong implementation.
@@ -161,13 +154,7 @@ How: Use technical reasoning, not defensiveness. Reference working tests/code.
 
 ### Addressing PR comments systematically
 
-When working through review comments on a PR:
-
-1. **List** all comments and review threads (`gh pr view --comments`).
-2. **Categorize**: blocking → simple fixes → complex fixes.
-3. **Clarify** anything unclear BEFORE implementing.
-4. **Fix** one at a time, test each.
-5. **Reply in the thread** — not as a top-level PR comment.
+Constraint: **clarify anything unclear before implementing, fix one item at a time (test each), and reply in each review thread** — not as a top-level PR comment. Triage first (blocking → simple → complex) so blockers land first; `gh pr view --comments` lists the threads.
 
 ```bash
 # Reply to a specific review comment thread
@@ -177,6 +164,10 @@ gh api repos/{owner}/{repo}/pulls/comments/{comment_id}/replies \
 
 ## Output format
 
+1. Structure every finding by severity (Blocker / Suggestion / Nit) using the block below; never mix severities in one block.
+2. Group related findings; skip anything the project's linter or type-checker already catches — focus on logic, architecture, and judgment.
+3. End with a one-line verdict (approve / request-changes / comment) and a count of Blockers vs. Suggestions.
+
 When reviewing code, structure feedback by severity:
 
 ```

package/dist/agent-src/skills/command-routing/SKILL.md

@@ -80,7 +80,7 @@ agents should not bypass the dispatcher.
 
 ## GitHub API: Replying to PR review comments
 
-When commands reply to PR review comments (e.g. `/fix-pr-bot-comments`):
+When commands reply to PR review comments (e.g. `/fix-pr-comments`):
 
 ### 1. Read the setting
 

package/dist/agent-src/skills/command-writing/SKILL.md

@@ -194,10 +194,10 @@ multi-paragraph explanation, extract it into a skill and call it.
 
 ### 5. Validate
 
-* Run `python3 scripts/skill_linter.py src/agent-src/commands/{name}.md`
+* Run `./scripts-run src/scripts/skill_linter src/agent-src/commands/{name}.md`
   → 0 FAIL.
 * Run `bash scripts/condense.sh --sync` → regenerates `dist/agent-src/commands/{name}.md`.
-* Run `python3 scripts/condense.py --generate-tools` → creates the Claude symlink at
+* Run `./scripts-run src/scripts/condense --generate-tools` → creates the Claude symlink at
   `.claude/skills/{name}/SKILL.md`.
 * Run the full CI pipeline locally (see `Taskfile.yml` in this repo for
   the script list) — must exit 0 except for tolerated warnings.