@event4u/agent-config 6.0.0 → 7.0.0

package/dist/agent-src/commands/analyze/near-miss.md

@@ -0,0 +1,113 @@
+---
+model_tier: inherit
+name: analyze-near-miss
+pack: analysis-workbench
+tier: 2
+visibility: internal
+cluster: analyze
+sub: near-miss
+skills: [blameless-post-mortem]
+description: Blame-free near-miss analysis — same post-mortem flow as analyze:postmortem but framed around a close call that did not result in a production incident.
+suggestion:
+  eligible: true
+  trigger_description: "near-miss, almost failed, beinahe-Vorfall, close call, we almost had an outage"
+  trigger_context: "user wants to analyse a close call or near-miss event that did not produce a full incident"
+workspaces:
+  - engineering
+packs:
+  - analysis-workbench
+---
+
+# /analyze:near-miss
+
+Near-miss analysis sub-command in the `/analyze` cluster.
+Uses the
+[`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md)
+skill with a near-miss framing — same structure as
+[`analyze:postmortem`](../postmortem/command.md) but the emphasis is
+on *what prevented actual impact* and *what systemic changes prevent
+recurrence*, not on cataloguing damage.
+
+## Instructions
+
+### 1. Gather the near-miss context
+
+Ask the user (in their language) for:
+
+- Event summary — what happened, what was at risk, what contained it.
+- Timeline bullets (what occurred, in what order).
+- Known trigger or suspected root cause (may be empty).
+- What safeguard, luck, or human action prevented full impact.
+
+Accept incomplete information; the write-up may include open items
+with `status: draft`.
+
+### 2. Retrieve prior incident-learnings
+
+Before drafting, call `retrieve()` over the same key-space (affected
+system, incident type, decision area) per
+[`analysis-memory-loop.md § 2`](../../../../docs/contracts/analysis-memory-loop.md):
+
+- **Stale entries** (age > `review_after_days`) are in `skipped` —
+  surface them; do not silently use them.
+- **Match found** → propose a `frequency` / `supersedes` update.
+- **No match** → proceed to draft a new candidate in Step 4.
+
+### 3. Write the near-miss document
+
+Following
+[`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md),
+produce a write-up covering:
+
+1. **Summary** — what was at risk, what contained it.
+2. **Timeline** — chronological bullets.
+3. **Trigger / contributing factors** — systemic, not individual.
+4. **What prevented impact** — named safeguard, human catch, timing.
+5. **Corrective actions** — numbered, owned, time-boxed.
+6. **What went well** — preserve the working safeguards.
+
+Emphasise the containing mechanism over the potential damage — the goal
+is to reinforce what worked and close the gap that allowed the close
+call.
+
+### 4. Draft the memory candidate
+
+Per
+[`analysis-memory-loop.md § 1`](../../../../docs/contracts/analysis-memory-loop.md),
+draft an `incident-learnings` candidate via `/memory propose`:
+
+```jsonc
+{
+  "type":              "incident-learnings",
+  "summary":           "<one-line pattern: near-miss type + containing mechanism>",
+  "evidence_paths":    ["<path/to/near-miss-doc>"],
+  "decision_surface":  ["<area1>", "<area2>"],
+  "last_validated":    "<today-YYYY-MM-DD>",
+  "review_after_days": 90,
+  "applicable_scope":  "project"
+}
+```
+
+### 5. Surface the candidate to the user
+
+> 1. Propose this candidate to `/memory propose` (recommended)
+> 2. Refine before proposing — suggest changes
+> 3. Skip memory candidate for now
+
+**Empfehlung:** 1
+
+### Rules
+
+- Do NOT commit, push, or open a PR.
+- Do NOT auto-promote — `/memory propose` is the intake.
+- Do NOT block on incomplete root cause — accept skeletons.
+- Systems and processes only — never name individuals.
+- Frame the write-up around the containing mechanism, not the
+  potential damage.
+
+## See also
+
+- [`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md)
+- [`analysis-memory-loop.md`](../../../../docs/contracts/analysis-memory-loop.md)
+- [`/analyze:postmortem`](../postmortem/command.md) — same flow, full incident
+- [`/analyze`](../command.md) — cluster orchestrator

package/dist/agent-src/commands/analyze/postmortem.md

@@ -0,0 +1,130 @@
+---
+model_tier: inherit
+name: analyze-postmortem
+pack: analysis-workbench
+tier: 2
+visibility: internal
+cluster: analyze
+sub: postmortem
+skills: [blameless-post-mortem, root-cause-frameworks]
+description: Blame-free post-mortem after a resolved incident — consume the incident-commander skeleton, derive root cause, write corrective actions, draft an incident-learnings memory candidate.
+suggestion:
+  eligible: true
+  trigger_description: "post-mortem, Nachbesprechung, incident review, was ist schiefgelaufen"
+  trigger_context: "incident or outage is resolved and a structured write-up is needed"
+workspaces:
+  - engineering
+packs:
+  - analysis-workbench
+---
+
+# /analyze:postmortem
+
+Blame-free post-mortem sub-command in the `/analyze` cluster.
+Loads and runs the
+[`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md)
+skill, supported by
+[`root-cause-frameworks`](../../../../skills/root-cause-frameworks/SKILL.md).
+
+## Instructions
+
+### 1. Gather the incident context
+
+Ask the user (in their language) for what is known:
+
+- Incident summary (title, affected system, start/end time, severity).
+- Timeline bullet points (what happened, when).
+- Known or suspected root cause (may be empty — that is fine; the
+  skill will derive it in Step 3).
+- Any existing `incident-commander` skeleton to consume.
+
+Accept an incomplete skeleton per
+[`analysis-memory-loop.md § 5`](../../../../docs/contracts/analysis-memory-loop.md):
+a missing root cause is normal, not a blocker.
+
+### 2. Retrieve prior incident-learnings
+
+Before drafting, call `retrieve()` over the same key-space (incident
+type, affected paths, decision areas) per
+[`analysis-memory-loop.md § 2`](../../../../docs/contracts/analysis-memory-loop.md).
+
+- **Stale entries** (age > `review_after_days`) appear in `skipped`
+  — surface them to the user, do not silently use them.
+- **Match found** → note the existing entry; propose a `frequency` or
+  `supersedes` update instead of a new candidate.
+- **No match** → proceed to draft a new candidate in Step 5.
+
+### 3. Derive or confirm root cause
+
+Load [`root-cause-frameworks`](../../../../skills/root-cause-frameworks/SKILL.md)
+and run the appropriate framework (5-whys chain, fishbone, fault-tree,
+or STAMP/STPA) against the timeline. The skill returns ranked
+candidates with confidence levels — not a forced verdict. Present the
+top candidates to the user.
+
+If root cause remains unresolved after the pass, mark the post-mortem
+`status: draft`; do not block or stall.
+
+### 4. Write the post-mortem document
+
+Following
+[`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md),
+produce a structured write-up covering:
+
+1. **Summary** — what failed, impact, duration.
+2. **Timeline** — chronological bullets.
+3. **Root cause** — confirmed or `status: draft` if unresolved.
+4. **Contributing factors** — systemic, not individual.
+5. **Corrective actions** — numbered, owned, time-boxed.
+6. **What went well** — preserve working safeguards.
+
+Systems and processes are examined — never individuals.
+
+### 5. Draft the memory candidate
+
+Per
+[`analysis-memory-loop.md § 1`](../../../../docs/contracts/analysis-memory-loop.md),
+draft an `incident-learnings` candidate using `/memory propose`:
+
+```jsonc
+{
+  "type":              "incident-learnings",
+  "summary":           "<one-line pattern learned>",
+  "evidence_paths":    ["<path/to/post-mortem>", "<path/to/timeline>"],
+  "decision_surface":  ["<area1>", "<area2>"],
+  "last_validated":    "<today-YYYY-MM-DD>",
+  "review_after_days": 90,
+  "applicable_scope":  "project"
+}
+```
+
+If the post-mortem is `status: draft`, include the open question in
+`summary` (e.g. `"root cause TBD — <symptom>"`).
+
+Dedup check from Step 2 determines whether to propose a new entry or
+update an existing one.
+
+### 6. Surface the candidate to the user
+
+Present the draft candidate and ask:
+
+> 1. Propose this candidate to `/memory propose` (recommended)
+> 2. Refine before proposing — suggest changes
+> 3. Skip memory candidate for now
+
+**Empfehlung:** 1
+
+### Rules
+
+- Do NOT commit, push, or open a PR.
+- Do NOT auto-promote to curated memory — `/memory propose` is the
+  intake; `/memory promote` requires the human to run the admission gate.
+- Do NOT block on an incomplete root cause — accept any skeleton.
+- Systems and processes only — never name individuals.
+
+## See also
+
+- [`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md)
+- [`root-cause-frameworks`](../../../../skills/root-cause-frameworks/SKILL.md)
+- [`analysis-memory-loop.md`](../../../../docs/contracts/analysis-memory-loop.md)
+- [`/analyze`](../command.md) — cluster orchestrator

