@event4u/agent-config 6.1.0 → 7.0.1

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

@@ -0,0 +1,120 @@
+---
+model_tier: inherit
+name: analyze-incident
+pack: analysis-workbench
+tier: 2
+visibility: internal
+cluster: analyze
+sub: incident
+skills: [incident-commander, root-cause-frameworks, blameless-post-mortem]
+description: Full incident flow — incident-commander coordination, then RCA via root-cause-frameworks, then a blame-free write-up via blameless-post-mortem, ending with an incident-learnings candidate.
+suggestion:
+  eligible: true
+  trigger_description: "production is down, active incident, Vorfall, Prod ist down, full incident analysis"
+  trigger_context: "user is managing or reviewing a production incident end-to-end"
+workspaces:
+  - engineering
+packs:
+  - analysis-workbench
+---
+
+# /analyze:incident
+
+Full incident sub-command in the `/analyze` cluster.
+Chains three skills:
+
+1. [`incident-commander`](../../../../skills/incident-commander/SKILL.md) — live coordination.
+2. [`root-cause-frameworks`](../../../../skills/root-cause-frameworks/SKILL.md) — RCA after mitigation.
+3. [`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md) — write-up + memory candidate.
+
+## Instructions
+
+### Phase 1 — Live incident coordination
+
+Load
+[`incident-commander`](../../../../skills/incident-commander/SKILL.md)
+and follow its procedure verbatim:
+
+- Open an incident log, assign roles, establish communication cadence.
+- Drive mitigation loop until impact is contained.
+- Capture a timeline as the incident progresses.
+- Write a partial post-mortem skeleton when mitigation is confirmed
+  (title, severity, timeline, impact — root cause can be TBD).
+
+**Handoff trigger:** mitigation confirmed → proceed to Phase 2.
+Per
+[`analysis-memory-loop.md § 5`](../../../../docs/contracts/analysis-memory-loop.md),
+the skeleton is acceptable input with open root-cause items.
+
+### Phase 2 — Root-cause analysis
+
+Load
+[`root-cause-frameworks`](../../../../skills/root-cause-frameworks/SKILL.md)
+and run the appropriate framework (5-whys, fishbone, fault-tree, or
+STAMP/STPA) against the captured timeline:
+
+- Return ranked root-cause candidates with confidence levels.
+- Present candidates to the user — not a forced verdict.
+- If root cause remains unresolved, mark the skeleton `status: draft`.
+  Do not block on an unresolved RCA.
+
+### Phase 3 — Post-mortem write-up + memory candidate
+
+Load
+[`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md)
+and produce the full write-up:
+
+1. **Summary** — what failed, impact, duration.
+2. **Timeline** — chronological bullets from Phase 1.
+3. **Root cause** — confirmed or `status: draft`.
+4. **Contributing factors** — systemic, not individual.
+5. **Corrective actions** — numbered, owned, time-boxed.
+6. **What went well** — working safeguards.
+
+#### Memory write-back
+
+Dedup pre-check: call `retrieve()` over the same key-space (incident
+type, affected paths) per
+[`analysis-memory-loop.md § 2`](../../../../docs/contracts/analysis-memory-loop.md):
+
+- **Match found** → propose a `frequency` / `supersedes` update.
+- **No match** → draft a new `incident-learnings` candidate:
+
+```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"
+}
+```
+
+Surface the draft 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 block on incomplete root cause — the skeleton from Phase 1 is
+  sufficient to enter Phase 3; mark `status: draft` if unresolved.
+- Systems and processes only — never name individuals.
+- Do NOT chain back to `/analyze:postmortem` — this command IS the
+  full incident flow end-to-end.
+
+## See also
+
+- [`incident-commander`](../../../../skills/incident-commander/SKILL.md)
+- [`root-cause-frameworks`](../../../../skills/root-cause-frameworks/SKILL.md)
+- [`blameless-post-mortem`](../../../../skills/blameless-post-mortem/SKILL.md)
+- [`analysis-memory-loop.md`](../../../../docs/contracts/analysis-memory-loop.md)
+- [`/analyze:postmortem`](../postmortem/command.md) — post-incident write-up only (no live coordination)
+- [`/analyze`](../command.md) — cluster orchestrator

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.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.