@milehimikey/em 1.1.0 → 1.2.0

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

@@ -4,23 +4,28 @@ 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.
 -->
 
----
-schemaVersion: 1
-model: {{model-name}}.em
----
-
 # Event Modeling Progress — {{Model Name}}
 
 - **Model file:** `{{model-name}}.em`
-- **Current phase:** {{discover | model | slice}}
-- **Current step:** {{1–7, see methodology}}
+- **Current phase:** {{extract | discover | model | slice}}
+- **Current step:** {{1–7, see methodology; or extraction round R1–R7}}
 - **Last updated:** {{YYYY-MM-DD}}
 
 ## Session inputs
 - **Scope line:** {{one-line description of what's in/out of bounds for this model}}
 - **PRD / spec reference:** {{path, link, or "none"}}
 - **Headless/API model:** {{yes | no}}
-- **Regulatory scope:** {{e.g. PCI-DSS, SOX, HIPAA, or "none"}}
+- **Source mode:** {{greenfield | extract-event-driven | extract-procedural}}
+- **Existing system refs:** {{repo paths, event-schema/topic locations, docs — or "n/a"}}
+
+## Extraction progress (existing-system models only — delete for greenfield)
+- [ ] R1. Candidate events (extracted/synthesized, filtered, confirmed)
+- [ ] R2. Timeline order (as-is narrative, actors/callers, first render)
+- [ ] R3. Commands / inputs
+- [ ] R4. Read models / outputs (validate from here)
+- [ ] R5. Boundaries & reactions (two-slice splits)
+- [ ] R6. Gap & TBD reconciliation
+- [ ] R7. Convergence (render + validate clean, user confirmed as-is)
 
 ## Steps completed
 - [ ] 1. Brainstorm events
@@ -40,6 +45,6 @@ model: {{model-name}}.em
 - [ ] {{question}}
 
 ## Slice inventory
-| Slice | Id | Pattern | Doc status |
-|-------|-----|---------|------------|
-| {{Slice Name}} | {{slice-id}} | {{state-change/state-view/automation/translation}} | {{none / draft / reviewed / ready-to-implement}} |
+| Slice | Pattern | Doc status |
+|-------|---------|------------|
+| {{Slice Name}} | {{State Change/View/Automation/Translation}} | {{none / draft / reviewed / ready-to-implement}} |

package/README.md

@@ -1,214 +1,85 @@
-# em — AI friendly event modeling
+# em — event modeling in plain text
 
 `em` is a command-line tool for [Event Modeling](https://eventmodeling.org/). You write a
-model in a small, **plain-text, slice-first DSL** (`.em`) and `em` renders it to a clean,
-deterministic diagram (SVG by default, PNG on request). Because the source is just text —
-diff-able, reviewable, and unambiguous — it's as easy for an LLM to generate and edit as it
-is for a person to write by hand. Layout is a **strict grid**: swimlane rows and
-time-ordered slice columns stay perfectly aligned with no manual offsets.
+model in a small, slice-first DSL and `em` renders it as a clean, deterministic diagram.
+Because the source is plain text — diff-able, reviewable, unambiguous — it's as easy for an
+AI to write and edit as it is for a person, and `em validate` keeps either one honest.
 
-```
-examples/order-fulfillment.em  ->  em render  ->  order-fulfillment.svg
-```
+![An order-fulfillment event model rendered by em](https://raw.githubusercontent.com/milehimikey/em/main/examples/order-fulfillment.svg)
 
-Rendering is **self-contained** — Graphviz runs as bundled WebAssembly and PNG is
-rasterized in-process, so there's nothing to `apt`/`brew` install for SVG or PNG output.
+The source for that diagram is [about 70 lines of text](examples/order-fulfillment.em).
 
 ## Install
 
 ```bash
-npm install -g @milehimikey/em     # then `em` is on your PATH
+npm install -g @milehimikey/em
 ```
 
-Requires **Node ≥ 18**. SVG and PNG need no other tools. PDF (and other Graphviz raster
-formats) are optional and use a system `rsvg-convert` (librsvg) if one is installed.
-
-Run without installing:
-
-```bash
-npx @milehimikey/em init model.em
-npx @milehimikey/em render model.em
-```
+Requires Node ≥ 18. SVG and PNG rendering are fully self-contained (Graphviz runs as
+bundled WebAssembly); nothing else to install. PDF is optional — see
+[docs/dependencies.md](docs/dependencies.md).
 
 ## Quickstart
 
 ```bash
 em init model.em          # scaffold a starter model
 em render model.em        # -> model.svg  (open it in a browser)
-em watch model.em         # re-render on every save
+em watch model.em --serve # live browser view, re-renders on every save
 em validate model.em      # check event-modeling rules
 ```
 
-A `.em` model is a list of **slices** (vertical time steps), each holding elements that fall
-into swimlane rows:
+A model is a list of slices — vertical time steps, read left to right — whose elements land
+in swimlane rows:
 
-```
+```em
 model "Order Fulfillment"
 
-persona Customer           # UI swimlanes (top), one row per persona
-context Order              # event swimlanes (bottom), one row per context
-context Payment
-
-slice "Browse Catalog" {           # each slice is one column (time, left -> right)
-  ui Product Catalog @Customer     # @Persona places the screen in a persona row
-  command Place Order {            # a `{ … }` block declares the element's fields
-    customerId
-    total: Money                   # optional `: Type` annotation
-  }
-  event Order Placed @Order note "notes/order-placed.md" {   # note "…" links docs
-    orderId
-    total: Money
-  }
+persona Customer
+context Order
+
+slice "Browse Catalog" {
+  ui Product Catalog @Customer
+  command Place Order
+  event Order Placed @Order
 }
 
 slice "View Open Orders" {
-  view Open Orders from "Order Placed"   # from "<event>" wires the data flow
+  view Open Orders from "Order Placed"
   ui Order List @Customer
 }
 ```
 
-## The four patterns
-
-Event Modeling is built from four patterns, all expressible as slices:
-
-| Pattern | Flow | DSL elements |
-|---|---|---|
-| **Input** (state change) | UI → command → event | `ui`, `command`, `event` |
-| **Output** (state view) | event → read model → UI | `event`, `view from "…"`, `ui` |
-| **Automation** | read model (todo) → processor → command → event | `view from "…"` + `processor`, then `command` + `event` |
-| **Translation** | external read model → translation → command → event | `view from "…"` + `translation`, then `command` + `event` |
-
-Automation/translation slices are **not** triggered by a command — they react to a read
-model (a "todo list") or a timer and *issue* a command when done. The automation slice
-contains **only** the read model it reads and the processor/translation; the command it
-triggers (and that command's event) is the **next** slice.
+The [tutorial](docs/tutorial.md) builds a complete model from an empty file in about twenty
+minutes.
 
-## DSL reference
+## Model with AI
 
-### Element keywords → swimlane bands (top → bottom)
-
-0. *(header)* — each slice name is rendered as a title cell in the top row
-1. `automation` / `processor` / `saga` / `translation` — **Automation** band (only shown if used)
-2. `ui` — **persona** rows (one per `persona`)
-3. `command` + `view` — the **API** row (commands and read models share one lane)
-4. `event` — **context/concept** rows (one per `context`)
-
-Commands and read models share the **API** row, so a slice holds *either* a command *or* a
-read model. The empty API lane is dropped when a model has neither; pass `--keep-empty-lanes`
-to keep it.
-
-`@Persona` / `@Context` choose the row within a band (undeclared tags create a new row).
-`view <Name> again [from "Event", …]` declares a LATER INSTANCE of an already-declared read
-model — the Event Modeling device for keeping the timeline forward-only as a view evolves.
-Instances are one logical view: the first declaration owns the `note` doc; each instance lists
-the events that reach it there; instances are linked left-to-right with a continuity arrow, and
-reactions (`processor … from "View"`) read the nearest instance at-or-before their slice.
-
-`view … from "Event"[, "Event2"]` declares which events feed a read model and draws the
-data-flow arrow. Arrows within a slice are inferred from the pattern; use `arrow A -> B` for
-anything extra (e.g. a read model feeding a different screen).
-
-### Fields
-
-Any element can declare **data fields** in a `{ … }` block — the data it accepts (command),
-records (event), projects (read model), or shows (UI). Each field is `name` with an optional
-`: Type`; write one per line, or inline and comma-separated:
-
-```
-command Place Order {            # one per line
-  customerId
-  items: List<LineItem>
-  total: Money
-}
-
-event Payment Requested @Payment { orderId, amount: Money }   # inline
-```
-
-Fields render **in the box**, UML-style: the name, a divider rule, then the fields. The box
-grows to fit them (width stays fixed, so columns stay aligned), and arrows still anchor to
-the box edges so the lines stay stable. A field block coexists with `note`/`from` clauses on
-the same element. Fields are the foundation of the later event-modeling phases (the slicing /
-information-completeness process); field-level validation across slices is planned.
-
-### Notes
-
-Any element can carry `note "path.md"` (valid on every keyword). The prose lives in the
-markdown file — keeping the diagram uncluttered — and the box gets a small **numbered
-folded-corner marker** in its top-right corner. A **legend** is appended below the diagram
-mapping each number to its element and note file, so even a static export tells you which
-note belongs to which box.
-
-In **SVG** output the markers and legend rows are links; clicking one opens the markdown
-file. Links resolve relative to the **output SVG's location**, so they keep working whether
-the SVG is rendered beside the model or into another folder (as long as the notes travel
-with it). Open the SVG in a **web browser** to use the links — image viewers like macOS
-Preview/Quick Look show the markers but ignore SVG hyperlinks. Raster output (PNG/PDF) can't
-carry links — that's what the footnote numbers + legend are for.
-
-## Commands
+`em` ships a Claude Code skill that runs a facilitated Event Modeling session: the AI asks
+the questions, you supply the domain, and the model renders live as it grows.
 
 ```bash
-em init [file]                        # scaffold a starter model (default: model.em)
-em render <file> [-o out.svg]         # render (format from -o extension or -T)
-em render <file> -o out.png           # PNG (in-process, no system deps)
-em render <file> --emit-dot           # print the generated DOT instead of rendering
-em render <file> --keep-empty-lanes   # don't collapse the API lane when empty
-em watch <file> [-o out.svg]          # re-render on every save
-em validate <file>                    # check event-modeling rules + slice-doc frontmatter
-em migrate <model-dir>                # one-time upgrade of a pre-1.0 model to the frontmatter standard
+em skill install          # copy the skill into .claude/skills/event-modeling/
 ```
 
-See [Slice docs & frontmatter](#slice-docs--frontmatter) below for the `em slice` command group.
-
-## Validation rules (`em validate`)
-
-- two same-band elements in one slice (collision) → **error** (split into separate slices)
-- a read model whose `from "Event"` doesn't exist → **error**
-- **time flows left to right** (the Two Laws): an event feeding an EARLIER view instance,
-  a reaction reading a view that only exists later, or an explicit backward `arrow` → **error**
-  (fix: add `view X again` at the point on the timeline where the event lands)
-- `again` on a view with no earlier declaration → **error**; `again` on non-views → parse error
-- multi-event slices always render as a FAN from the command (never event→event); fanned
-  arrows route around the column gutter so they cannot read as a chain
-- an automation/translation whose `from "<read model>"` doesn't exist → **error**
-- an `arrow` endpoint that matches no element → **error**
-- an automation/translation slice that also holds the command it triggers → **warning**
-- a command that records no event → **warning**
-- a read model with no source event → **warning**
-- a name defined more than once and referenced → **warning** (resolves to first)
-
-## Slice docs & frontmatter
-
-Slice design docs (`slices/<id>.md`, written during the skill's `slice` phase or via
-`em slice new`) carry a required YAML frontmatter block — a stable `id`, lifecycle `status`,
-integer `version`, and fields generated from the `.em` (`commands`/`events`/`readModels`/
-`contexts`/`personas`, plus `triggers`/`triggeredBy` for automation/translation) — so an AI agent
-can search and filter across a model with hundreds of slices from frontmatter alone, without
-reading every doc's body or re-parsing the `.em`:
-
-```bash
-em slice new "Place Order" --pattern state-change   # scaffold slices/place-order.md
-em slice sync place-order                           # after wiring note "slices/..." into the .em
-em slice list --status ready-to-implement
-em slice search --pattern automation --context Payment --format json
-em slice search --status ready-to-implement --format json --full   # every field, not just a summary
-em slice update place-order --status reviewed --bump-version
-```
-
-The doc body itself is **yours to define** — point `em.config.json` at a custom template
-(`{ "sliceTemplate": "path/to/template.md" }`) and `em` injects the frontmatter on top of it
-regardless of what sections you ask for. Full schema, lifecycle model, and the handoff contract a
-build/SDD tool should treat as authoritative once a slice is `ready-to-implement`:
-[docs/1.0.0-spec.md](docs/1.0.0-spec.md).
+Then run `/event-modeling` in Claude Code. See [docs/ai-workflow.md](docs/ai-workflow.md)
+for the phases and what a session produces, and the
+[em-with-ai repository](https://github.com/milehimikey/em-with-ai) for a ~50-slice model
+built this way.
 
 ## Documentation
 
-- [docs/1.0.0-spec.md](docs/1.0.0-spec.md) — slice frontmatter standard, config, `em slice`/
-  `em migrate`, and the SDD handoff contract
-- [docs/why-dot-not-plantuml.md](docs/why-dot-not-plantuml.md) — why DOT + the strict-grid /
-  self-drawn-edges architecture
-- [docs/features.md](docs/features.md) — full feature list and roadmap
-- [docs/dependencies.md](docs/dependencies.md) — how rendering works with no system deps
+| Doc | What it answers |
+|---|---|
+| [docs/tutorial.md](docs/tutorial.md) | Learn the tool by building a model from scratch |
+| [docs/patterns.md](docs/patterns.md) | The four Event Modeling patterns and their DSL shapes |
+| [docs/dsl.md](docs/dsl.md) | Full DSL reference: keywords, `from`, `again`, fields, notes |
+| [docs/cli.md](docs/cli.md) | Every command and flag |
+| [docs/validation.md](docs/validation.md) | Every rule `em validate` checks, and the fixes |
+| [docs/timeline.md](docs/timeline.md) | The Two Laws of the Timeline |
+| [docs/ai-workflow.md](docs/ai-workflow.md) | The Claude Code skill: install, phases, artifacts |
+| [docs/dependencies.md](docs/dependencies.md) | What's bundled vs. what needs a system install |
+| [docs/architecture.md](docs/architecture.md) | How rendering works; why Graphviz, not PlantUML |
+| [docs/roadmap.md](docs/roadmap.md) | What's planned |
 
 ## Development
 
@@ -219,32 +90,6 @@ 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 (frontmatter via `em slice new`)
-/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

@@ -4,24 +4,19 @@ import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { cp, mkdir } from "node:fs/promises";
 import { basename, dirname, extname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { Command, Option } from "commander";
+import { Command } from "commander";
 import { compile } from "./pipeline.js";
 import { ParseError } from "./parser/parser.js";
 import { renderDot, formatFromPath } from "./render/render.js";
 import { watchFile } from "./render/watch.js";
+import { startLiveServer } from "./render/serve.js";
 import { formatDiagnostic, hasErrors } from "./model/validate.js";
-import { loadSliceDocs } from "./model/sliceDoc.js";
-import { validateSliceDocs, VALID_PATTERNS, VALID_STATUSES } from "./model/validateSliceDocs.js";
-import { newSlice } from "./slice/generate.js";
-import { syncAll, syncSlice } from "./slice/sync.js";
-import { listSliceRecords, listSlices, searchSliceRecords, searchSlices, showSlice, updateSlice, } from "./slice/query.js";
-import { applyMigration, assertCleanWorkingTree, formatMigrationReport, planMigration, } from "./migrate/migrate.js";
 import { STARTER_EM } from "./templates.js";
 const program = new Command();
 program
     .name("em")
     .description("Event Modeling CLI — slice-first DSL rendered as a strict Graphviz grid")
-    .version("1.1.0");
+    .version("1.2.0");
 program
     .command("init")
     .description("scaffold a starter .em model")
@@ -75,9 +70,12 @@ program
     .option("-o, --out <path>", "output path (extension picks the format)")
     .option("-T, --format <fmt>", "output format (svg, png, pdf, ...)")
     .option("--keep-empty-lanes", "keep the API lane even when empty")
+    .option("--serve", "serve a live viewer with instant push-reload (no polling)")
+    .option("--port <n>", "port for --serve (default 5173)", (v) => parseInt(v, 10))
     .action(async (file, opts) => {
     const out = opts.out ?? defaultOut(file, opts.format ?? "svg");
     const fmt = opts.format ?? formatFromPath(out);
+    let server;
     const build = async () => {
         const started = Date.now();
         try {
@@ -92,12 +90,25 @@ program
             }
             await renderDot(dot, model, out, fmt, dirname(file));
             console.log(`rendered ${out} (${Date.now() - started}ms)`);
+            server?.notify();
         }
         catch (e) {
             reportError(e);
         }
     };
     await build();
+    if (opts.serve) {
+        try {
+            // Serve the directory the SVG is written to — that's what the browser
+            // fetches, and note "..." links inside the SVG resolve relative to it.
+            server = await startLiveServer({ dir: dirname(resolve(out)), port: opts.port });
+            console.log(`→ live view: ${server.url}/?svg=${encodeURIComponent(basename(out))}`);
+            console.log("  open it in a browser and share your screen");
+        }
+        catch (e) {
+            reportError(e);
+        }
+    }
     watchFile(file, build);
     console.log(`watching ${file} … (ctrl-c to stop)`);
 });
@@ -105,13 +116,8 @@ program
     .command("validate")
     .description("check a model against event-modeling rules")
     .argument("<file>", "input .em file")
-    .option("--skip-slices", "don't validate slice docs (slices/*.md)")
-    .action((file, opts) => {
-    const { model, diagnostics } = compileFile(file);
-    if (!opts.skipSlices) {
-        const docs = loadSliceDocs(dirname(file));
-        diagnostics.push(...validateSliceDocs(model, file, docs));
-    }
+    .action((file) => {
+    const { diagnostics } = compileFile(file);
     printDiagnostics(diagnostics);
     if (hasErrors(diagnostics))
         process.exit(1);
@@ -139,198 +145,6 @@ skill
     console.log(`installed event-modeling skill → ${dest}`);
     console.log("in Claude Code, run /event-modeling to start a guided session");
 });
-const slice = program.command("slice").description("manage slice design docs (slices/*.md)");
-slice
-    .command("new")
-    .description("scaffold a new slice doc with injected frontmatter")
-    .argument("<name>", 'slice title, e.g. "Place Order"')
-    .option("--dir <path>", "model directory", ".")
-    .option("--model <path>", "explicit .em file (default: the only .em in --dir)")
-    .option("--config <path>", "explicit em.config.json path")
-    .addOption(new Option("--pattern <pattern>", "slice pattern").choices(VALID_PATTERNS).default("state-change"))
-    .option("--id <id>", "explicit slice id (default: kebab-case of the name)")
-    .option("--slice-element <id>", "the .em Element.id this doc documents, if already known")
-    .option("-f, --force", "overwrite an existing doc with this id")
-    .action((name, opts) => {
-    try {
-        const result = newSlice(name, {
-            dir: opts.dir,
-            modelPath: opts.model,
-            configPath: opts.config,
-            pattern: opts.pattern,
-            id: opts.id,
-            sliceElement: opts.sliceElement,
-            force: opts.force,
-        });
-        console.log(`wrote ${result.path} (id: ${result.id})`);
-    }
-    catch (e) {
-        reportError(e);
-        process.exit(1);
-    }
-});
-slice
-    .command("sync")
-    .description("recompute generated frontmatter fields (commands/events/readModels/contexts/personas/triggers) from the .em")
-    .argument("[id]", "slice id to sync (omit with --all)")
-    .option("--dir <path>", "model directory", ".")
-    .option("--model <path>", "explicit .em file")
-    .option("--all", "sync every slice doc in the directory")
-    .action((id, opts) => {
-    try {
-        if (opts.all) {
-            const { synced, skipped } = syncAll({ dir: opts.dir, modelPath: opts.model });
-            for (const s of synced)
-                console.log(`synced ${s.path}${s.changed ? "" : " (no changes)"}`);
-            for (const s of skipped)
-                console.warn(`  skip  ${s.file}: ${s.reason}`);
-        }
-        else {
-            if (!id) {
-                console.error("pass a slice id, or --all");
-                process.exit(1);
-            }
-            const result = syncSlice(id, { dir: opts.dir, modelPath: opts.model });
-            console.log(`synced ${result.path}${result.changed ? "" : " (no changes)"}`);
-        }
-    }
-    catch (e) {
-        reportError(e);
-        process.exit(1);
-    }
-});
-slice
-    .command("list")
-    .description("list slice docs from frontmatter only (no .em parse, no body read)")
-    .option("--dir <path>", "model directory", ".")
-    .addOption(new Option("--status <status>", "filter by status").choices(VALID_STATUSES))
-    .addOption(new Option("--pattern <pattern>", "filter by pattern").choices(VALID_PATTERNS))
-    .option("--context <context>", "filter by context")
-    .option("--tag <tag>", "filter by tag")
-    .option("--format <fmt>", "table | json", "table")
-    .option("--full", "emit every frontmatter field per slice (requires --format json)")
-    .action((opts) => {
-    const filter = {
-        dir: opts.dir,
-        status: opts.status,
-        pattern: opts.pattern,
-        context: opts.context,
-        tag: opts.tag,
-    };
-    if (opts.full) {
-        requireJson(opts.format);
-        console.log(JSON.stringify(listSliceRecords(filter), null, 2));
-        return;
-    }
-    printSlices(listSlices(filter), opts.format);
-});
-slice
-    .command("show")
-    .description("show one slice doc's frontmatter")
-    .argument("<id>", "slice id")
-    .option("--dir <path>", "model directory", ".")
-    .option("--format <fmt>", "table | json", "table")
-    .option("--body", "include the doc body")
-    .action((id, opts) => {
-    const doc = showSlice(id, { dir: opts.dir });
-    if (!doc) {
-        console.error(`no slice doc with id "${id}" found in ${opts.dir}`);
-        process.exit(1);
-    }
-    if (opts.format === "json") {
-        const payload = opts.body ? { ...doc.frontmatter, body: doc.body } : doc.frontmatter;
-        console.log(JSON.stringify(payload, null, 2));
-        return;
-    }
-    console.log(`# ${doc.file}`);
-    for (const [k, v] of Object.entries(doc.frontmatter ?? {})) {
-        console.log(`${k}: ${JSON.stringify(v)}`);
-    }
-    if (opts.body) {
-        console.log("");
-        console.log(doc.body);
-    }
-});
-slice
-    .command("search")
-    .description("search slice docs by frontmatter only (title/tags/commands/events/readModels)")
-    .argument("[query]", "free-text query", "")
-    .option("--dir <path>", "model directory", ".")
-    .addOption(new Option("--status <status>", "filter by status").choices(VALID_STATUSES))
-    .addOption(new Option("--pattern <pattern>", "filter by pattern").choices(VALID_PATTERNS))
-    .option("--context <context>", "filter by context")
-    .option("--tag <tag>", "filter by tag")
-    .option("--format <fmt>", "table | json", "table")
-    .option("--full", "emit every frontmatter field per slice (requires --format json)")
-    .action((query, opts) => {
-    const filter = {
-        dir: opts.dir,
-        status: opts.status,
-        pattern: opts.pattern,
-        context: opts.context,
-        tag: opts.tag,
-    };
-    if (opts.full) {
-        requireJson(opts.format);
-        console.log(JSON.stringify(searchSliceRecords(query, filter), null, 2));
-        return;
-    }
-    printSlices(searchSlices(query, filter), opts.format);
-});
-slice
-    .command("update")
-    .description("write status/version changes back into a slice doc's frontmatter")
-    .argument("<id>", "slice id")
-    .option("--dir <path>", "model directory", ".")
-    .addOption(new Option("--status <status>", "new status").choices(VALID_STATUSES))
-    .option("--bump-version", "increment version by 1")
-    .action((id, opts) => {
-    try {
-        const result = updateSlice(id, {
-            dir: opts.dir,
-            status: opts.status,
-            bumpVersion: opts.bumpVersion,
-        });
-        console.log(`updated ${result.path}`);
-    }
-    catch (e) {
-        reportError(e);
-        process.exit(1);
-    }
-});
-program
-    .command("migrate")
-    .description("upgrade a pre-1.0 model directory to the frontmatter standard (docs/1.0.0-spec.md)")
-    .argument("<model-dir>", "model directory")
-    .option("--model <path>", "explicit .em file")
-    .option("--dry-run", "print the plan/report without writing")
-    .option("--force", "proceed even with uncommitted changes or no git repo")
-    .option("--report <path>", "write the migration report to a file instead of stdout")
-    .action((dir, opts) => {
-    try {
-        if (!opts.dryRun)
-            assertCleanWorkingTree(dir, opts.force);
-        const plan = planMigration(dir, { modelPath: opts.model });
-        const report = formatMigrationReport(plan);
-        if (opts.report) {
-            writeFileSync(opts.report, report);
-            console.log(`wrote migration report -> ${opts.report}`);
-        }
-        else {
-            console.log(report);
-        }
-        if (opts.dryRun) {
-            console.log("dry run — no files written");
-            return;
-        }
-        applyMigration(plan);
-        console.log("migration applied");
-    }
-    catch (e) {
-        reportError(e);
-        process.exit(1);
-    }
-});
 program.parseAsync().catch((e) => {
     reportError(e);
     process.exit(1);
@@ -383,24 +197,4 @@ function printDiagnostics(diags) {
 function reportError(e) {
     console.error(e instanceof Error ? e.message : String(e));
 }
-/** --full emits a shape only JSON can carry; fail loudly rather than silently ignoring it. */
-function requireJson(format) {
-    if (format !== "json") {
-        console.error("--full requires --format json");
-        process.exit(1);
-    }
-}
-function printSlices(results, format) {
-    if (format === "json") {
-        console.log(JSON.stringify(results, null, 2));
-        return;
-    }
-    if (results.length === 0) {
-        console.log("no matching slices");
-        return;
-    }
-    for (const s of results) {
-        console.log(`${s.id}\t${s.pattern ?? "?"}\t${s.status ?? "?"}\tv${s.version ?? "?"}\t${s.title}`);
-    }
-}
 //# sourceMappingURL=cli.js.map