@milehimikey/em 0.1.0 → 0.2.0

package/.claude/skills/event-modeling/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: event-modeling
+description: >-
+  Guide a user and their team through building rigorous Event Models with the `em` CLI, using
+  the 7 steps of Event Modeling and the 4 patterns (State Change, State View, Automation,
+  Translation), and produce implementation-ready slice design documents. Use when the user wants
+  to event-model a business process or system, do event modeling / event storming, design slices,
+  build or edit an `.em` model, or run the em tool. Works in resumable phases via an argument:
+  `discover` (steps 1-4), `model` (steps 5-7), `slice` (deep slice specs), plus `watch` and
+  `validate`. With no argument it resumes from the saved state file.
+---
+
+# Event Modeling with `em`
+
+You are facilitating an Event Modeling session. Your job is to **extract an accurate model from
+the user through Socratic questioning** — never to invent the domain. You drive the `em` CLI to
+render the model live, and you produce implementation-ready slice design docs.
+
+Read `reference/methodology.md` (the 7 steps + 4 patterns) and `reference/em-dsl.md` (DSL syntax
++ validation rules) before doing real work — they are the source of truth. Templates live in
+`templates/`.
+
+## Operating principles (every phase)
+
+- **Socratic, one question at a time.** Ask focused questions; use `AskUserQuestion` for tight
+  multiple-choice decisions. Never assume a domain fact — extract it. Prefer "who/why/what-if/
+  what-must-always-be-true/how-do-you-know" over yes-no.
+- **Don't guess — park it.** Unresolved items go into the Open Questions list in
+  `.event-modeling.md`, not into invented model content.
+- **Happy path first; branches belong to slicing.** Steps 1-7 build the **happy-path spine**.
+  Alternate, unhappy, and exception-path events (rejections, removals, cancellations,
+  expirations, declines) are **not** enumerated as a separate discover/model task — they
+  surface during the `slice` phase as each slice's alternate/error flows and rule-boundary
+  scenarios, and any new branch events get added to the `.em` then. Never list "draft the
+  branch events" as a discover/model to-do or ask the user to do it before slicing.
+- **Reflect and re-render.** After each meaningful increment, update the `.em` file, re-render,
+  and show the user what changed. Encourage running the live view (`watch`) so a team can follow.
+- **Keep the `.em` structural; put depth in `note` docs.** The diagram holds flow; invariants,
+  fields, and scenarios live in `slices/*.md` linked via `note "slices/<name>.md"`.
+- **No UI in headless/API models.** If the system is headless (clients call an API, not screens),
+  use no `ui`/`persona`: writes are `external translation → command → event` (name the inbound
+  adapter for the caller/role); reads are `read model → read translation` (an API query that
+  triggers **no** command — the analog of `view → ui`). **Repeat read models** across slices so the
+  timeline flows left-to-right — put each repeat **right after the event that feeds it**, sourcing
+  only that one adjacent event, so every arrow is short (a read model far from its source events
+  draws long arrows that look like a forbidden read→read link). Repeats render cleanly — em only
+  warns on a duplicate name that's *referenced* by `from`/`arrow`. Slice order matters: a reaction
+  must be directly followed by its command slice, and a read slice must not be (see `em-dsl.md`).
+  See `reference/methodology.md` (State View) and `reference/em-dsl.md`.
+- **Validate continuously.** Run `em validate` and fix errors/warnings as you go (see DSL ref).
+- **Save state at the end of every session** so work resumes cleanly.
+
+## Preconditions (run first)
+
+1. Check the tool: `em --version`. If missing, tell the user to run `npm i -g @milehimikey/em`
+   and stop until installed.
+2. Locate the model. Look for an existing `<dir>/.event-modeling.md` and `*.em` in the working
+   directory (or a `models/` subfolder). If found, read the state file. If not, and the phase
+   needs one, ask the user for the model name and where to create it.
+3. Parse the argument (`$ARGUMENTS`) to pick the phase below. With **no argument**, read the
+   state file and resume the recorded phase/step; if no model exists, propose starting `discover`.
+
+## Project layout this skill creates
+
+```
+<model-name>/
+  <model-name>.em          # the model (slice docs linked via note "...")
+  <model-name>.svg         # render target for em watch
+  live.html                # auto-refresh viewer (copy of templates/live.html, SVG_FILE set)
+  README.md                # overview + slice index (from templates/model-readme.md)
+  .event-modeling.md       # resumable state (from templates/state.md)
+  slices/<slice-name>.md   # one rich slice doc per slice (from templates/slice.md)
+```
+
+When creating a new model, scaffold the directory, copy the templates in (filling the
+placeholders), and set `SVG_FILE` in the copied `live.html` to `<model-name>.svg`. You may use
+`em init` for a starter `.em`, but usually you'll build it up from the discovery conversation
+instead. Fill template placeholders — never leave `{{...}}` in delivered files.
+
+---
+
+## Phase: `discover` — steps 1-4
+
+Goal: a draft model of events, storyboard, commands, and views. Loose is OK; structure comes next.
+
+1. **Brainstorm events (step 1).** Ask the user to name everything that happens, as past-tense
+   facts. Capture a flat list. Probe for missed state changes.
+2. **Plot / storyboard (step 2).** Order the events into the narrative. Identify **personas**
+   (actors) and the **UI** screens at each step. Add `persona` declarations and `ui` elements.
+3. **Inputs (step 3).** For each event, find the **command** that causes it (imperative name).
+   Form `command → event` slices (State Change pattern).
+4. **Outputs (step 4).** Identify the **read models / views** consumers need and wire them with
+   `from "Event"` (State View pattern). In a **headless/API** model there is no UI — a read model is
+   consumed by an **external read translation** (the API query, triggers no command), and read
+   models are **repeated** in each slice where they're read so the timeline flows (see
+   `reference/methodology.md`).
+
+End of phase: write/refresh the `.em`, render it, update `.event-modeling.md` (steps done,
+decisions, open questions, slice inventory). Tell the user they can stop here and resume with
+`/event-modeling model`.
+
+## Phase: `model` — steps 5-7
+
+Goal: a structurally complete, **validated** model with correct patterns and swimlanes.
+
+1. **Swimlanes & patterns (step 5).** Group events into **contexts** (bounded contexts /
+   aggregates) — ask which events share a consistency boundary and who owns them. Classify each
+   slice as one of the 4 patterns. **Split every automation _and every translation_ across two
+   slices** (the reaction — processor/translation — plus its read model in one slice; the
+   triggered command + its event in the *next* slice). A translation or automation is a reaction:
+   it **triggers a command and never records an event directly**. Add `translation` slices for
+   external inputs (externally triggered: external → translation → command → event) and for the
+   system reacting to its own state (internally triggered: read model → translation → command →
+   event).
+2. **Elaborate scenarios — first pass (step 6).** For each slice, capture the happy-path
+   Given/When/Then and the obvious invariants as short notes. (The full spec is the `slice` phase.)
+3. **Evaluate completeness (step 7).** Walk the model: every command emits an event, every view
+   has a source, no orphan events, every UI is reachable, automations **and translations** split
+   correctly (each reaction triggers a command — none wired straight to an event). Run
+   `em validate` and resolve all errors and warnings — but check the reaction→command→event split
+   by hand, since `em validate` does **not** flag a translation/automation that emits an event
+   directly (see `reference/em-dsl.md`).
+
+End of phase: render, update state, suggest `/event-modeling slice` to write implementation specs.
+
+## Phase: `slice` — deep slice documents
+
+Goal: implementation-ready specs. Go slice by slice (let the user pick order, or follow the
+timeline). Check the state file's slice inventory for what's already done.
+
+This is also where **branch / unhappy-path events** are discovered and added to the model — as a
+slice's alternate/error flows surface (a rejection, removal, cancellation, decline, expiry), add
+the corresponding event/slice to the `.em` and re-render. The happy-path spine from earlier
+phases is the starting point, not the finished event set.
+
+For each slice:
+1. Hold a Socratic deep-dive to fill every section of `templates/slice.md`: intent, trigger/actor,
+   command + field table (types & rules), event(s) + payload (mark immutable facts), invariants
+   (give each a stable ID), Given/When/Then scenarios (happy path + rule boundaries + edge cases),
+   alternate/error flows (retries, idempotency, compensations), read models affected, open
+   questions. Park anything unresolved rather than guessing.
+2. Write the doc to `slices/<slice-name>.md` (kebab-case the slice name).
+3. Wire it into the `.em`: add `note "slices/<slice-name>.md"` to the slice's primary element
+   (the command for State Change, the view for State View, the processor for Automation, the
+   translation for Translation).
+4. Update `README.md`'s slice index and the state file's slice inventory (`draft` → `ready`).
+5. Re-render and `em validate`.
+
+## Phase: `watch` — live team view
+
+1. Ensure `live.html` exists in the model dir (copy from `templates/live.html`) with `SVG_FILE`
+   set to `<model-name>.svg`.
+2. Start the watcher in the background: `em watch <model-name>.em -o <model-name>.svg`
+   (run_in_background). It re-renders the SVG on every save.
+3. Tell the user to open `live.html` in a browser and share their screen — it auto-refreshes ~1s,
+   so the team sees the model evolve as you edit during the session. (`em` has no built-in server;
+   the HTML viewer provides the auto-reload.)
+
+## Phase: `validate`
+
+Run `em validate <model-name>.em` and walk through each diagnostic with the user, explaining the
+rule (see `reference/em-dsl.md`) and proposing the fix (e.g. split an automation's command into
+the next slice, add a missing `from`, give a command its event). Apply fixes on agreement.
+
+Then do one check `em validate` can't: scan every `translation`/`processor`/`automation` slice and
+confirm none contains an `event` — each reaction must trigger a `command` in the next slice
+(`reaction → command → event`). If you find a reaction wired straight to an event, split it into
+two slices and route it through a command.
+
+---
+
+## em command reference (quick)
+
+```bash
+em --version
+em init <name>.em                          # optional starter scaffold
+em validate <name>.em                      # check rules; exit 0 if clean/warnings only
+em render <name>.em -o <name>.svg          # render (svg/png/pdf by extension)
+em render <name>.em --emit-dot             # inspect generated Graphviz DOT
+em watch <name>.em -o <name>.svg           # re-render on save (run in background)
+```
+
+Always finish a working session by: re-rendering, running `em validate`, and updating
+`.event-modeling.md` with the current phase/step, decisions, and open questions.