package/dist/agent-src/commands/analyze/premortem.md

@@ -0,0 +1,104 @@
+---
+model_tier: inherit
+name: analyze-premortem
+pack: analysis-workbench
+tier: 2
+visibility: internal
+cluster: analyze
+sub: premortem
+skills: [premortem]
+description: Forward-looking imagined-failure analysis before committing to a heavy or irreversible plan — enumerate failure stories, score each mode, derive early-warning signals and guardrails.
+suggestion:
+  eligible: true
+  trigger_description: "premortem, what if this fails, imagine failure, stress-test this plan, what could go wrong"
+  trigger_context: "user wants to anticipate failure modes before committing to a plan"
+workspaces:
+  - engineering
+packs:
+  - analysis-workbench
+---
+
+# /analyze:premortem
+
+Forward-looking imagined-failure sub-command in the `/analyze` cluster.
+Loads and runs the
+[`premortem`](../../../../skills/premortem/SKILL.md) skill.
+
+## Instructions
+
+### 1. Gather the plan to stress-test
+
+Ask the user (in their language) for:
+
+- A one-sentence summary of the plan: *"We are doing X for outcome Y,
+  touching Z."*
+- The prospective-failure horizon (default: 6 months post-launch).
+- Any known constraints, irreversibilities, or high-coordination
+  surfaces worth front-loading.
+
+If the plan cannot be summarised in one sentence, stop and ask for
+scope clarification before proceeding. An un-summarisable plan is not
+reviewable.
+
+### 2. Run the premortem skill
+
+Delegate to
+[`premortem`](../../../../skills/premortem/SKILL.md) verbatim:
+
+1. **Set the prospective-failure frame** — "Assume total failure at
+   horizon H. What went wrong?"
+2. **Enumerate failure stories** — cover people, process, technical,
+   external, and timing angles. Each story is a short narrative in past
+   tense. Invoke `adversarial-review` to attack the plan's assumptions.
+   Invoke `risk-officer` to assign L × I scores — do not re-implement
+   L × I inline.
+3. **Derive early-warning signals and preventive guardrails** — one
+   observable signal and one actionable guardrail per top failure mode.
+   If no practical guardrail exists, mark it `accept` with rationale.
+
+### 3. Optional memory write-back
+
+If the analysis surfaces a pattern worth preserving for future plans:
+
+1. Dedup pre-check: call `retrieve()` over the same key-space (plan
+   type, affected paths, decision area) per
+   [`analysis-memory-loop.md § 2`](../../../../docs/contracts/analysis-memory-loop.md).
+   - **Match found** → propose a `frequency` / `supersedes` update.
+   - **No match** → draft a new `historical-patterns` candidate.
+
+2. Draft the candidate:
+
+```jsonc
+{
+  "type":              "historical-patterns",
+  "summary":           "<one-line pattern: failure mode to watch for>",
+  "evidence_paths":    ["<path/to/plan-doc>"],
+  "decision_surface":  ["<area1>", "<area2>"],
+  "last_validated":    "<today-YYYY-MM-DD>",
+  "review_after_days": 90,
+  "applicable_scope":  "project"
+}
+```
+
+3. Surface the candidate to the user and ask:
+
+> 1. Propose this candidate to `/memory propose` (recommended)
+> 2. Refine before proposing — suggest changes
+> 3. Skip memory candidate for now
+
+**Empfehlung:** 1
+
+### Rules
+
+- Do NOT commit, push, or open a PR.
+- Do NOT auto-promote — `/memory propose` is the intake.
+- Do NOT re-implement L × I scoring — delegate to `risk-officer`.
+- Failure stories must be grounded in the actual plan's structure —
+  no invented strawmen.
+- Label all scenarios as prospective (imagined future), not predictions.
+
+## See also
+
+- [`premortem`](../../../../skills/premortem/SKILL.md)
+- [`analysis-memory-loop.md`](../../../../docs/contracts/analysis-memory-loop.md)
+- [`/analyze`](../command.md) — cluster orchestrator

