@danmoisan/drm-copilot-mcp 1.0.24 → 1.0.27

package/resources/claude-customizations/.claude/skills/mermaid-diagram/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: mermaid-diagram
+description: 'Generate, validate, and render Mermaid diagrams (flowchart, sequence, class, state, ER, C4, gantt, pie). Use when asked to create, edit, fix, or visualize a diagram, write a .mmd file, or embed a mermaid fence in Markdown. Bundles per-type syntax references and the generate-validate-render workflow enforced by the enforce-mermaid-validation hook.'
+---
+
+# Mermaid Diagram
+
+Authoring workflow for Mermaid diagrams on the Claude runtime. The constraints — file conventions,
+the validation mandate, the managed-diagram rule, and the opt-out marker — are in
+`.claude/rules/mermaid.md`. This skill carries the workflow and the generation recipes.
+
+Pinned Mermaid documentation version: **11.17.0**.
+
+## Workflow: Generate, Validate, Render
+
+1. **Determine the diagram type.** Pick from the per-type references below. When the type is
+   unfamiliar, read its reference file before generating; when the reference does not answer the
+   question, `WebFetch` the pinned documentation page (see [Syntax References](#syntax-references)).
+2. **Generate the syntax.** Follow the reference's first-line keyword form and its arrow token set.
+   Keywords are case-sensitive.
+3. **Write the diagram.** A standalone diagram goes in a `.mmd` file; a diagram that belongs to
+   prose goes in a fenced ` ```mermaid ` block in that document.
+4. **Validate.** The `Write` is gated automatically by
+   `.claude/hooks/enforce-mermaid-validation.ps1`. A deny names the defect class, the line number,
+   and points back here. To check before writing, call the validator directly:
+
+   ```powershell
+   Import-Module ./.claude/lib/mermaid/MermaidValidation.psm1 -Force
+   Test-MermaidDiagram -Content $diagramText
+   ```
+
+   The result carries `Verdict` (`Valid`, `Invalid`, `NotJudged`), `DiagramType`, `Findings` (each
+   with `Class`, `Line`, `Message`), and `Warnings`.
+5. **Render** per [Rendering](#rendering). Rendering is a workflow step, never something the hook
+   does: a hook is a non-interactive subprocess whose stdout belongs to the hook protocol.
+
+### What "validated" means here
+
+The gate rejects the defect classes listed in `.claude/rules/mermaid.md`. It does not parse and it
+cannot prove a diagram renders. Do not report a diagram as "validated" without that qualifier; say
+the structural gate accepted it. Semantic errors — an undefined node reference, a malformed gantt
+date, an invalid `classDef` property — pass the gate and still fail to render.
+
+## Generation Recipes
+
+Eight recipes, one per generation intent of the Copilot `@mermaid-chart` participant. Each names
+the source to read, the diagram type to emit, and the shape that survives review.
+
+### 1. Diagram from code (`/generate_diagram_from_code`)
+
+Read the entry point and follow control flow outward one level at a time. Emit a `flowchart`
+whose nodes are functions or modules and whose edges are calls. Keep node labels to the symbol
+name; put qualifiers in a quoted label rather than in the identifier. Stop at the first boundary
+the reader does not need (framework internals, third-party libraries) and mark it as one node.
+
+### 2. Execution sequence (`/generate_execution_sequence`)
+
+Emit a `sequenceDiagram`. One `participant` per process, service, or object that owns state;
+messages in call order; the message text after the first colon carries the payload summary. Use
+`-->>` for returns and `->>` for calls so the direction reads without the labels. Reserve `activate`
+and `deactivate` for lifetimes the reader must see; they add noise otherwise.
+
+### 3. ER diagram (`/generate_er_diagram`)
+
+Read the schema, ORM models, or migration files. Emit an `erDiagram`. One entity per table, the
+cardinality token pair chosen from the reference table, and the relationship label as the verb the
+domain uses. Include an attribute block only for the columns that carry the relationship (keys) or
+that the reader must see; a full column dump defeats the diagram.
+
+### 4. Cloud or CI/CD architecture (`/generate_cloud_architecture_diagram`)
+
+Read the infrastructure-as-code files and the workflow definitions. Emit a `flowchart` with one
+`subgraph` per environment, account, or region boundary, and `-.->` for asynchronous or
+event-driven edges against `-->` for synchronous ones. State the direction convention in a comment
+so the next reader keeps it.
+
+### 5. Docker architecture (`/generate_docker_diagram`)
+
+Read the Dockerfiles and the compose file. Emit a `flowchart` with one node per service, one
+`subgraph` per compose network, and edges labelled with the published or internal port. Show
+volumes as nodes only when a volume is shared between services.
+
+### 6. C4 top-down architecture (`/generate_c4_topdown_architecture`)
+
+Emit `C4Context` for the system landscape, then `C4Container` for the chosen system, then
+`C4Component` for the chosen container: one diagram per level, not one diagram with three levels.
+Keywords carry a capital `C4`. Relationships use the `Rel(...)` call form rather than arrow tokens.
+See `references/c4.md`.
+
+### 7. Code ownership (`/analyze_code_ownership`)
+
+Read `CODEOWNERS`, or derive ownership from directory structure when no such file exists. Emit a
+`flowchart` with one `subgraph` per owning team and the owned directories as nodes. When ownership
+is derived rather than declared, say so in the diagram title; an inferred ownership map presented
+as authoritative is worse than none.
+
+### 8. Dependency or security visualisation (`/generate_dependency_diagram`)
+
+Read the manifest and lock files. Emit a `flowchart` for the dependency graph, direct dependencies
+at the first level and transitive ones only where they matter to the question being asked. For a
+security view, mark the affected node with a `classDef` and state the advisory identifier in the
+label.
+
+## Rendering
+
+`Artifact` and `SendUserFile` are harness-dependent and are absent from some sessions. Take the
+first available path:
+
+1. **`Artifact` available.** Publish a Markdown artifact containing the ` ```mermaid ` fence. This
+   is the preferred path: no CSP handling and no theme handling, unlike an HTML artifact.
+2. **Else `SendUserFile` with `display: "render"` available.** Use it.
+3. **Else** state that the diagram was written to its path and name the viewing route: the Mermaid
+   Chart VS Code extension auto-previews `.mmd` and `.mermaid` files, the built-in VS Code Markdown
+   preview renders fenced blocks, and GitHub renders ` ```mermaid ` fences natively in Markdown,
+   pull requests, and issues.
+
+Never claim a diagram was rendered when only path 3 was taken. Say where it was written and how to
+view it.
+
+## Opt-Out Marker
+
+To quote invalid Mermaid deliberately, place the exact HTML comment on the line immediately before
+the fence:
+
+```text
+<!-- mermaid-validator: ignore -->
+```
+
+The marker suppresses validation for exactly that one block, must have no intervening line before
+the fence, applies only to Markdown fences, and never suppresses the managed-diagram guard. Full
+rules are in `.claude/rules/mermaid.md`.
+
+## Syntax References
+
+Per-type references under `references/`, pinned to Mermaid 11.17.0:
+
+| File | Covers |
+| --- | --- |
+| `references/flowchart.md` | `flowchart`, `graph`, `flowchart-elk` |
+| `references/sequence.md` | `sequenceDiagram` |
+| `references/class.md` | `classDiagram`, `classDiagram-v2` |
+| `references/state.md` | `stateDiagram-v2`, `stateDiagram` |
+| `references/er.md` | `erDiagram` |
+| `references/c4.md` | `C4Context`, `C4Container`, `C4Component`, `C4Dynamic`, `C4Deployment` |
+| `references/gantt.md` | `gantt` |
+| `references/pie.md` | `pie` |
+| `references/other-types.md` | every remaining keyword of the pinned table |
+
+**`WebFetch` fallback.** The references are a snapshot, not the documentation. When a construct is
+absent from them, or when a first-line keyword is not in the validator's allowlist, fetch the
+pinned page and confirm the form before generating:
+
+- entry point: `https://mermaid.js.org/intro/syntax-reference.html`
+- per-type pages: `https://mermaid.js.org/syntax/<type>.html`
+
+Confirming a keyword against the documentation is also the mechanism for updating
+`.claude/lib/mermaid/MermaidGrammar.psm1` when Mermaid adds a diagram type: the validator warns
+rather than blocks on an unknown keyword, so a warning is the signal to check and extend the table.
+
+## Out of Scope
+
+The VS Code extension mechanisms the Copilot instruction pack relies on are not reachable from a
+Claude Code session. The full disposition table, one row per mechanism with its reason and its
+replacement, is in `.claude/rules/mermaid.md` under "Out of Scope: The Non-Portable Extension
+Mechanisms". In summary: the three LM tools, the sixteen `mermaidChart.*` command IDs, the
+`@mermaid-chart` chat participants, and the Mermaid Chart cloud login/sync/review flows are not
+ported; validation, generation, preview, and sync cooperation are ported by substitution to the
+hook, these recipes, the rendering paths above, and the `id:` guard. Deep `mmdc`/Chromium
+validation in CI, and retrofitting the existing repository Mermaid emitters through this validator,
+are recorded follow-ups.
+
+## Worked Example
+
+```mermaid
+---
+title: Generate, validate, render
+---
+flowchart LR
+    A[Pick diagram type] --> B[Read references type page]
+    B --> C[Generate syntax]
+    C --> D{Structural gate}
+    D -->|deny with class and line| C
+    D -->|allow| E[Render or state the path]
+```

package/resources/claude-customizations/.claude/skills/mermaid-diagram/references/c4.md

@@ -0,0 +1,50 @@
+# C4 Diagram Syntax Reference
+
+Pinned to Mermaid **11.17.0**. Source: `https://mermaid.js.org/syntax/c4.html`.
+When a construct is absent here, `WebFetch` that page and confirm the form before generating.
+
+## First-line keyword forms
+
+`C4Context`, `C4Container`, `C4Component`, `C4Dynamic`, `C4Deployment`.
+
+The capital `C4` is part of the keyword. `c4context` does not resolve, and the validator is
+case-sensitive by design because Mermaid is.
+
+Emit one diagram per C4 level rather than one diagram spanning levels: context first, then the
+container view of the chosen system, then the component view of the chosen container.
+
+## Statement forms
+
+C4 uses call-style statements, not arrow tokens. The validator therefore keyword-checks a C4
+diagram and does not judge its body.
+
+- Elements: `Person(alias, label, description)`, `Person_Ext(...)`,
+  `System(alias, label, description)`, `System_Ext(...)`, `SystemDb(...)`, `SystemQueue(...)`,
+  `Container(alias, label, technology, description)`, `ContainerDb(...)`, `ContainerQueue(...)`,
+  `Component(alias, label, technology, description)`.
+- Boundaries: `Enterprise_Boundary(alias, label) { ... }`, `System_Boundary(...)`,
+  `Container_Boundary(...)`, `Boundary(alias, label, type)`. Braces are paired.
+- Relationships: `Rel(from, to, label, technology)` plus the directional variants `Rel_U`, `Rel_D`,
+  `Rel_L`, `Rel_R`, and `BiRel(...)` for a two-way relationship.
+- Layout: `UpdateLayoutConfig($c4ShapeInRow, $c4BoundaryInRow)`. Styling:
+  `UpdateElementStyle(alias, $bgColor, $fontColor, $borderColor)`,
+  `UpdateRelStyle(from, to, $offsetX, $offsetY)`.
+
+## Example
+
+```mermaid
+C4Context
+    title System context for the order service
+    Person(customer, "Customer", "Places and tracks orders")
+    Enterprise_Boundary(company, "Retail company") {
+        System(orders, "Order service", "Accepts and tracks orders")
+        System(billing, "Billing service", "Charges cards and issues refunds")
+        SystemDb(orderdb, "Order store", "Durable order records")
+    }
+    System_Ext(psp, "Payment provider", "Third-party card processing")
+    Rel(customer, orders, "Places an order", "HTTPS/JSON")
+    Rel(orders, orderdb, "Reads and writes", "SQL")
+    Rel(orders, billing, "Requests a charge", "internal API")
+    Rel(billing, psp, "Authorises the card", "HTTPS")
+    UpdateLayoutConfig($c4ShapeInRow="3", $c4BoundaryInRow="1")
+```

package/resources/claude-customizations/.claude/skills/mermaid-diagram/references/class.md

@@ -0,0 +1,63 @@
+# Class Diagram Syntax Reference
+
+Pinned to Mermaid **11.17.0**. Source: `https://mermaid.js.org/syntax/classDiagram.html`.
+When a construct is absent here, `WebFetch` that page and confirm the form before generating.
+
+## First-line keyword forms
+
+`classDiagram`, or the legacy-accepted `classDiagram-v2`.
+
+## Relation tokens
+
+A relation is composed as `<tail><line><head>`:
+
+| Token | Meaning |
+| --- | --- |
+| `<|--` / `--|>` | inheritance |
+| `*--` / `--*` | composition |
+| `o--` / `--o` | aggregation |
+| `-->` / `<--` | association |
+| `--` | link, solid |
+| `..>` / `<..` | dependency |
+| `..|>` / `<|..` | realization |
+| `..` | link, dashed |
+
+Cardinalities are quoted and sit outside the token: `Customer "1" --> "0..*" Order`.
+Generics use tilde runs: `List~T~`, and a tilde run is never an edge defect.
+
+## Structural conventions
+
+- A member block is `class <Name> { ... }` with `+`, `-`, `#`, `~` visibility prefixes; methods
+  carry `()`. Brackets and braces are structural in a class diagram, so every opener needs a closer.
+- A member may also be declared inline: `Animal : +String name`.
+- `namespace <Name> { ... }` groups classes.
+- Annotations use `<<interface>>` / `<<abstract>>` on their own line inside the block or after the
+  class name.
+- `classDef`, `cssClass`, `click`, `style`, `note`, `note for <Class>` are statement lines exempt
+  from the edge rules.
+- Text after the first `:` on a relation line is the relation label and is free text.
+
+## Example
+
+```mermaid
+classDiagram
+    direction LR
+    class Repository~T~ {
+        <<interface>>
+        +findById(id) T
+        +save(entity) void
+    }
+    class OrderRepository {
+        -connection
+        +findById(id) Order
+        +save(order) void
+    }
+    class Order {
+        +String id
+        +decimal total
+        +addLine(line)
+    }
+    Repository~T~ <|.. OrderRepository
+    OrderRepository ..> Order : returns
+    Order "1" --* "0..*" OrderLine : contains
+```

package/resources/claude-customizations/.claude/skills/mermaid-diagram/references/er.md

@@ -0,0 +1,56 @@
+# Entity Relationship Diagram Syntax Reference
+
+Pinned to Mermaid **11.17.0**. Source: `https://mermaid.js.org/syntax/entityRelationshipDiagram.html`.
+When a construct is absent here, `WebFetch` that page and confirm the form before generating.
+
+## First-line keyword form
+
+`erDiagram`.
+
+## Cardinality tokens
+
+A relationship token is `<left><line><right>`.
+
+| Position | Options |
+| --- | --- |
+| left | `\|o` (zero or one), `\|\|` (exactly one), `}o` (zero or more), `}\|` (one or more) |
+| line | `--` (identifying), `..` (non-identifying) |
+| right | `o\|` (zero or one), `\|\|` (exactly one), `o{` (zero or more), `\|{` (one or more) |
+
+Common complete forms: `||--||`, `||--o{`, `}o--o{`, `}|--|{`, `|o..o|`, `}|..|{`.
+
+Word aliases are also accepted in place of the token: `one or zero`, `zero or more`, `only one`,
+`1+`, `0+`, `many(0)`, `many(1)`, joined by `to` or `optionally to`.
+
+The relationship label follows the first `:` and is free text.
+
+## Structural conventions
+
+- An attribute block is `ENTITY { <type> <name> <key> "<comment>" }`. Braces are structural.
+- Key markers are `PK`, `FK`, `UK`; several may be comma-separated.
+- An entity name may be quoted when it is not identifier-shaped.
+- `%%` comments and the statement keywords behave as in every other type.
+
+## Example
+
+```mermaid
+erDiagram
+    CUSTOMER ||--o{ ORDER : places
+    ORDER ||--|{ ORDER_LINE : contains
+    PRODUCT }o--o{ ORDER_LINE : "appears in"
+    CUSTOMER {
+        string id PK
+        string email UK "lowercased on write"
+        string display_name
+    }
+    ORDER {
+        string id PK
+        string customer_id FK
+        decimal total
+    }
+    ORDER_LINE {
+        string order_id FK
+        string product_id FK
+        int quantity
+    }
+```

package/resources/claude-customizations/.claude/skills/mermaid-diagram/references/flowchart.md

@@ -0,0 +1,68 @@
+# Flowchart Syntax Reference
+
+Pinned to Mermaid **11.17.0**. Source: `https://mermaid.js.org/syntax/flowchart.html`.
+When a construct is absent here, `WebFetch` that page and confirm the form before generating.
+
+## First-line keyword forms
+
+- `flowchart` followed optionally by a direction: `TB`, `TD`, `BT`, `LR`, `RL`. The direction is
+  optional and defaults to `TB`.
+- `graph` with the same optional direction. Accepted and equivalent for the validator's purposes.
+- `flowchart-elk` selects the ELK layout variant.
+- A trailing `;` on the keyword line is accepted (`graph LR;`).
+
+## Edge tokens
+
+| Token | Meaning |
+| --- | --- |
+| `-->` | arrow |
+| `---` | open link |
+| `-.->` | dotted arrow |
+| `-.-` | dotted open link |
+| `==>` | thick arrow |
+| `===` | thick open link |
+| `~~~` | invisible link |
+| `--o` | circle edge |
+| `--x` | cross edge |
+| `o--o`, `x--x`, `<-->` | bidirectional forms |
+
+Length variants extend the dash, dot, or equals run (`---->`, `====>`, `-...->`) and rank the edge
+lower in layout. Text forms: `A -- text --> B`, `A -->|text| B`, `A -. text .-> B`,
+`A == text ==> B`.
+
+## Node shapes
+
+`A[rect]`, `A(round)`, `A([stadium])`, `A[[subroutine]]`, `A[(cylinder)]`, `A((circle))`,
+`A>asymmetric]`, `A{rhombus}`, `A{{hexagon}}`, `A[/parallelogram/]`, `A[\parallelogram alt\]`,
+`A[/trapezoid\]`, `A(((double circle)))`.
+
+Brackets are structural in a flowchart, so every opener needs its closer. A bracket inside a quoted
+label is content, not structure: `A["foo[bar](baz)"]` is valid.
+
+## Structural conventions
+
+- `subgraph <id> [<free-text title>]` opens a block; `end` closes it. A `direction` statement inside
+  a subgraph sets that subgraph's direction.
+- Statement lines are exempt from edge and bracket rules: `click`, `style`, `classDef`, `linkStyle`,
+  `class`, `accTitle`, `accDescr`, `title`.
+- `%%` starts a comment outside a quoted span. `%%{init: {...}}%%` is a directive, not a comment.
+- Labels may carry HTML (`<br/>`, `<b>`) and Markdown strings in backticks. Angle brackets are never
+  structural.
+- Mermaid has no backslash escape; use the `#quot;` entity for a double quote inside a label.
+
+## Example
+
+```mermaid
+flowchart LR
+    A[Client] --> B{Authenticated}
+    B -->|yes| C[Handler]
+    B -->|no| D((Reject))
+    subgraph backend [Backend services]
+        direction TB
+        C --> E[(Database)]
+        C -.-> F[Queue]
+    end
+    click C "https://example.com/handler" "Open the handler"
+    classDef hot fill:#f96,stroke:#333
+    class E hot
+```

package/resources/claude-customizations/.claude/skills/mermaid-diagram/references/gantt.md

@@ -0,0 +1,51 @@
+# Gantt Chart Syntax Reference
+
+Pinned to Mermaid **11.17.0**. Source: `https://mermaid.js.org/syntax/gantt.html`.
+When a construct is absent here, `WebFetch` that page and confirm the form before generating.
+
+## First-line keyword form
+
+`gantt`.
+
+## Body form
+
+A gantt body is free text to the validator: it carries no edge tokens, and brackets and parentheses
+are not structural. A task named `Deploy (phase 1` is accepted by the gate even though it is
+untidy, because rejecting it would be a false positive. The date and duration grammar is not
+structurally checkable either, so a malformed date passes the gate and fails to render — check
+dates by reading them.
+
+Statement lines:
+
+- `title <free text>`
+- `dateFormat <format>` — the input format of the task dates, for example `YYYY-MM-DD`.
+- `axisFormat <format>` — the output format of the axis, for example `%Y-%m-%d`.
+- `tickInterval <n><unit>` — for example `1week`, `2day`.
+- `excludes <weekends|YYYY-MM-DD|monday..sunday>`
+- `todayMarker <off|stroke:...>`
+- `section <free text>` opens a section; sections need no closing statement.
+
+## Task form
+
+`<task label> :<tags>, <id>, <start or dependency>, <duration or end>`
+
+- Tags: `done`, `active`, `crit`, `milestone`.
+- The start may be a literal date, `after <id>`, or omitted to continue from the previous task.
+- The duration is a number with a unit (`3d`, `2w`, `12h`) or an explicit end date.
+
+## Example
+
+```mermaid
+gantt
+    title Order service rollout
+    dateFormat YYYY-MM-DD
+    axisFormat %m-%d
+    excludes weekends
+    section Preparation
+    Schema migration          :done,   mig,  2026-01-05, 3d
+    Contract tests            :active, ct,   after mig, 4d
+    section Rollout
+    Deploy to staging         :crit,   stg,  after ct, 2d
+    Soak (24 hours minimum)   :        soak, after stg, 1d
+    Production cutover        :milestone, prod, after soak, 0d
+```

package/resources/claude-customizations/.claude/skills/mermaid-diagram/references/other-types.md

@@ -0,0 +1,82 @@
+# Remaining Diagram Types
+
+Pinned to Mermaid **11.17.0**. Entry point: `https://mermaid.js.org/intro/syntax-reference.html`;
+per-type pages at `https://mermaid.js.org/syntax/<type>.html`. When a construct is absent here,
+`WebFetch` the type's page and confirm the form before generating.
+
+Every type on this page is **keyword-checked only** by the structural gate: the validator confirms
+the first-line keyword and declines to judge the body, because these grammars are free text,
+indentation-structured, CSV-like, or supplied by an external plugin. A body defect in one of these
+types therefore passes the gate and fails to render. Read the body.
+
+## Verified keyword forms
+
+| Keyword | Type | Body shape |
+| --- | --- | --- |
+| `journey` | User journey | `section <name>` then `Task: <score>: <Actor>, <Actor>` rows |
+| `quadrantChart` | Quadrant chart | `x-axis`, `y-axis`, `quadrant-1`..`quadrant-4`, then `"<label>": [x, y]` points |
+| `requirementDiagram` | Requirement diagram | `requirement`/`element` blocks in braces; relationships as `<a> - <verb> -> <b>` |
+| `gitGraph` | Git graph | `commit`, `branch`, `checkout`, `merge`, `cherry-pick`. Accepts a direction and trailing colon: `gitGraph LR:`, `gitGraph TB:`, `gitGraph BT:` |
+| `mindmap` | Mind map | indentation-structured; node shapes `((circle))`, `))cloud((`, `)bang(`, `{{hexagon}}` |
+| `timeline` | Timeline | `title`, optional `section`, then `<period> : <event> : <event>` rows |
+| `zenuml` | ZenUML sequence | requires the external `@mermaid-js/mermaid-zenuml` plugin even in browser Mermaid; the gate keyword-accepts and never judges the body |
+| `sankey-beta` | Sankey diagram | CSV-like `source,target,value` rows |
+| `xychart-beta` | XY chart | `title`, `x-axis`, `y-axis`, `bar [..]`, `line [..]`. Accepts the `horizontal` modifier: `xychart-beta horizontal` |
+| `block-beta` | Block diagram | `columns <n>`, block ids, `space`, flowchart-style arrows between blocks |
+| `packet` | Packet diagram | `<start>-<end>: "<name>"` rows. `packet-beta` was the earlier keyword and remains accepted |
+| `kanban` | Kanban board | indentation-structured columns and cards |
+| `architecture-beta` | Architecture diagram | `group`, `service`, `junction`; edges carry port syntax `L`/`R`/`T`/`B`, as in `db:L -- R:server` |
+| `radar-beta` | Radar chart | axis list then per-series value rows |
+| `treemap-beta` | Treemap | indentation plus `"<label>": <value>` rows |
+| `info` | Version info | no body; renders the Mermaid version |
+
+## Keyword-accept rows: documented types, unverified keyword form
+
+These types appear in the 11.x documentation sidebar, but their exact first-line keyword form was
+not individually verified against the pinned pages. The validator resolves them and records a drift
+warning rather than judging the body, so neither spelling costs a false rejection. Confirm the form
+by `WebFetch` before relying on one.
+
+`swimlanes`, `eventmodeling`, `venn`, `ishikawa`, `wardley`, `cynefin`, `treeView`, `railroad`
+(`railroad-beta`).
+
+## Version drift
+
+The allowlist in `.claude/lib/mermaid/MermaidGrammar.psm1` is a snapshot of 11.17.0, and Mermaid adds
+diagram types several times a year. An unknown but keyword-shaped first-line token produces a drift
+warning and is allowed. That warning is the signal to confirm the keyword against the documentation
+and add it to the table; it is never a reason to abandon the diagram.
+
+One exception: a token within a single character of a known keyword and at least five characters
+long is reported as a misspelling and denied, because a typo is a defect the gate is required to
+name. `flowchar TD` is a misspelling of `flowchart`, not a new diagram type.
+
+## Examples
+
+```mermaid
+gitGraph LR:
+    commit id: "init"
+    branch feature
+    checkout feature
+    commit id: "work"
+    checkout main
+    merge feature
+```
+
+```mermaid
+timeline
+    title Release history
+    2026-01 : 1.0 shipped : docs published
+    2026-02 : 1.1 shipped
+```
+
+```mermaid
+journey
+    title Order placement
+    section Browse
+      Search catalogue: 4: Customer
+      Read reviews: 3: Customer
+    section Checkout
+      Enter payment: 2: Customer
+      Confirm order: 5: Customer, System
+```

package/resources/claude-customizations/.claude/skills/mermaid-diagram/references/pie.md

@@ -0,0 +1,32 @@
+# Pie Chart Syntax Reference
+
+Pinned to Mermaid **11.17.0**. Source: `https://mermaid.js.org/syntax/pie.html`.
+When a construct is absent here, `WebFetch` that page and confirm the form before generating.
+
+## First-line keyword forms
+
+- `pie`
+- `pie showData` — the modifier appends each slice's numeric value to its legend label.
+
+## Body form
+
+- `title <free text>` is optional and appears above the chart.
+- Each data row is `"<label>" : <number>`. The label is double-quoted; the value may be an integer
+  or a decimal. Mermaid computes the percentages, so values need not sum to 100.
+- Up to twelve slices render with distinct default colours; beyond that the palette repeats, so
+  aggregate the tail into one slice rather than emitting twenty.
+
+The body carries no edge tokens and no structural brackets, so the validator keyword-checks a pie
+chart and does not judge the body. An unquoted label or a non-numeric value passes the gate and
+fails to render; read the rows.
+
+## Example
+
+```mermaid
+pie showData
+    title Test suite composition
+    "Unit" : 271
+    "Hook" : 28
+    "Contract" : 15
+    "Distribution" : 3
+```

package/resources/claude-customizations/.claude/skills/mermaid-diagram/references/sequence.md

@@ -0,0 +1,63 @@
+# Sequence Diagram Syntax Reference
+
+Pinned to Mermaid **11.17.0**. Source: `https://mermaid.js.org/syntax/sequenceDiagram.html`.
+When a construct is absent here, `WebFetch` that page and confirm the form before generating.
+
+## First-line keyword form
+
+`sequenceDiagram`. No direction modifier.
+
+## Message tokens
+
+| Token | Meaning |
+| --- | --- |
+| `->` | solid line, no arrowhead |
+| `-->` | dotted line, no arrowhead |
+| `->>` | solid line with arrowhead |
+| `-->>` | dotted line with arrowhead |
+| `<<->>` | solid bidirectional |
+| `<<-->>` | dotted bidirectional |
+| `-x` | solid line with a cross (async, lost) |
+| `--x` | dotted line with a cross |
+| `-)` | solid line with an open arrow (async) |
+| `--)` | dotted line with an open arrow |
+
+Half-arrow variants (`-\`, `-/` families) were added in 11.12.3 and later.
+
+Everything after the first `:` on a message line is free text: it may contain dashes, angle
+brackets, and brackets, and it is never edge-checked. Only the pre-colon segment carries the
+message token.
+
+## Structural conventions
+
+- `participant <id> as <label>` and `actor <id>` declare lifelines; declaration order fixes the
+  left-to-right order.
+- `activate <id>` / `deactivate <id>`, or a `+`/`-` suffix on the message token, mark activation.
+- Block keywords: `loop`, `alt`, `else`, `opt`, `par`, `and`, `critical`, `break`, `rect`, `box`.
+  Each block is closed by `end`.
+- `Note left of <id>`, `Note right of <id>`, `Note over <id>,<id>` place notes.
+- `autonumber` numbers messages. `create participant <id>` and `destroy <id>` manage lifeline
+  lifetime.
+- Brackets are NOT structural in a sequence diagram, because message text routinely contains them.
+
+## Example
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant C as Client
+    participant A as API
+    participant D as Database
+    C->>A: POST /orders [payload 2 - 3 items]
+    activate A
+    A->>D: INSERT order
+    D-->>A: order id
+    A-->>C: 201 Created
+    deactivate A
+    alt payment declined
+        A-->>C: 402 Payment Required
+    else accepted
+        A-)C: webhook: order.confirmed
+    end
+    Note over C,A: Retry policy is 3 attempts
+```