package/.claude/skills/event-modeling/reference/em-dsl.md

@@ -0,0 +1,193 @@
+# `em` DSL Reference & Cheatsheet
+
+The `em` tool (`@milehimikey/em`) is a slice-first text DSL rendered to a strict Graphviz
+swimlane grid. Use this reference so the models you generate are **valid** and render cleanly.
+Keep `.em` files focused on **structure**; put deep design in markdown linked via `note`.
+
+---
+
+## CLI
+
+```bash
+em init [file]                 # scaffold a starter model.em (default: model.em); -f to overwrite
+em render <file> -o out.svg    # render (extension picks format: svg, png, pdf)
+em render <file> --emit-dot    # print the Graphviz DOT instead of rendering
+em render <file> --keep-empty-lanes   # keep the API lane even when empty
+em watch  <file> -o out.svg    # re-render on every save (file-based; no HTTP server)
+em validate <file>             # check event-modeling rules; exit 0 if only warnings/clean
+```
+
+Install if missing: `npm i -g @milehimikey/em`. PNG works with no system deps; PDF needs
+`rsvg-convert`.
+
+---
+
+## Grammar
+
+```
+model "Name"                     # diagram title
+
+persona Name                     # a UI swimlane row (actor)
+context Name                     # an event swimlane row (bounded context / aggregate)
+
+slice "Name" {                   # one vertical time step (a column)
+  ui   Free Text @Persona        # screen; @Persona picks its row (defaults to first/"User")
+  command Free Text              # state-changing request (API band)
+  view Free Text from "Event A", "Event B"   # read model fed by event(s)
+  event Free Text @Context       # recorded fact; @Context picks its row (defaults to "Domain")
+  processor Free Text from "View"   # automation; aliases: automation | saga | translation
+}
+
+arrow From Element -> To Element    # explicit cross-slice edge (overrides inferred flow)
+```
+
+### Element kinds (8 keywords, nothing else)
+| Keyword | Band | Meaning | Tag | Extra clauses |
+|---|---|---|---|---|
+| `ui` | persona | screen / interface | `@Persona` | `note`, `{ fields }` |
+| `command` | API | state-changing request | — | `note`, `{ fields }` |
+| `view` | API | read model / projection | — | `from "Event"…`, `note`, `{ fields }` |
+| `event` | context | recorded fact (past tense) | `@Context` | `note`, `{ fields }` |
+| `processor` / `automation` / `saga` / `translation` | automation | system reaction / adapter | — | `from "…"`, `note`, `{ fields }` |
+
+### Clauses
+- **Tags:** `@Persona` only on `ui`; `@Context` only on `event`. Undeclared tags auto-create a row.
+- **`from "X"`** on views/automations declares the source(s); names are quoted, comma-separated.
+  Matching is case-insensitive and whitespace-normalized.
+- **`note "path.md"`** on ANY element links a markdown doc. Relative to the `.em` file. Renders as
+  a clickable marker in SVG and a legend entry in PNG/PDF. **This is how slice docs attach.**
+- **Fields:** `command Place Order { orderId: UUID, items: LineItem[], customerId }` — inline or
+  one-per-line. Types are free text (no semantic checking). Keep these light; full field specs
+  with rules live in the slice doc.
+- **Comments:** `# ...` anywhere outside quotes (full-line or trailing).
+
+### Swimlane band order (top → bottom)
+Header row → **Automation** (only if used) → **persona** rows (in declared order) → **API**
+(commands + views share this lane) → **context** rows (in declared order).
+
+### Colors (for orientation)
+UI = white, command = blue, event = amber/orange, view = green, automation = gray.
+
+---
+
+## Pattern → DSL mapping
+
+```em
+# 1. State Change: UI -> Command -> Event
+slice "Place Order" {
+  ui Checkout @Customer
+  command Place Order
+  event Order Placed @Order
+}
+
+# 2. State View: Event(s) -> Read Model -> UI
+slice "Open Orders" {
+  view Open Orders from "Order Placed"
+  ui Order List @Customer
+}
+
+# 3. Automation: split across TWO slices
+slice "Orders To Fulfill" {
+  view Orders To Fulfill from "Order Placed"
+  processor Fulfillment Service
+}
+slice "Ship Order" {            # the triggered command goes in the NEXT slice
+  command Ship Order
+  event Order Shipped @Shipping
+}
+
+# 4a. Translation (external trigger): external input -> translation -> command -> event
+slice "Carrier Webhook" {
+  translation Carrier Adapter         # inbound from outside the model; no internal `from`
+}
+slice "Confirm Delivery" {            # the triggered command goes in the NEXT slice
+  command Confirm Delivery
+  event Delivery Confirmed @Shipping
+}
+
+# 4b. Translation (internal trigger): read model -> translation -> command -> event
+slice "Quotes To Sync" {
+  view Accepted Quotes from "Quote Accepted"
+  translation CRM Sync                # reacts to our own state via the read model in this slice
+}
+slice "Record Sync" {
+  command Record Crm Sync
+  event Quote Synced @Quote
+}
+```
+
+A `translation` (like a `processor`) is a **reaction**: it triggers a command and never carries an
+`event` in its own slice. Same two-slice split as the Automation pattern above.
+
+### Headless / API systems (no UI) & repeated read models
+
+When the system is headless (no UI — clients call an API), drop `ui`/`persona` entirely:
+
+```em
+# Write: external translation -> command -> event (name the inbound adapter for the caller/role)
+slice "Create Quote (request)" { translation SalesRep BU Create Quote }
+slice "Create Quote"           { command Create Quote  event QuoteCreated @Quote }
+
+# Read: event(s) -> read model -> READ translation (the external caller's API query, replaces UI)
+slice "Read Quote — created"   { view Quote from "QuoteCreated"  translation SalesRep BU Read Quote }
+```
+
+- A **read translation triggers no command** (it returns data outbound) — it is the headless analog
+  of `view → ui`, *not* a reaction. Only *reaction* translations/processors trigger commands. A read
+  slice has no `command` and no `event`, so `em validate` stays quiet about it.
+- **Repeat the read model** in every slice where it's read so the timeline flows left-to-right.
+  Recurring `view`/`translation` names **render cleanly and stay warning-free** as long as nothing
+  references the repeated name via `from`/`arrow` (the duplicate-name warning fires only for a
+  *referenced* duplicate, resolving to the first). **Wire each event to a read model exactly once:**
+  a repeated instance's `from` lists only the **new** events since the previous instance (not
+  cumulative), or the event draws a duplicate arrow to the same read model at every repeat. (An
+  event may still feed several *different* read models, once each.)
+- **Keep arrows span-1: put each repeat right after its feeding event.** Place a read-model instance
+  immediately after the event that updates it, sourcing only that single adjacent event. A read
+  model far from its source events draws long arrows that cross the read-model row and read as
+  read→read (an Event Modeling violation) — repeat the read model next to each event instead.
+
+### Slice-ordering gotchas (edge inference)
+
+`em` infers cross-slice arrows positionally, so **slice order matters**:
+- A **reaction** (`processor`/`translation` that triggers a command) wires to the command in the
+  **immediately next** slice. So a reaction slice must be *directly* followed by its command slice —
+  don't insert a read slice between them.
+- A **read** slice (read model → read translation, no command) must **not** be immediately followed
+  by a `command` slice, or the read translation will be mis-wired to that command. Put reads after a
+  command+event slice, or before another read / a reaction / an inbound `(request)` slice.
+
+---
+
+## `em validate` rules (design to satisfy these)
+
+**Errors (must fix):**
+1. **Band collision** — two elements of the same band in one slice (e.g. two `command`s, or two
+   `ui`s in the *same* persona row). Split them into separate slices/personas.
+2. **Unknown event source** — `view X from "Event"` where the event doesn't exist anywhere.
+3. **Unknown read-model source** — `processor X from "View"` where the view doesn't exist.
+4. **Arrow endpoint mismatch** — `arrow A -> B` where A or B matches no element name.
+
+**Warnings (should fix):**
+1. **Automation/translation shares slice with its command** — both `automation`/`processor` and
+   `translation` are reactions; put the triggered command in the *next* slice.
+2. **Command without event** — every command should record at least one event.
+3. **Read model without source** — add `from "Event"` or place the view in a slice with an event.
+4. **Duplicate name** — the same name defined N times; references resolve to the first. Rename.
+
+**Design rules that keep models valid:**
+- One element per band per slice (multiple personas/contexts are fine — they're different rows).
+- Every `command` slice includes its `event`. Every `view` has a `from` source.
+- Automations **and translations** are always two slices: the reaction (plus its read model, if
+  internally triggered) in one slice, the triggered `command` + its `event` in the next. A
+  translation/automation slice **never contains an `event`** — reactions trigger commands, not
+  events. Externally-triggered reactions start from outside the model (no `from`);
+  internally-triggered ones read a **view** (read model) — `from "X"` must resolve to a view.
+- Name everything uniquely and consistently.
+- Events are past tense; commands are imperative; views name the thing shown.
+
+> ⚠️ **Validator blind spot:** `em validate` does **not** flag a translation/automation that emits
+> an event directly (e.g. `translation T` and `event E` in the same slice with no command). It only
+> warns when a reaction shares a slice with a *command*. So enforce the two-slice
+> `reaction → command → event` split **by construction** — never rely on `em validate` to catch a
+> reaction wired straight to an event.

package/.claude/skills/event-modeling/reference/methodology.md

@@ -0,0 +1,177 @@
+# Event Modeling — Methodology Reference
+
+This is the authoritative reference for the **7 steps** and **4 patterns** of Event Modeling
+(Adam Dymitruk's method). Consult it while running any phase of the `event-modeling` skill.
+Do not invent domain facts — use the Socratic prompts to extract them from the user.
+
+---
+
+## Core idea
+
+An event model is a **timeline of state changes** told as a story. Information only moves
+three ways:
+
+1. **Into** the system via a **command** (a request to change state) → produces an **event**.
+2. **Out of** the system via a **read model / view** (a projection of past events) → shown on a **UI** or consumed by an automation.
+3. There is **no other way** for information to flow. Every box on the diagram is one of:
+   UI screen, command, event, read model, or automation/processor.
+
+**Automations and translations are not exceptions to rule 1.** They are *reactions* — a processor
+or an adapter that wakes up, decides something must change, and **issues a command** to do it. They
+never record an event themselves. A reaction box always points at a **command** (in the next
+slice), and that command produces the event. If you ever see a translation or automation wired
+straight to an event, the model is wrong.
+
+Events are **immutable past-tense facts** ("Order Placed", "Payment Captured"). They are the
+spine of the model. Everything else hangs off the events.
+
+The unit of delivery is a **slice**: a thin vertical cut through the swimlanes that delivers
+one of the four patterns. A slice is what a developer implements and tests in isolation.
+
+---
+
+## The 4 patterns
+
+Every slice is exactly one of these. In `em`, each maps to a specific shape (see `em-dsl.md`).
+
+### 1. State Change (Command pattern)
+**UI → Command → Event.** A user (or automation) submits a command; the system validates it
+against invariants and records one or more events.
+- `em` shape: `slice { ui X @Persona  command Y  event Z @Context }`
+- This is where **invariants** live — the command is rejected if a rule is violated.
+- Socratic prompts: *"What does the user do here? What request are they making? What must be
+  true for it to succeed? What fact gets recorded when it does? What gets rejected and why?"*
+
+### 2. State View (View pattern)
+**Event(s) → Read Model → UI.** Past events are projected into a read model that a screen
+displays. Read-only; changes no state.
+- `em` shape: `slice { view V from "Event A", "Event B"  ui Screen @Persona }`
+- **Headless / API systems (no UI):** when there is no UI, a read model is consumed by an
+  **external caller querying the API**, modeled as a **read translation** — the outbound analog of
+  `→ ui`. Shape: `slice { view V from "..."  translation <Caller> Read <V> }`. A read translation
+  **triggers no command** (it returns data); it is *not* a reaction, so the
+  `reaction → command → event` rule does **not** apply to it. (Contrast: a *reaction* translation in
+  pattern 4 triggers a command.)
+- **Repeat read models across the timeline.** A read model is drawn fresh in **every** slice where
+  it is read — after the events that update it, before the actions that consume it — so the diagram
+  shows state flowing left-to-right (the information-completeness staircase). The same read-model
+  name recurring is intentional and **renders cleanly**: `em validate` only warns about a duplicate
+  name that is *also referenced* by a `from`/`arrow` (it resolves to the first), so a repeated read
+  model that nothing references by name produces **no warning**. **Wire each event to a read model
+  exactly once:** a repeated instance's `from` lists only the **new** events since the previous
+  instance (not cumulative) — otherwise an event draws a duplicate arrow to the same read model at
+  every repeat. (An event may still feed several *different* read models, once each.)
+- **Place each repeat immediately after its feeding event (span-1).** The cleanest staircase puts a
+  read-model instance right after each event that updates it, sourcing **only that one adjacent
+  event** — every `event → read model` arrow is then short and forward-flowing. A read model sitting
+  far from its source events (e.g. a "list/queue" read placed early but fed by late events) draws
+  long arrows that cross the read-model row and *look* like read→read connections — which Event
+  Modeling forbids. The fix is never a `view → view` edge; it's to repeat the read model next to each
+  event that feeds it.
+- Socratic prompts: *"What does the consumer need to see to make their next decision? Which past
+  events provide that information? Is this a screen or an API read? What's the freshness/consistency
+  expectation?"*
+
+### 3. Automation (Processor pattern)
+**Read Model → Processor → (next slice) Command → Event.** The system reacts on its own: a
+processor watches a read model (a "to-do list" of work) and **issues a command** — it never
+records an event directly.
+- `em` shape: **two slices.** First `slice { view "Todo" from "..."  processor P }`, then the
+  **next** `slice { command C  event E @Context }`. The processor band holds no event; the command
+  in the next slice produces it. Keeping the triggered command in the same slice as the processor
+  is a validation warning — always split it.
+- Socratic prompts: *"What should happen without a human? What condition triggers it? What work
+  list does the processor watch? What command does it fire? What if it fails or retries?"*
+
+### 4. Translation
+**Boundary crossing → command → event.** An adapter translates data across a boundary (an external
+system, or another bounded context) into the model's own language. Like an automation, a
+translation is a *reaction*: it **triggers a command**, never records an event directly. Two
+trigger forms:
+- **Externally triggered:** `external input → translation → command → event`. The trigger comes
+  from outside the model, so the translation has no internal `from`.
+- **Internally triggered** (reacting to the modeled system's own state, e.g. pushing data out):
+  `read model → translation → command → event`. The translation reads a **view** via `from`.
+- `em` shape: **two slices**, exactly like an automation. First
+  `slice { [view "Source" from "..."]  translation T [from "Source"] }`, then the **next**
+  `slice { command C  event E @Context }`. The translation band never carries an event.
+- Socratic prompts: *"What boundary are we crossing, and which way? What outside system or context
+  feeds us (or do we feed)? In what format? How do we know its data is trustworthy/complete? What
+  internal **command** does it trigger, and what event does that command record?"*
+
+---
+
+## The 7 steps
+
+Run them in order. The skill groups them into phases: **discover = 1–4**, **model = 5–7**,
+and a dedicated **slice** phase deepens step 6 to implementation-ready specs.
+
+### Step 1 — Brainstorm Events  *(discover)*
+List the domain **events** as past-tense facts, unordered at first. Go wide; capture every
+state change anyone can think of. No commands, no UI yet — just facts.
+- Prompts: *"What are all the things that happen in this process? Say each as something that
+  already occurred. What changed when that happened?"*
+- Output: a flat list of candidate `event` names.
+
+### Step 2 — The Plot / Storyboard  *(discover)*
+Put the events in **timeline order** to form the narrative. Identify the **personas** (actors)
+and sketch the **UI** screens that move the story forward. This is the storyboard.
+- Prompts: *"In what order do these happen? Who is on screen at each step? What screen are they
+  looking at? What's the happy-path story start to finish?"*
+- Output: ordered events + `persona` list + `ui` screens per step.
+
+### Step 3 — Inputs (Commands)  *(discover)*
+For each event, identify the **command** that causes it (State Change pattern). Name the intent,
+not the outcome ("Place Order", not "Order Placed").
+- Prompts: *"What action produces this event? Who or what issues it? Could it be refused?"*
+- Output: `command → event` pairs.
+
+### Step 4 — Outputs (Read Models)  *(discover)*
+Identify the **read models / views** each UI and automation needs (State View pattern). Wire
+each view to the events that feed it.
+- Prompts: *"What information does this screen show? Which past events supply it? Does any
+  automation need a work list derived from events?"*
+- Output: `view` elements with their `from "Event"` sources.
+
+### Step 5 — Swimlanes & Apply the Patterns  *(model)*
+Organize elements into swimlanes: one **persona** row per actor, one **context** (bounded
+context / aggregate) row per event family. Classify every slice as one of the **4 patterns** and
+wire them correctly — especially **split both automations and translations across two slices**
+(the reaction in one, the command + event in the next). A translation or automation never records
+an event directly; it triggers a command.
+- Prompts: *"Which events belong together as one consistency boundary (aggregate)? Who owns this
+  data? Is this slice a state change, a view, an automation, or a translation?"*
+- Output: a structurally complete model with swimlanes and pattern-correct slices.
+
+### Step 6 — Elaborate Scenarios  *(model first pass, slice deep pass)*
+For each slice, write **Given / When / Then** scenarios and surface **invariants**, **critical
+fields**, and **alternate / error flows**. In the `model` phase do a light first pass; the
+dedicated `slice` phase writes the full rich spec (see `templates/slice.md`).
+- Prompts: *"Given what starting state, when this command/trigger fires, then what event(s)
+  result? What must always be true? What are the failure paths? Which fields are essential and
+  what are their rules?"*
+- Output: rich slice docs linked into the `.em` via `note "slices/<name>.md"`.
+
+### Step 7 — Evaluate Completeness  *(model)*
+Walk the whole model with stakeholders and check for loose ends:
+- Every **command** produces at least one **event**.
+- Every **view** has at least one source event.
+- Every **event** is shown somewhere or consumed by something (no orphan facts).
+- Every **UI** is reachable and leads somewhere.
+- Automations **and** translations are split correctly (reaction → command → event, never a
+  reaction wired straight to an event); translations cover every external input.
+- Run `em validate` and resolve all errors and warnings. Note: `em validate` does **not** catch a
+  translation/automation that emits an event directly — verify the two-slice split by hand.
+- Prompts: *"Is there any event nobody sees? Any screen with no way in or out? Any command that
+  records nothing? Any external system we haven't translated? Any translation or automation that
+  records an event instead of triggering a command?"*
+
+---
+
+## Socratic stance (applies throughout)
+
+- Ask **one focused question at a time**; never assume a domain fact — extract it.
+- Prefer "why", "what if", "who", "what must always be true", "how do you know" over yes/no.
+- Mirror the model back after each increment and **re-render** so the team sees it evolve.
+- Park unresolved questions in the state file instead of guessing.
+- Name things crisply: events past-tense, commands imperative, views as the thing-shown.

package/.claude/skills/event-modeling/templates/live.html

@@ -0,0 +1,53 @@
+<!doctype html>
+<!--
+  Live viewer for an em event model. Auto-reloads the rendered SVG so a team on a shared
+  screen sees updates from `em watch` without manual refresh.
+
+  Usage:
+    1) In one terminal:  em watch MODEL.em -o MODEL.svg
+    2) Set SVG_FILE below to the SVG filename (same folder as this file).
+    3) Open this file in a browser (open live.html) and share the screen.
+
+  The SVG is embedded via <object> so note "..." links inside it stay clickable.
+-->
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>Event Model — Live</title>
+  <style>
+    :root { color-scheme: light dark; }
+    body { margin: 0; font-family: system-ui, sans-serif; background: #fafafa; }
+    header {
+      display: flex; align-items: center; gap: .75rem;
+      padding: .5rem .9rem; background: #1f2933; color: #fff; font-size: 14px;
+    }
+    header .dot { width: 9px; height: 9px; border-radius: 50%; background: #34c759; }
+    header .stamp { margin-left: auto; opacity: .7; font-variant-numeric: tabular-nums; }
+    #stage { padding: 1rem; }
+    object { width: 100%; height: calc(100vh - 60px); border: 0; }
+  </style>
+</head>
+<body>
+  <header>
+    <span class="dot"></span>
+    <span>Event Model — live (auto-refresh)</span>
+    <span class="stamp" id="stamp">—</span>
+  </header>
+  <div id="stage">
+    <object id="svg" type="image/svg+xml"></object>
+  </div>
+  <script>
+    // Change this to your model's SVG filename:
+    const SVG_FILE = "model.svg";
+    const obj = document.getElementById("svg");
+    const stamp = document.getElementById("stamp");
+    function reload() {
+      // cache-bust so the freshly written SVG is fetched each tick
+      obj.setAttribute("data", SVG_FILE + "?t=" + Date.now());
+      stamp.textContent = new Date().toLocaleTimeString();
+    }
+    reload();
+    setInterval(reload, 1000);
+  </script>
+</body>
+</html>

package/.claude/skills/event-modeling/templates/model-readme.md

@@ -0,0 +1,28 @@
+# {{Model Name}}
+
+{{One-paragraph description of the business process(es) this event model covers.}}
+
+## Live view
+While modeling, run the live view so the team can watch the diagram update:
+
+```bash
+em watch {{model-name}}.em -o {{model-name}}.svg   # re-renders on every save
+# then open live.html in a browser (auto-refreshes ~1s; share the screen)
+```
+
+Static render: `em render {{model-name}}.em -o {{model-name}}.svg`
+
+## Patterns legend
+- **State Change** — UI → Command → Event
+- **State View** — Event(s) → Read Model → UI
+- **Automation** — Read Model → Processor → (next slice) Command → Event
+- **Translation** — External input (or Read Model) → Translation → (next slice) Command → Event
+
+## Slices
+<!-- Keep this index in sync as slice docs are written. -->
+| # | Slice | Pattern | Design doc |
+|---|-------|---------|------------|
+| 1 | {{Slice Name}} | {{Pattern}} | [slices/{{slice-name}}.md](slices/{{slice-name}}.md) |
+
+## Status
+See [`.event-modeling.md`](.event-modeling.md) for current phase, decisions, and open questions.

package/.claude/skills/event-modeling/templates/slice.md

@@ -0,0 +1,70 @@
+<!--
+Rich slice design document. One per slice, stored in <model>/slices/<slice-name>.md and
+linked from the .em model with:  note "slices/<slice-name>.md"  on the slice's defining element.
+Fill every section through Socratic questioning. Leave "Open Questions" rather than guessing.
+Replace the bracketed placeholders; delete guidance comments before finishing.
+-->
+
+# Slice: {{Slice Name}}
+
+- **Pattern:** {{State Change | State View | Automation | Translation}}
+- **Swimlane:** {{Persona/Actor}} → {{Context/Aggregate}}
+- **Status:** {{draft | reviewed | ready-to-implement}}
+
+## Intent
+{{Why this slice exists — the user or business goal it serves, in one or two sentences.}}
+
+## Trigger & Actor
+{{Who or what initiates this slice and under what circumstances. For automations, the watched
+read model and the triggering condition. For translations, state the trigger form: externally
+triggered (the external system/source feeding us) or internally triggered (the read model whose
+state we react to). Either way, name the command this reaction triggers — reactions never record
+an event directly.}}
+
+## Command / Input
+<!-- For State Change, and the command half of an Automation or Translation (reactions trigger a
+     command in the next slice). Omit for pure State View slices. -->
+**Command:** `{{Command Name}}`
+
+| Field | Type | Required | Rules / Validation |
+|-------|------|----------|--------------------|
+| {{field}} | {{Type}} | {{yes/no}} | {{constraints, formats, ranges}} |
+
+## Event(s) Emitted
+<!-- The immutable facts recorded. List each event and its payload. -->
+**Event:** `{{Event Name}}` → context `{{Context}}`
+
+| Field | Type | Immutable Fact? | Source / Notes |
+|-------|------|-----------------|----------------|
+| {{field}} | {{Type}} | {{yes/no}} | {{where the value comes from}} |
+
+## Read Model / View
+<!-- For State View slices, and any read model this slice produces or feeds. -->
+- **View:** `{{View Name}}` built from events: {{"Event A", "Event B"}}
+- **Consumed by:** {{which UI screen or automation}}
+- **Freshness / consistency expectation:** {{real-time | eventual | on-demand}}
+
+## Invariants / Business Rules
+<!-- What must ALWAYS hold. Give each a stable ID so tests and code can reference it. -->
+- **INV-1:** {{rule that the command enforces; violation ⇒ rejection}}
+- **INV-2:** {{...}}
+
+## Scenarios (Given / When / Then)
+<!-- The executable specification. Cover the happy path AND the key rule boundaries. -->
+- **Happy path** — Given {{starting state / prior events}}, When {{command/trigger}},
+  Then {{event(s) recorded}} and {{resulting read-model change}}.
+- **Rejected (INV-1)** — Given {{state}}, When {{command}}, Then {{rejected with reason}}; no event.
+- **{{Edge case}}** — Given {{...}}, When {{...}}, Then {{...}}.
+
+## Alternate & Error Flows
+<!-- Failure paths, retries, compensations, timeouts, idempotency. -->
+- {{e.g. external call fails → retry policy / compensating event}}
+- {{idempotency: what happens if the command/event arrives twice?}}
+
+## Dependencies & Read Models Affected
+- **Upstream events this slice relies on:** {{...}}
+- **Downstream read models / slices affected:** {{...}}
+
+## Open Questions
+<!-- Park unresolved items here instead of guessing. Mirror them into .event-modeling.md. -->
+- [ ] {{question}}

package/.claude/skills/event-modeling/templates/state.md

@@ -0,0 +1,34 @@
+<!--
+Resumable progress state for an event model. Stored as <model>/.event-modeling.md
+The skill reads this on `/event-modeling` (no arg) to resume where you left off.
+Keep it current at the end of every working session.
+-->
+
+# Event Modeling Progress — {{Model Name}}
+
+- **Model file:** `{{model-name}}.em`
+- **Current phase:** {{discover | model | slice}}
+- **Current step:** {{1–7, see methodology}}
+- **Last updated:** {{YYYY-MM-DD}}
+
+## Steps completed
+- [ ] 1. Brainstorm events
+- [ ] 2. Plot / storyboard (personas + UI)
+- [ ] 3. Inputs (commands)
+- [ ] 4. Outputs (read models)
+- [ ] 5. Swimlanes & apply patterns
+- [ ] 6. Elaborate scenarios
+- [ ] 7. Evaluate completeness (`em validate` clean)
+
+## Decisions log
+<!-- Resolved choices, with the reasoning, so they aren't re-litigated. -->
+- {{YYYY-MM-DD}}: {{decision}} — {{why}}
+
+## Open questions / parking lot
+<!-- Unresolved items to bring back to the user. Never guess these. -->
+- [ ] {{question}}
+
+## Slice inventory
+| Slice | Pattern | Doc status |
+|-------|---------|------------|
+| {{Slice Name}} | {{State Change/View/Automation/Translation}} | {{none / draft / ready}} |

package/README.md

@@ -178,6 +178,32 @@ npm test               # vitest
 npx tsx src/cli.ts <command> ...   # run straight from source
 ```
 
+## AI Assistant (Claude Code)
+
+`em` ships a **Claude Code skill** that guides you and your team through Event Modeling using the 7-step process and 4 design patterns, producing implementation-ready slice specifications. The AI drives the model — asking focused questions, never guessing domain facts — while `em validate` keeps the diagram honest.
+
+**Install the skill into your project:**
+
+```bash
+em skill install          # copies the skill into .claude/skills/event-modeling/
+em skill install --force  # overwrite an existing installation
+```
+
+Then, in Claude Code, run:
+
+```
+/event-modeling           # start (or resume) a guided session
+/event-modeling discover  # steps 1–4: brainstorm events, timeline, commands, read models
+/event-modeling model     # steps 5–7: swimlanes, patterns, completeness check
+/event-modeling slice     # deep implementation specs, one per slice
+/event-modeling watch     # open a live browser view for team modeling sessions
+/event-modeling validate  # run em validate and resolve all diagnostics
+```
+
+Sessions are **resumable** — the skill checkpoints progress in `.event-modeling.md` so you can continue across conversations.
+
+For a complete worked example (a headless CPQ system with ~50 slices), see the [em-with-ai repository](https://github.com/milehimikey/em-with-ai).
+
 ## License
 
 [MIT](LICENSE) © milehimikey

package/dist/cli.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 // SPDX-License-Identifier: MIT
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
-import { basename, dirname, extname, resolve } from "node:path";
+import { cp, mkdir } from "node:fs/promises";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 import { compile } from "./pipeline.js";
 import { ParseError } from "./parser/parser.js";
@@ -13,7 +15,7 @@ const program = new Command();
 program
     .name("em")
     .description("Event Modeling CLI — slice-first DSL rendered as a strict Graphviz grid")
-    .version("0.1.0");
+    .version("0.2.0");
 program
     .command("init")
     .description("scaffold a starter .em model")
@@ -105,6 +107,27 @@ program
     if (diagnostics.length === 0)
         console.log("ok — no issues");
 });
+const skill = program
+    .command("skill")
+    .description("manage Claude Code skills bundled with em");
+skill
+    .command("install")
+    .description("copy the event-modeling skill into .claude/skills/event-modeling/")
+    .option("-f, --force", "overwrite an existing installation")
+    .action(async (opts) => {
+    const pkgDir = dirname(fileURLToPath(import.meta.url));
+    const src = join(pkgDir, "..", ".claude", "skills", "event-modeling");
+    const dest = join(process.cwd(), ".claude", "skills", "event-modeling");
+    if (existsSync(dest) && !opts.force) {
+        console.log(`skill already installed at ${dest}`);
+        console.log("re-run with --force to overwrite");
+        return;
+    }
+    await mkdir(join(process.cwd(), ".claude", "skills"), { recursive: true });
+    await cp(src, dest, { recursive: true });
+    console.log(`installed event-modeling skill → ${dest}`);
+    console.log("in Claude Code, run /event-modeling to start a guided session");
+});
 program.parseAsync().catch((e) => {
     reportError(e);
     process.exit(1);

package/dist/cli.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}

package/dist/emit/theme.js

@@ -8,7 +8,7 @@ const STYLES = {
     automation: { fill: "#DBDBDB", stroke: "#5F6368", fontColor: "#202124" },
     processor: { fill: "#DBDBDB", stroke: "#5F6368", fontColor: "#202124" },
     saga: { fill: "#DBDBDB", stroke: "#5F6368", fontColor: "#202124" },
-    translation: { fill: "#E4D5F7", stroke: "#6B46C1", fontColor: "#2A1A4A" },
+    translation: { fill: "#DBDBDB", stroke: "#5F6368", fontColor: "#202124" },
 };
 export function styleFor(kind) {
     return STYLES[kind];
@@ -25,9 +25,8 @@ export function edgeColorFor(kind) {
         case "automation":
         case "processor":
         case "saga":
-            return "#5F6368";
         case "translation":
-            return "#6B46C1";
+            return "#5F6368";
         default:
             return "#3C4043";
     }

package/dist/emit/theme.js.map

@@ -1 +1 @@
-{"version":3,"file":"theme.js","sourceRoot":"","sources":["../../src/emit/theme.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,qCAAqC;AAUrC,MAAM,MAAM,GAAmC;IAC7C,EAAE,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;IAChE,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;IACrE,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;IAClE,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;IACnE,UAAU,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;IACxE,SAAS,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;IACvE,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;IAClE,WAAW,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;CAC1E,CAAC;AAEF,MAAM,UAAU,QAAQ,CAAC,IAAiB;IACxC,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC;AACtB,CAAC;AAED,uDAAuD;AACvD,MAAM,UAAU,YAAY,CAAC,IAA6B;IACxD,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,SAAS;YACZ,OAAO,SAAS,CAAC;QACnB,KAAK,MAAM;YACT,OAAO,SAAS,CAAC;QACnB,KAAK,OAAO;YACV,OAAO,SAAS,CAAC;QACnB,KAAK,YAAY,CAAC;QAClB,KAAK,WAAW,CAAC;QACjB,KAAK,MAAM;YACT,OAAO,SAAS,CAAC;QACnB,KAAK,aAAa;YAChB,OAAO,SAAS,CAAC;QACnB;YACE,OAAO,SAAS,CAAC;IACrB,CAAC;AACH,CAAC"}
+{"version":3,"file":"theme.js","sourceRoot":"","sources":["../../src/emit/theme.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,qCAAqC;AAUrC,MAAM,MAAM,GAAmC;IAC7C,EAAE,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;IAChE,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;IACrE,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;IAClE,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;IACnE,UAAU,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;IACxE,SAAS,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;IACvE,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;IAClE,WAAW,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE;CAC1E,CAAC;AAEF,MAAM,UAAU,QAAQ,CAAC,IAAiB;IACxC,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC;AACtB,CAAC;AAED,uDAAuD;AACvD,MAAM,UAAU,YAAY,CAAC,IAA6B;IACxD,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,SAAS;YACZ,OAAO,SAAS,CAAC;QACnB,KAAK,MAAM;YACT,OAAO,SAAS,CAAC;QACnB,KAAK,OAAO;YACV,OAAO,SAAS,CAAC;QACnB,KAAK,YAAY,CAAC;QAClB,KAAK,WAAW,CAAC;QACjB,KAAK,MAAM,CAAC;QACZ,KAAK,aAAa;YAChB,OAAO,SAAS,CAAC;QACnB;YACE,OAAO,SAAS,CAAC;IACrB,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milehimikey/em",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "AI-friendly Event Modeling — a slice-first text DSL rendered to a strict, self-contained Graphviz grid (SVG/PNG)",
   "type": "module",
   "bin": {
@@ -10,7 +10,8 @@
   "files": [
     "dist",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    ".claude"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",