package/dist/agent-src/commands/analyze-reference-repo.md

@@ -3,6 +3,7 @@ model_tier: high
 name: analyze-reference-repo
 pack: engineering-base
 tier: 2
+visibility: internal
 skills: [project-analyzer, learning-to-rule-or-skill]
 description: Analyze an external reference repository (competitor, inspiration, peer) and produce a structured comparison + adoption plan for this project.
 suggestion:

package/dist/agent-src/commands/analyze.md

@@ -0,0 +1,124 @@
+---
+model_tier: medium
+name: analyze
+disable-model-invocation: true
+pack: analysis-workbench
+intent: "Analysis dispatcher — classify input by keywords, propose a weighted framework path, let the user pick"
+routes_to: [analyze-postmortem, analyze-premortem, analyze-decision, analyze-near-miss, analyze-incident]
+replaces: []
+tier: 1
+visibility: advanced
+description: Analysis orchestrator — confidence-weighted suggester that routes to postmortem, premortem, decision-review, near-miss, or incident frameworks.
+cluster: analyze
+type: orchestrator
+suggestion:
+  eligible: true
+  trigger_description: "analyze this, run a post-mortem, pre-mortem, decision review, near-miss, or incident analysis"
+  trigger_context: "user wants to apply a structured analysis framework to a past event, future risk, or past decision"
+workspaces:
+  - engineering
+packs:
+  - analysis-workbench
+---
+
+# /analyze
+
+Top-level orchestrator for the `/analyze` family. A
+**confidence-weighted suggester** — classifies the user's input by
+keywords, proposes a numbered-options menu ranked by fit, and routes
+to the chosen sub-command. Never auto-selects silently.
+
+## Sub-commands
+
+| Sub-command | Routes to | Purpose |
+|---|---|---|
+| `/analyze:postmortem` | `analyze/postmortem/command.md` | Blame-free post-mortem after a resolved incident |
+| `/analyze:premortem` | `analyze/premortem/command.md` | Forward-looking imagined-failure before committing to a plan |
+| `/analyze:decision` | `analyze/decision/command.md` | Audit a past architectural decision (did it hold?) |
+| `/analyze:near-miss` | `analyze/near-miss/command.md` | Post-mortem for a near-miss (same flow, lighter severity framing) |
+| `/analyze:incident` | `analyze/incident/command.md` | Full incident flow: commander → RCA → post-mortem → memory candidate |
+
+## Dispatch
+
+### 1. Parse the argument
+
+`/analyze[:<sub>] [args]` or `/analyze <sub> [args]`.
+
+- **Explicit sub-command present** → load that sub-command's body and
+  follow its `## Instructions` verbatim with the remaining args.
+- **No sub-command** → proceed to Step 2.
+
+### 2. Confidence-weighted classification
+
+Read the user's free-text input. Score each framework by keyword
+match:
+
+| Keyword signals | Suggests |
+|---|---|
+| "post-mortem", "outage", "incident resolved", "was ist schiefgelaufen" | `postmortem` |
+| "near-miss", "almost failed", "beinahe-Vorfall", "close call" | `near-miss` |
+| "pre-mortem", "what could go wrong", "imagine failure", "vor dem Start" | `premortem` |
+| "decision review", "ADR", "did this hold up", "rückblick Architektur" | `decision` |
+| "production is down", "active incident", "Vorfall", "Prod ist down" | `incident` |
+
+Assign a confidence level (high / medium / low) per framework based on
+signal count. A framework with zero signals gets `low`.
+
+### 3. Surface the weighted menu — NEVER auto-select
+
+Present numbered options in descending confidence order. At least two
+options must appear. Always include the `describe in your own words`
+escape:
+
+> Which analysis framework fits?
+>
+> 1. [high] Post-mortem (`/analyze:postmortem`) — blame-free write-up after a resolved incident
+> 2. [medium] Near-miss (`/analyze:near-miss`) — same flow, lighter severity framing
+> 3. [low] Pre-mortem (`/analyze:premortem`) — imagined-failure analysis before committing
+> 4. [low] Decision review (`/analyze:decision`) — did a past architectural decision hold up?
+> 5. [low] Incident (`/analyze:incident`) — full live-incident coordination + RCA + post-mortem
+> 6. Describe in your own words — I'll re-classify
+
+**Empfehlung:** 1
+
+The user picks a number. Load the routed sub-command and follow its
+`## Instructions` verbatim with the remaining args.
+
+### 4. If the user picks "Describe in your own words"
+
+Ask one question (per `ask-when-uncertain`):
+
+> What happened or what are you trying to analyse?
+
+Re-run Step 2 with the answer. Present the menu again. Do not loop
+more than twice — on the third attempt, show all five options unranked
+and let the user pick.
+
+### 5. Unknown sub-command
+
+If the argument names a sub-command not in the table, show the table
+and ask which one was intended. One question, no guessing.
+
+## Rules
+
+- **Never auto-select a framework** — always show the weighted menu
+  and wait for the user's pick (council-locked design, Phase 4).
+- **Explicit routing only in v1** — do not infer the framework from
+  open files, branch names, or context not supplied by the user in
+  this turn.
+- **Do NOT commit, push, or open a PR** unless a sub-command
+  explicitly authorizes it.
+- **Do NOT chain sub-commands.** One `/analyze <sub>` per turn.
+- **Memory loop applies** — every sub-command that produces an
+  analysis output MUST draft a memory candidate via
+  `/memory propose` per
+  [`docs/contracts/analysis-memory-loop.md`](../docs/contracts/analysis-memory-loop.md).
+
+## See also
+
+- [`docs/contracts/analysis-memory-loop.md`](../docs/contracts/analysis-memory-loop.md) — produce → propose → promote → retrieve contract
+- [`blameless-post-mortem`](../../../skills/blameless-post-mortem/SKILL.md) — post-mortem + near-miss skill
+- [`root-cause-frameworks`](../../../skills/root-cause-frameworks/SKILL.md) — RCA engine
+- [`premortem`](../../../skills/premortem/SKILL.md) — forward-looking imagined-failure skill
+- [`decision-review`](../../../skills/decision-review/SKILL.md) — past-decision audit skill
+- [`incident-commander`](../../../skills/incident-commander/SKILL.md) — live-incident coordination skill

package/dist/agent-src/commands/brand/identity.md

@@ -0,0 +1,27 @@
+---
+model_tier: high
+name: brand-identity
+pack: brand
+tier: 2
+visibility: internal
+cluster: brand
+sub: identity
+skills: [brand-identity]
+description: Define the brand identity — logo direction, colour story, type story, imagery direction — and the token constraints downstream generation consumes.
+suggestion:
+  eligible: true
+  trigger_description: "define our brand identity, logo and colour direction, type story, visual identity system"
+  trigger_context: "user has a brand strategy and wants the identity system (logo/colour/type/imagery)"
+workspaces:
+  - small-business
+packs:
+  - brand
+---
+
+# /brand:identity
+
+Run the [`brand-identity`](../../skills/brand-identity/SKILL.md) skill — logo
+direction, colour story, type story, imagery direction. brand-identity
+**defines** the tokens/constraints; pack-ai-image's brand-asset generation
+**generates** the marks from them (B → A). Args: `"<strategy ref or brief>"`.
+Run `/brand:strategy` first when no positioning exists.

package/dist/agent-src/commands/brand/review.md

@@ -0,0 +1,27 @@
+---
+model_tier: high
+name: brand-review
+pack: brand
+tier: 2
+visibility: internal
+cluster: brand
+sub: review
+skills: [brand-audit]
+description: Audit emitted UI, copy, and assets against the active brand tokens and voice profile — flag any value not traceable to a brand token or voice rule.
+suggestion:
+  eligible: true
+  trigger_description: "audit our brand consistency, is this on-brand, check this UI/copy against the brand, brand review"
+  trigger_context: "user has emitted UI/copy/assets and wants an on-brand consistency check against tokens + voice"
+workspaces:
+  - small-business
+packs:
+  - brand
+---
+
+# /brand:review
+
+Run the [`brand-audit`](../../skills/brand-audit/SKILL.md) skill — audit emitted
+UI / copy / assets against the active brand tokens (from `state.ui_design` / the
+consumer's `.tokens.json`) and the voice profile, per the `brand-consistency`
+gate. A value not traceable to a brand token or voice rule is flagged off-brand.
+Args: `"<artifact path or description>"`.

package/dist/agent-src/commands/brand/strategy.md

@@ -0,0 +1,27 @@
+---
+model_tier: high
+name: brand-strategy
+pack: brand
+tier: 2
+visibility: internal
+cluster: brand
+sub: strategy
+skills: [brand-strategy]
+description: Define brand positioning, archetype, voice, tone, and messaging over the brand-grounding corpus — the strategy that bounds identity and UI.
+suggestion:
+  eligible: true
+  trigger_description: "define our brand strategy, what's our brand archetype, positioning and messaging, brand voice direction"
+  trigger_context: "user wants brand positioning/archetype/voice/messaging before identity or UI work"
+workspaces:
+  - small-business
+packs:
+  - brand
+---
+
+# /brand:strategy
+
+Run the [`brand-strategy`](../../skills/brand-strategy/SKILL.md) skill —
+positioning, archetype (the 12), voice, tone, messaging frameworks grounded in
+the brand corpus. Output: the strategic frame identity/tokens/voice build on.
+Args: `"<brief>"` (company / product + market). Consumer brand tokens, if
+present, are the source of truth; the corpus fills gaps.

package/dist/agent-src/commands/brand/tokens.md

@@ -0,0 +1,28 @@
+---
+model_tier: high
+name: brand-tokens
+pack: brand
+tier: 2
+visibility: internal
+cluster: brand
+sub: tokens
+skills: [brand-to-tokens]
+description: Derive a DTCG .tokens.json source of truth from brand decisions, then emit CSS vars + Tailwind via the no-Node token generator.
+suggestion:
+  eligible: true
+  trigger_description: "derive brand tokens, turn our brand into design tokens, generate a .tokens.json from the brand"
+  trigger_context: "user has brand identity decisions and wants a DTCG token source of truth + CSS/Tailwind output"
+workspaces:
+  - small-business
+packs:
+  - brand
+---
+
+# /brand:tokens
+
+Run the [`brand-to-tokens`](../../skills/brand-to-tokens/SKILL.md) skill — brand
+decisions → a DTCG `.tokens.json` source of truth → `design-tokens` emits CSS
+vars + Tailwind (no Node). The same `.tokens.json` is the export pack-ai-image's
+brand-asset generation and the greenfield scaffold seed consume; stays on
+`$value`/`$type` so Tokens Studio / Style Dictionary round-trip. Args:
+`"<identity ref>"`.

package/dist/agent-src/commands/brand/voice.md

@@ -0,0 +1,27 @@
+---
+model_tier: high
+name: brand-voice
+pack: brand
+tier: 2
+visibility: internal
+cluster: brand
+sub: voice
+skills: [voice-and-tone-design]
+description: Define the brand voice-and-tone profile — register, do/don't lexicon, and tone shifts by context — the profile the brand-consistency gate checks copy against.
+suggestion:
+  eligible: true
+  trigger_description: "define our brand voice, voice and tone guide, how should our copy sound, tone of voice profile"
+  trigger_context: "user wants a documented voice-and-tone profile for the brand to govern copy"
+workspaces:
+  - small-business
+packs:
+  - brand
+---
+
+# /brand:voice
+
+Run the [`voice-and-tone-design`](../../skills/voice-and-tone-design/SKILL.md)
+skill — register, do/don't lexicon, per-context tone shifts. The voice profile
+is what `/brand:review` and the `brand-consistency` gate check emitted copy
+against. Args: `"<brand/strategy ref>"`. Run `/brand:strategy` first when the
+archetype/positioning is not yet set.

package/dist/agent-src/commands/brand.md

@@ -0,0 +1,58 @@
+---
+model_tier: inherit
+name: brand
+pack: brand
+tier: 2
+visibility: internal
+cluster: brand
+type: orchestrator
+description: Brand-as-UX orchestrator — strategy, identity, tokens, review, voice. Routes to the brand-grounding skills that constrain the design layer.
+suggestion:
+  eligible: true
+  trigger_description: "work on our brand, define brand strategy/identity/voice, derive brand tokens, audit brand consistency"
+  trigger_context: "user wants to define or govern a brand layer (positioning, identity, tokens, voice) that constrains the UI"
+workspaces:
+  - small-business
+packs:
+  - brand
+---
+
+# /brand
+
+Top-level orchestrator for the `/brand:*` family — brand as a first-class UX
+layer that **constrains** the UI. Consulted **before**
+[`design-intelligence`](../../skills/design-intelligence/SKILL.md) so brand
+bounds style selection. Designer flow: discover → strategy → identity → tokens →
+application → governance. Derived brand tokens are the export pack-ai-image's
+brand-asset generation and the greenfield scaffold seed consume (B → A).
+
+## Sub-commands
+
+| Sub-command | Routes to | Purpose |
+|---|---|---|
+| `/brand:strategy "<brief>"` | `commands/brand/strategy.md` | Positioning, archetype, voice, tone, messaging over the brand corpus |
+| `/brand:identity "<strategy ref>"` | `commands/brand/identity.md` | Logo/colour/type/imagery direction; defines the token constraints |
+| `/brand:tokens "<identity ref>"` | `commands/brand/tokens.md` | Derive a DTCG `.tokens.json` source of truth → CSS vars + Tailwind |
+| `/brand:review "<artifact>"` | `commands/brand/review.md` | Audit emitted UI/copy/assets against active brand tokens + voice |
+| `/brand:voice "<brand ref>"` | `commands/brand/voice.md` | Define the voice-and-tone profile the consistency gate checks copy against |
+
+## Dispatch
+
+1. Parse `/brand <sub-command> [args]`. Sub-command = first token; match against
+   the table's exact names only.
+2. Look up the sub-command and execute its file verbatim with the remaining args.
+3. Unknown / missing sub-command → print the table and ask which stage to run.
+
+## Rules
+
+- **Do NOT commit, push, or open a PR** — subcommands never do this.
+- **Do NOT chain subcommands.** One `/brand <sub>` per turn.
+- **Consumer brand tokens are the source of truth.** Corpus only fills gaps; a
+  value not traceable to a brand token or voice rule is off-brand (per
+  [`brand-consistency`](../rules/brand-consistency.md)).
+- **Edit `src/` only.** Generated mirrors regenerate.
+
+## See also
+
+- [`brand-strategy`](../../skills/brand-strategy/SKILL.md) · [`brand-identity`](../../skills/brand-identity/SKILL.md) · [`brand-to-tokens`](../../skills/brand-to-tokens/SKILL.md) · [`brand-audit`](../../skills/brand-audit/SKILL.md) · [`voice-and-tone-design`](../../skills/voice-and-tone-design/SKILL.md) — the skills these commands invoke.
+- [`docs/contracts/command-clusters.md`](../docs/contracts/command-clusters.md) — `brand` cluster registration.