diff --git a/README.md b/README.md
index 2e6f9cc..b42cf21 100644
--- a/README.md
+++ b/README.md
@@ -57,7 +57,8 @@ Configuration lives at exactly one of two levels: in the package (`eslint.config
 | [`graph-store-contract`](packages/core/graph/store-contract/README.md)                 | The persistence port as an oRPC contract: save, load and delete models, set run state, upsert items from a source, structural ready, blocked-chain and impact queries, and a change feed; with an in-memory fake and a conformance kit.           |
 | [`graph-store-sqlite`](packages/adapters/graph/store-sqlite/README.md)                 | The store port on SQLite through Drizzle: one table definition, committed drizzle-kit migrations applied the same way in every runtime, recursive SQL for the structural queries, against Drizzle's async SQLite database so any driver plugs in. |
 | [`graph-sqlite-node`](packages/adapters/graph/sqlite-node/README.md)                   | The SQLite store on Node's built-in `node:sqlite` through `drizzle-orm/node-sqlite`, for the command line and servers.                                                                                                                            |
-| [`process-graph`](packages/targets/process-graph/README.md)                            | The primary entry point: re-exports the schema, projection and domain APIs flat and the DAG API as the `dag` namespace.                                                                                                                           |
+| [`graph-cli`](packages/targets/graph-cli/README.md)                                    | The command line and its library entry: sync GitHub issues into the SQLite store, ready, blocked, impact, critical path, cycles, hand-offs and status explanations, and every view drawn in Mermaid or Graphviz DOT.                              |
+| [`process-graph`](packages/targets/process-graph/README.md)                            | The primary entry point: re-exports the schema, projection and domain APIs flat and the DAG API as the `dag` namespace, and carries the `process-graph` bin.                                                                                      |
 
 ## Conventions
 
diff --git a/knip.config.ts b/knip.config.ts
index f97958e..127d749 100644
--- a/knip.config.ts
+++ b/knip.config.ts
@@ -25,7 +25,8 @@ const config: KnipConfig = {
       project: ["src/**/*.{ts,tsx}!"],
     },
     "packages/targets/*": {
-      entry: ["src/index.{ts,tsx}"],
+      // A target's bin is an entry point of its own, run as a process rather than imported.
+      entry: ["src/index.{ts,tsx}", "src/bin.ts"],
       project: ["src/**/*.{ts,tsx}!"],
     },
   },
diff --git a/packages/core/graph/domain/README.md b/packages/core/graph/domain/README.md
index 3add645..3bbe363 100644
--- a/packages/core/graph/domain/README.md
+++ b/packages/core/graph/domain/README.md
@@ -25,19 +25,20 @@ deriveStatuses(model, overlay, facts); // Map { "triage" => "done", ... }
 
 ## Functions
 
-| Function                                      | Result                                                                                  |
-| --------------------------------------------- | --------------------------------------------------------------------------------------- |
-| `controlDag(model)`                           | The `graph-dag` `Dag` over element ids, with loop edges removed.                        |
-| `loopTransitions(model)`                      | The transitions that close a legal decision loop.                                       |
-| `illegalCycles(model)`                        | The cycles of the control graph, each with its path.                                    |
-| `evaluateBranches(model, overlay, facts)`     | Each transition's `taken`, `not-taken` or `indeterminate`.                              |
-| `deriveStatuses(model, overlay, facts)`       | The `Status` of every element.                                                          |
-| `readySet(model, overlay, facts)`             | The elements that are `ready`.                                                          |
-| `blockedBy(model, overlay, facts, id)`        | The open leaves an element is waiting on.                                               |
-| `impact(model, overlay, facts, id)`           | The live elements that transitively depend on `id`.                                     |
-| `whatIfDone(model, overlay, facts, id)`       | The elements that become ready and every status change if `id` were done.               |
-| `criticalPath(model, overlay, facts, weight)` | The heaviest chain through the work still ahead.                                        |
-| `unmetOutputs(model, overlay, facts)`         | Each deliverable not yet produced, with the elements and missing inputs it still needs. |
+| Function                                      | Result                                                                                   |
+| --------------------------------------------- | ---------------------------------------------------------------------------------------- |
+| `controlDag(model)`                           | The `graph-dag` `Dag` over element ids, with loop edges removed.                         |
+| `loopTransitions(model)`                      | The transitions that close a legal decision loop.                                        |
+| `illegalCycles(model)`                        | The cycles of the control graph, each with its path.                                     |
+| `evaluateBranches(model, overlay, facts)`     | Each transition's `taken`, `not-taken` or `indeterminate`.                               |
+| `deriveStatuses(model, overlay, facts)`       | The `Status` of every element.                                                           |
+| `readySet(model, overlay, facts)`             | The elements that are `ready`.                                                           |
+| `blockedBy(model, overlay, facts, id)`        | The open leaves an element is waiting on.                                                |
+| `impact(model, overlay, facts, id)`           | The live elements that transitively depend on `id`.                                      |
+| `explainStatus(model, overlay, facts, id)`    | The rule that decided `id`'s status, what it was decided from, and the blocked-by chain. |
+| `whatIfDone(model, overlay, facts, id)`       | The elements that become ready and every status change if `id` were done.                |
+| `criticalPath(model, overlay, facts, weight)` | The heaviest chain through the work still ahead.                                         |
+| `unmetOutputs(model, overlay, facts)`         | Each deliverable not yet produced, with the elements and missing inputs it still needs.  |
 
 Every function that derives status throws `CycleError` (from `graph-dag`, carrying the cycles) when `illegalCycles` is not empty, `UnknownNodeError` when a transition names an element the model does not declare, and `UnsupportedConditionError` for a condition the facts port cannot serve.
 
@@ -84,7 +85,9 @@ The `Facts` port is `(key: JsonValue) => Resolution`: an opaque key in, `{ found
 
 ## Queries
 
-`blockedBy` starts at an element's unfinished needs and follows each one's own unfinished needs to the elements that wait on nothing further: the minimal set of open work to finish first. Cut transitions and provided artefacts are not followed. An element that is not blocked by anything returns an empty list.
+`blockedBy` starts at an element's unfinished needs and follows each one's own unfinished needs to the elements that wait on nothing further: the minimal set of open work to finish first. Cut transitions and provided artefacts are not followed. An element that is not blocked by anything returns an empty list, and so does an element that is `done` or `skipped`, even one the overlay marked done ahead of its needs.
+
+`explainStatus` says why an element has its status. `rule` names the rule of the status table that decided it (`overlay-done`, `overlay-unknown`, `unknown-need`, `all-cut`, `needs-met` or `waiting`); `transitions` lists its incoming transitions other than loop edges, each with its branch, its source's status and whether it is cut; `artefacts` lists what it consumes, each with whether it is provided and its producers' statuses. `chain` is the blocked-by chain: the element, then every unfinished need reached from it, each with the needs it still waits on, so the links after the first that wait on nothing are exactly what `blockedBy` returns. The explanation is recorded by the derivation itself, so it never disagrees with `deriveStatuses`.
 
 `impact` follows live needs in reverse, so a branch that was not taken, a skipped element and an element already `done` carry no impact; `id` itself is not included.
 
diff --git a/packages/core/graph/domain/src/derive.ts b/packages/core/graph/domain/src/derive.ts
index a03b499..3ec7223 100644
--- a/packages/core/graph/domain/src/derive.ts
+++ b/packages/core/graph/domain/src/derive.ts
@@ -27,6 +27,68 @@ export interface Analysis<I extends IdSpace> {
    * For each element, the elements its progress still depends on: the sources of its incoming transitions that are not cut (the condition is not definitely false and the source is not skipped) and the producers of the artefacts it consumes that are neither provided nor produced already, except producers that are skipped. Includes elements that are done.
    */
   readonly liveNeeds: ReadonlyMap<I["element"], readonly I["element"][]>;
+  /** For each element, what its status was derived from, recorded by the derivation itself so an explanation never re-derives it. */
+  readonly basis: ReadonlyMap<I["element"], StatusBasis<I>>;
+}
+
+/** Which of the derivation's rules decided an element's status, in the order the rules are applied. */
+export const statusRules = [
+  "overlay-done",
+  "overlay-unknown",
+  "unknown-need",
+  "all-cut",
+  "needs-met",
+  "waiting",
+] as const;
+
+/**
+ * Which rule decided a status.
+ *
+ * - `overlay-done`: the overlay says `done`.
+ * - `overlay-unknown`: the overlay says `unknown`.
+ * - `unknown-need`: a live transition's condition is indeterminate or its source is `unknown`, or a consumed artefact that is not provided and has no done producer has an `unknown` producer.
+ * - `all-cut`: the element has incoming transitions and every one is cut, so it is `skipped`.
+ * - `needs-met`: every live need is done and every consumed artefact is satisfied, so it is `ready`, or `done` for a decision or pseudo-state.
+ * - `waiting`: anything else, so it is `blocked`.
+ */
+export type StatusRule = (typeof statusRules)[number];
+
+/** An incoming transition of an element, as the derivation saw it. Loop edges are not incoming transitions. */
+export interface IncomingBasis<I extends IdSpace> {
+  readonly transition: I["transition"];
+  readonly source: I["element"];
+  /** What the transition's condition evaluated to. */
+  readonly branch: Branch;
+  /** The derived status of the source. */
+  readonly sourceStatus: Status;
+  /** Whether the transition is cut: its condition is definitely false or its source is skipped. A cut transition is not a need. */
+  readonly cut: boolean;
+}
+
+/** A producer of a consumed artefact and its derived status. */
+export interface ProducerBasis<I extends IdSpace> {
+  readonly element: I["element"];
+  readonly status: Status;
+}
+
+/** A consumed artefact of an activity, as the derivation saw it. */
+export interface ArtefactBasis<I extends IdSpace> {
+  readonly artefact: I["artefact"];
+  /** Whether the facts port reports it provided from outside the process. */
+  readonly provided: boolean;
+  /** The activities that produce it, in model order. Empty when none does. */
+  readonly producers: readonly ProducerBasis<I>[];
+  /** Whether it is provided or a producer is done. */
+  readonly satisfied: boolean;
+}
+
+/** What one element's status was derived from. */
+export interface StatusBasis<I extends IdSpace> {
+  readonly rule: StatusRule;
+  /** The element's incoming transitions other than loop edges, in model order. */
+  readonly transitions: readonly IncomingBasis<I>[];
+  /** The artefacts the element consumes, in the order it lists them; empty for anything but an activity. */
+  readonly artefacts: readonly ArtefactBasis<I>[];
 }
 
 /**
@@ -84,18 +146,26 @@ export const analyse = <I extends IdSpace>({
 
   const statuses = new Map<I["element"], Status>();
   const liveNeeds = new Map<I["element"], readonly I["element"][]>();
+  const basis = new Map<I["element"], StatusBasis<I>>();
   for (const id of topologicalLayers(dag).layers.flat()) {
     const element = lookup(elements, id);
-    const edges = lookup(incoming, id).map((transitionId) => ({
-      source: lookup(transitions, transitionId).source,
-      branch: lookup(branches, transitionId),
-    }));
-    const live = edges.filter(
-      ({ source, branch }) =>
-        branch !== "not-taken" && lookup(statuses, source) !== "skipped",
-    );
+    const edges = lookup(incoming, id).map((transitionId) => {
+      const source = lookup(transitions, transitionId).source;
+      const branch = lookup(branches, transitionId);
+      const sourceStatus = lookup(statuses, source);
+
+      return {
+        transition: transitionId,
+        source,
+        branch,
+        sourceStatus,
+        cut: branch === "not-taken" || sourceStatus === "skipped",
+      };
+    });
+    const live = edges.filter(({ cut }) => !cut);
 
     const dataNeeds = new Set<I["element"]>();
+    const artefacts: ArtefactBasis<I>[] = [];
     let dataUnknown = false;
     let dataUnmet = false;
     for (const artefact of element.kind === "activity"
@@ -103,7 +173,18 @@ export const analyse = <I extends IdSpace>({
       : []) {
       const makers = producers.get(artefact) ?? [];
       const made = makers.map((maker) => lookup(statuses, maker));
-      if (isProvided(facts, artefact) || made.includes("done")) {
+      const provided = isProvided(facts, artefact);
+      const satisfied = provided || made.includes("done");
+      artefacts.push({
+        artefact,
+        provided,
+        producers: makers.map((maker) => ({
+          element: maker,
+          status: lookup(statuses, maker),
+        })),
+        satisfied,
+      });
+      if (satisfied) {
         continue;
       }
       dataUnmet = true;
@@ -120,31 +201,40 @@ export const analyse = <I extends IdSpace>({
 
     const own = overlay[id];
     let status: Status;
+    let rule: StatusRule;
     if (own === "done") {
       status = "done";
+      rule = "overlay-done";
+    } else if (own === "unknown") {
+      status = "unknown";
+      rule = "overlay-unknown";
     } else if (
-      own === "unknown" ||
       dataUnknown ||
       live.some(
-        ({ source, branch }) =>
-          branch === "indeterminate" || lookup(statuses, source) === "unknown",
+        ({ branch, sourceStatus }) =>
+          branch === "indeterminate" || sourceStatus === "unknown",
       )
     ) {
       status = "unknown";
+      rule = "unknown-need";
     } else if (edges.length > 0 && live.length === 0) {
       status = "skipped";
+      rule = "all-cut";
     } else if (
       !dataUnmet &&
-      live.every(({ source }) => lookup(statuses, source) === "done")
+      live.every(({ sourceStatus }) => sourceStatus === "done")
     ) {
       status =
         element.kind === "decision" || element.kind === "pseudo"
           ? "done"
           : "ready";
+      rule = "needs-met";
     } else {
       status = "blocked";
+      rule = "waiting";
     }
     statuses.set(id, status);
+    basis.set(id, { rule, transitions: edges, artefacts });
   }
 
   return {
@@ -152,6 +242,7 @@ export const analyse = <I extends IdSpace>({
     branches,
     statuses: new Map(dag.nodes.map((id) => [id, lookup(statuses, id)])),
     liveNeeds,
+    basis,
   };
 };
 
diff --git a/packages/core/graph/domain/src/explain.ts b/packages/core/graph/domain/src/explain.ts
new file mode 100644
index 0000000..a680824
--- /dev/null
+++ b/packages/core/graph/domain/src/explain.ts
@@ -0,0 +1,86 @@
+import type { IdSpace, Model, Overlay } from "@exadev/process-graph-schema";
+import {
+  analyse,
+  type ArtefactBasis,
+  type IncomingBasis,
+  type StatusRule,
+} from "./derive.ts";
+import type { Facts } from "./facts.ts";
+import { lookup } from "./lookup.ts";
+import { waitingOn } from "./progress.ts";
+import type { Status } from "./status.ts";
+
+/** One element of a blocked-by chain and the unfinished needs it still waits on. */
+export interface ChainLink<I extends IdSpace> {
+  readonly element: I["element"];
+  readonly status: Status;
+  /** The element's live needs that are not done, in model order. Empty for the open work at the end of the chain. */
+  readonly waitingOn: readonly I["element"][];
+}
+
+/** Why an element has the status it has. */
+export interface StatusExplanation<I extends IdSpace> {
+  readonly element: I["element"];
+  readonly status: Status;
+  /** The rule that decided the status. */
+  readonly rule: StatusRule;
+  /** The element's incoming transitions other than loop edges, each with its branch, its source's status and whether it is cut, in model order. */
+  readonly transitions: readonly IncomingBasis<I>[];
+  /** The artefacts the element consumes, each with whether it is provided and its producers' statuses. */
+  readonly artefacts: readonly ArtefactBasis<I>[];
+  /**
+   * The blocked-by chain: the element, then every unfinished need reached from it by following unfinished needs, in model order. The links after the first that wait on nothing are the elements `blockedBy` returns. A done or skipped element waits on nothing, so its chain is the element alone.
+   */
+  readonly chain: readonly ChainLink<I>[];
+}
+
+/**
+ * Explains an element's status: the rule that decided it, the transitions and artefacts it was decided from, and the chain of unfinished work behind it. The explanation is the derivation's own record, so it always agrees with `deriveStatuses` and `blockedBy`.
+ * @param model - The model to read.
+ * @param overlay - Run state by element id.
+ * @param facts - The injected source of facts conditions read, and of which input artefacts are provided.
+ * @param id - The element asked about.
+ * @returns The explanation.
+ * @throws UnknownNodeError when `id` is not an element.
+ * @throws CycleError when the control graph has an illegal cycle.
+ */
+export const explainStatus = <I extends IdSpace>(
+  model: Model<I>,
+  overlay: Readonly<Overlay<I>>,
+  facts: Facts,
+  id: I["element"],
+): StatusExplanation<I> => {
+  const analysis = analyse({ model, overlay, facts });
+  const basis = lookup(analysis.basis, id);
+  const reached = new Map<I["element"], readonly I["element"][]>();
+  const pending = [id];
+  for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+    if (reached.has(next)) {
+      continue;
+    }
+    const needs = waitingOn(analysis, next);
+    reached.set(next, needs);
+    pending.push(...needs);
+  }
+  const link = (element: I["element"]): ChainLink<I> => ({
+    element,
+    status: lookup(analysis.statuses, element),
+    waitingOn: analysis.dag.nodes.filter((node) =>
+      lookup(reached, element).includes(node),
+    ),
+  });
+
+  return {
+    element: id,
+    status: lookup(analysis.statuses, id),
+    rule: basis.rule,
+    transitions: basis.transitions,
+    artefacts: basis.artefacts,
+    chain: [
+      link(id),
+      ...analysis.dag.nodes
+        .filter((node) => node !== id && reached.has(node))
+        .map(link),
+    ],
+  };
+};
diff --git a/packages/core/graph/domain/src/explain.unit.test.ts b/packages/core/graph/domain/src/explain.unit.test.ts
new file mode 100644
index 0000000..19f24f5
--- /dev/null
+++ b/packages/core/graph/domain/src/explain.unit.test.ts
@@ -0,0 +1,135 @@
+import { UnknownNodeError } from "@exadev/process-graph-dag";
+import type { OpenIds } from "@exadev/process-graph-schema";
+import { describe, expect, it } from "vitest";
+import { deriveStatuses } from "./derive.ts";
+import { explainStatus } from "./explain.ts";
+import { blockedBy } from "./queries.ts";
+import { factsOf, noFacts } from "./test-support/conditions.ts";
+import { approval, chain, diamond, pipeline } from "./test-support/models.ts";
+
+describe("explainStatus", () => {
+  it("names the overlay when it decided the status", () => {
+    expect(explainStatus(chain, { b: "done" }, noFacts, "b")).toMatchObject({
+      element: "b",
+      status: "done",
+      rule: "overlay-done",
+      chain: [{ element: "b", status: "done", waitingOn: [] }],
+    });
+    expect(explainStatus(chain, { a: "unknown" }, noFacts, "a")).toMatchObject({
+      status: "unknown",
+      rule: "overlay-unknown",
+    });
+  });
+
+  it("gives the whole chain of unfinished work behind a blocked element", () => {
+    expect(explainStatus(chain, {}, noFacts, "c")).toEqual({
+      element: "c",
+      status: "blocked",
+      rule: "waiting",
+      transitions: [
+        {
+          transition: "bc",
+          source: "b",
+          branch: "taken",
+          sourceStatus: "blocked",
+          cut: false,
+        },
+      ],
+      artefacts: [],
+      chain: [
+        { element: "c", status: "blocked", waitingOn: ["b"] },
+        { element: "a", status: "ready", waitingOn: [] },
+        { element: "b", status: "blocked", waitingOn: ["a"] },
+      ],
+    });
+  });
+
+  it("branches the chain at a join and agrees with blockedBy on its ends", () => {
+    const explained = explainStatus(diamond, { a: "done" }, noFacts, "d");
+
+    expect(explained.chain).toEqual([
+      { element: "d", status: "blocked", waitingOn: ["b", "c"] },
+      { element: "b", status: "ready", waitingOn: [] },
+      { element: "c", status: "ready", waitingOn: [] },
+    ]);
+    expect(
+      explained.chain
+        .slice(1)
+        .filter((link) => link.waitingOn.length === 0)
+        .map((link) => link.element),
+    ).toEqual(blockedBy(diamond, { a: "done" }, noFacts, "d"));
+  });
+
+  it("explains a ready element as having its needs met", () => {
+    expect(explainStatus(chain, { a: "done" }, noFacts, "b")).toMatchObject({
+      status: "ready",
+      rule: "needs-met",
+      transitions: [{ source: "a", sourceStatus: "done", cut: false }],
+      chain: [{ element: "b", waitingOn: [] }],
+    });
+  });
+
+  it("explains a skipped element by its cut transitions", () => {
+    expect(
+      explainStatus(
+        approval,
+        { triage: "done" },
+        factsOf({ approved: false }),
+        "accept",
+      ),
+    ).toMatchObject({
+      status: "skipped",
+      rule: "all-cut",
+      transitions: [
+        {
+          transition: "t-accept",
+          source: "choose",
+          branch: "not-taken",
+          sourceStatus: "done",
+          cut: true,
+        },
+      ],
+    });
+  });
+
+  it("explains an unknown element by its indeterminate condition", () => {
+    expect(
+      explainStatus(approval, { triage: "done" }, noFacts, "accept"),
+    ).toMatchObject({
+      status: "unknown",
+      rule: "unknown-need",
+      transitions: [{ transition: "t-accept", branch: "indeterminate" }],
+    });
+  });
+
+  it("reports each consumed artefact with whether it is satisfied", () => {
+    expect(explainStatus(pipeline, {}, noFacts, "build")).toMatchObject({
+      status: "blocked",
+      rule: "waiting",
+      artefacts: [
+        { artefact: "spec", provided: false, producers: [], satisfied: false },
+      ],
+    });
+    expect(
+      explainStatus(pipeline, {}, factsOf({}, ["spec"]), "build"),
+    ).toMatchObject({
+      status: "ready",
+      rule: "needs-met",
+      artefacts: [{ artefact: "spec", provided: true, satisfied: true }],
+    });
+  });
+
+  it("agrees with deriveStatuses on every element", () => {
+    const overlay = { triage: "done" } as const;
+    const facts = factsOf({ approved: true });
+    for (const [id, status] of deriveStatuses(approval, overlay, facts)) {
+      expect(explainStatus(approval, overlay, facts, id).status).toBe(status);
+    }
+  });
+
+  it("throws for an element the model does not declare", () => {
+    expect(() => explainStatus<OpenIds>(chain, {}, noFacts, "z")).toThrow(
+      UnknownNodeError,
+    );
+  });
+});
diff --git a/packages/core/graph/domain/src/index.ts b/packages/core/graph/domain/src/index.ts
index 193838a..b182c86 100644
--- a/packages/core/graph/domain/src/index.ts
+++ b/packages/core/graph/domain/src/index.ts
@@ -10,7 +10,20 @@ export {
   type Facts,
 } from "./facts.ts";
 export { controlDag, illegalCycles, loopTransitions } from "./control.ts";
-export { deriveStatuses } from "./derive.ts";
+export {
+  deriveStatuses,
+  statusRules,
+  type ArtefactBasis,
+  type IncomingBasis,
+  type ProducerBasis,
+  type StatusBasis,
+  type StatusRule,
+} from "./derive.ts";
+export {
+  explainStatus,
+  type ChainLink,
+  type StatusExplanation,
+} from "./explain.ts";
 export {
   blockedBy,
   criticalPath,
diff --git a/packages/core/graph/domain/src/progress.ts b/packages/core/graph/domain/src/progress.ts
new file mode 100644
index 0000000..8aaff69
--- /dev/null
+++ b/packages/core/graph/domain/src/progress.ts
@@ -0,0 +1,19 @@
+import type { IdSpace } from "@exadev/process-graph-schema";
+import type { Analysis } from "./derive.ts";
+import { lookup } from "./lookup.ts";
+import type { Status } from "./status.ts";
+
+/** Whether an element still has work ahead of it: it is neither finished nor going to be skipped. */
+export const isLive = (status: Status): boolean =>
+  status !== "done" && status !== "skipped";
+
+/** The live needs of an element that are not done: what it is still waiting for. A finished or skipped element waits on nothing, even when the overlay marked it done ahead of its needs or it consumes an artefact still to be made. */
+export const waitingOn = <I extends IdSpace>(
+  analysis: Analysis<I>,
+  id: I["element"],
+): readonly I["element"][] =>
+  isLive(lookup(analysis.statuses, id))
+    ? lookup(analysis.liveNeeds, id).filter(
+        (need) => lookup(analysis.statuses, need) !== "done",
+      )
+    : [];
diff --git a/packages/core/graph/domain/src/queries.ts b/packages/core/graph/domain/src/queries.ts
index d3aa667..7b95215 100644
--- a/packages/core/graph/domain/src/queries.ts
+++ b/packages/core/graph/domain/src/queries.ts
@@ -4,24 +4,12 @@ import {
   type CriticalPath,
 } from "@exadev/process-graph-dag";
 import type { IdSpace, Model, Overlay } from "@exadev/process-graph-schema";
-import { analyse, type Analysis } from "./derive.ts";
+import { analyse } from "./derive.ts";
 import { isProvided, type Facts } from "./facts.ts";
 import { lookup } from "./lookup.ts";
+import { isLive, waitingOn } from "./progress.ts";
 import type { Status } from "./status.ts";
 
-/** Whether an element still has work ahead of it: it is neither finished nor going to be skipped. */
-const isLive = (status: Status): boolean =>
-  status !== "done" && status !== "skipped";
-
-/** The live needs of an element that are not done: what it is still waiting for. */
-const waitingOn = <I extends IdSpace>(
-  analysis: Analysis<I>,
-  id: I["element"],
-): readonly I["element"][] =>
-  lookup(analysis.liveNeeds, id).filter(
-    (need) => lookup(analysis.statuses, need) !== "done",
-  );
-
 /**
  * The elements that can be worked on now: every element whose status is `ready`, in model order. Pure control elements (decisions and pseudo-states) are derived `done` and never appear.
  * @param model - The model to read.
diff --git a/packages/core/graph/domain/src/queries.unit.test.ts b/packages/core/graph/domain/src/queries.unit.test.ts
index 7a3e312..78569a2 100644
--- a/packages/core/graph/domain/src/queries.unit.test.ts
+++ b/packages/core/graph/domain/src/queries.unit.test.ts
@@ -1,3 +1,4 @@
+import { defineModel } from "@exadev/process-graph-schema";
 import { describe, expect, it } from "vitest";
 import {
   blockedBy,
@@ -6,7 +7,7 @@ import {
   unmetOutputs,
   whatIfDone,
 } from "./queries.ts";
-import { factsOf, noFacts } from "./test-support/conditions.ts";
+import { factsOf, holds, noFacts } from "./test-support/conditions.ts";
 import { approval, chain, diamond, pipeline } from "./test-support/models.ts";
 
 describe("blockedBy", () => {
@@ -25,6 +26,50 @@ describe("blockedBy", () => {
     expect(blockedBy(chain, { a: "done" }, noFacts, "a")).toEqual([]);
   });
 
+  it("is empty for an element marked done while its needs are still open", () => {
+    expect(blockedBy(chain, { c: "done" }, noFacts, "c")).toEqual([]);
+  });
+
+  it("is empty for a skipped element, even one consuming an artefact still to be made", () => {
+    const skippedConsumer = defineModel({
+      participants: [{ id: "team", label: "Team", kind: "role" }],
+      events: [],
+      actions: [],
+      artefacts: [{ id: "spec", name: "Spec" }],
+      elements: [
+        { kind: "decision", id: "choose", label: "Build?", actor: "team" },
+        {
+          kind: "activity",
+          id: "build",
+          label: "Build",
+          actor: "team",
+          consumes: ["spec"],
+        },
+        {
+          kind: "activity",
+          id: "write",
+          label: "Write",
+          actor: "team",
+          produces: ["spec"],
+        },
+      ],
+      transitions: [
+        {
+          id: "t-build",
+          source: "choose",
+          target: "build",
+          condition: holds("wanted"),
+        },
+      ],
+      fragments: [],
+      projections: [],
+    });
+
+    expect(
+      blockedBy(skippedConsumer, {}, factsOf({ wanted: false }), "build"),
+    ).toEqual([]);
+  });
+
   it("names an element whose state is unknown as the leaf", () => {
     expect(blockedBy(chain, { a: "unknown" }, noFacts, "c")).toEqual(["a"]);
   });
diff --git a/packages/targets/graph-cli/AGENTS.md b/packages/targets/graph-cli/AGENTS.md
new file mode 120000
index 0000000..42061c0
--- /dev/null
+++ b/packages/targets/graph-cli/AGENTS.md
@@ -0,0 +1 @@
+README.md
\ No newline at end of file
diff --git a/packages/targets/graph-cli/CLAUDE.md b/packages/targets/graph-cli/CLAUDE.md
new file mode 120000
index 0000000..42061c0
--- /dev/null
+++ b/packages/targets/graph-cli/CLAUDE.md
@@ -0,0 +1 @@
+README.md
\ No newline at end of file
diff --git a/packages/targets/graph-cli/README.md b/packages/targets/graph-cli/README.md
new file mode 100644
index 0000000..a1fcdbf
--- /dev/null
+++ b/packages/targets/graph-cli/README.md
@@ -0,0 +1,101 @@
+# @exadev/process-graph-cli
+
+[![GitHub](https://img.shields.io/badge/GitHub-181717?logo=github&logoColor=white)](https://github.com/ExaDev/process-graph) [![npm](https://img.shields.io/badge/npm-CB3837?logo=npm&logoColor=white)](https://www.npmjs.com/package/@exadev/process-graph-cli) [![Release](https://img.shields.io/github/v/release/ExaDev/process-graph)](https://github.com/ExaDev/process-graph/releases/latest) [![CI](https://img.shields.io/github/actions/workflow/status/ExaDev/process-graph/ci.yml?branch=main)](https://github.com/ExaDev/process-graph/actions)
+
+The process-graph command line, and the same commands as a library. It syncs work from GitHub issues into a SQLite store, answers what is ready, blocked, affected, on the critical path or handed off between owners, explains why an element has its status, builds and edits a model by hand, and draws the model as a flowchart, swimlane, state machine or sequence diagram in Mermaid or Graphviz DOT.
+
+It is a composition root and nothing else: the model, reasoning, projections, sources and store are the other packages of this repository, and this package wires them to a command line through injected ports. The unscoped [`process-graph`](../process-graph/README.md) package carries the same command line as its `process-graph` bin; this package's own bin is `process-graph-cli`.
+
+```sh
+process-graph sync github:ExaDev github:Mearman/agent-permissions
+process-graph ready
+process-graph why github:ExaDev/process-graph#12
+process-graph show --view swimlane --format mermaid
+```
+
+## Commands
+
+| Command                                                                              | What it does                                                                                                                                         |
+| ------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `sync <scope...> [--after <cursor>]`                                                 | Reads the scopes from their sources and merges them into the model in one write; prints what it wrote and any gaps.                                  |
+| `ready`                                                                              | The work that can start now.                                                                                                                         |
+| `blocked <id>`                                                                       | The open work an element is waiting on: the ends of its blocked-by chain.                                                                            |
+| `impact <id>`                                                                        | The live work that depends on an element.                                                                                                            |
+| `path`                                                                               | The critical path: the longest chain of work still ahead, each element counting one step.                                                            |
+| `cycles`                                                                             | The cycles no decision closes.                                                                                                                       |
+| `handoffs`                                                                           | The transitions from one actor's work to another's, such as a dependency across repositories or organisations.                                       |
+| `why <id>`                                                                           | The rule that decided an element's status, its needs and artefacts, and the blocked-by chain behind it.                                              |
+| `show [--view <view>] [--format <format>]`                                           | Draws the model. Views: `flowchart` (default), `swimlane`, `state`, `sequence`. Formats: `mermaid` (default), `dot`, `json` (the projection itself). |
+| `add participant <id> <label> [--kind <kind>]`                                       | Adds a `role` (default), `system` or `entity`.                                                                                                       |
+| `add activity <id> <label> [--actor <participant>]`                                  | Adds a step of work.                                                                                                                                 |
+| `add decision <id> <label> [--actor <participant>]`                                  | Adds a point where the flow branches.                                                                                                                |
+| `add state <id> <label> [--parent <state>]`                                          | Adds a state an entity rests in.                                                                                                                     |
+| `add event <id> <name>`                                                              | Adds an event that can trigger a transition.                                                                                                         |
+| `add artefact <id> <name> [--deliverable]`                                           | Adds something activities consume or produce.                                                                                                        |
+| `add transition <source> <target> [--id <id>] [--guard <label>] [--trigger <event>]` | Adds a transition; the target waits on the source. Its identifier defaults to `<source>-><target>`, the form sources use.                            |
+| `set <id> <done\|open\|unknown>`                                                     | Sets an element's run state.                                                                                                                         |
+| `validate [file]`                                                                    | Checks the stored model and run state, or a model document as JSON, for structural issues and illegal cycles.                                        |
+
+`show --view state` follows an entity given with `--subject`, and `show --view sequence` follows the transitions given with `--scenario`; each defaults to the matching projection the model declares.
+
+Every command takes the global options:
+
+| Option          | Default                                            | Meaning                                                     |
+| --------------- | -------------------------------------------------- | ----------------------------------------------------------- |
+| `--data <path>` | `PROCESS_GRAPH_DATA`, else the XDG data file below | The SQLite file the store keeps. It is created when absent. |
+| `--model <id>`  | `default`                                          | The model in the store; one file holds many.                |
+| `--json`        | off                                                | Writes the result as JSON.                                  |
+
+Without `--data` or `PROCESS_GRAPH_DATA`, the store is `process-graph/graph.sqlite3` under `XDG_DATA_HOME`, or under `~/.local/share` when that is not set.
+
+## Output
+
+Text output is stable and made for scripts: a list is one item per line with tab-separated fields (an element is its identifier and label), and an empty list prints nothing. `--json` writes the same result as one JSON document; for `show` it is the projection when the format is `json`, and otherwise the view, the format and the diagram text. Errors go to standard error as one message, with no stack trace.
+
+The Mermaid emitters name nodes by their position in the view, since Mermaid does not accept identifiers such as `github:org/repo#12`, and write every character Mermaid reads as syntax in a label as its entity code. The DOT emitters keep the model identifiers as node names. Hand-offs are drawn as thick (Mermaid) or bold (DOT) edges, and an empty swimlane lane is still drawn. DOT has no sequence notation, so a sequence diagram in DOT is a grid of lifelines with one row per message, each message numbered and prefixed with the fragments around it.
+
+## Exit status
+
+| Status | Meaning                                                                                                                                        |
+| ------ | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| 0      | Success; for `validate` and `cycles`, nothing wrong was found.                                                                                 |
+| 1      | A failure not listed below, such as a store that cannot be opened.                                                                             |
+| 2      | A usage error: an unknown command or option, a missing argument, a value outside its choices, or a view with nothing to follow.                |
+| 3      | The model, an element or another identifier named on the command line does not exist.                                                          |
+| 4      | The model has problems: `validate` found issues, `cycles` found one, a reasoning command met an illegal cycle, or the store rejected a change. |
+| 5      | A source refused the sync: credentials, a rate limit or a scope it does not accept.                                                            |
+
+## Sources and tokens
+
+Scopes are source-qualified: `github:owner` reads every repository an account owns and `github:owner/repo` one repository. The GitHub token comes from `GITHUB_TOKEN`, or from the GitHub CLI (`gh auth token`) when that is not set; it is sent only to GitHub and never printed.
+
+A sync merges everything it reads into the model in one write, so a record synced again is replaced by identifier and the rest of the model is kept. When a source fails part way, as on a rate limit, the pages read before the failure are still written and the error prints the command that resumes the sync with `--after`. Relations a source reports (sub-issues, assignees, repository membership) have no place in the store and are not kept.
+
+## Library
+
+`runCli(args, ports, identity)` runs the whole command surface as a function and resolves with the exit status; it never reads `process.argv`, writes to the process's streams or exits. `CliPorts` is everything it touches: `stdout` and `stderr`, `openStore(path)` (any `GraphStoreClient`, over any transport), `defaultDataPath`, `source(prefix)` (any `GraphSourceClient`), `readFile`, the `facts` decision conditions read, and the abort `signal`. `nodePorts(options)` builds them for a Node process, with the environment, home directory, GitHub token port, `fetch`, clock, facts, signal and streams each replaceable; `runProcess(identity)` is what the bins run.
+
+A host program mounts the command line as a subcommand by forwarding its arguments:
+
+```ts
+import { nodePorts, packageVersion, runCli } from "@exadev/process-graph-cli";
+
+// sb graph <args...>
+process.exitCode = await runCli(args, nodePorts(), {
+  name: "sb graph",
+  version: packageVersion(new URL("../package.json", import.meta.url)),
+});
+```
+
+The operation behind each command is exported on its own and returns plain data rather than text, for hosts that want results, such as tools served over MCP: `sync`, `ready`, `blocked`, `impactOf`, `path`, `cycles`, `handoffsOf`, `why`, `show`, `add`, `setState`, `validateStored` and `validateDocument`, each taking a `GraphSession` (a store client, a model id, facts and a signal). The emitters `flowchartToMermaid`, `swimlaneToMermaid`, `stateMachineToMermaid`, `sequenceToMermaid` and their `...ToDot` counterparts are pure functions of a projection.
+
+`add` reads the model and saves it whole, so a write another process makes between the two is overwritten; the store checks every save, so a duplicate identifier or a dangling reference is rejected and nothing changes.
+
+## Commands
+
+```sh
+pnpm build          # tsc -b -> dist/ (ESM + .d.ts), including the bin
+pnpm test           # unit tests, end to end against an in-memory source and a SQLite file
+pnpm test:smoke     # the built dist/ as a library and the built bin as a process
+pnpm test:mutation  # Stryker
+```
diff --git a/packages/targets/graph-cli/eslint.config.ts b/packages/targets/graph-cli/eslint.config.ts
new file mode 100644
index 0000000..c431768
--- /dev/null
+++ b/packages/targets/graph-cli/eslint.config.ts
@@ -0,0 +1,10 @@
+import { defineConfig } from "eslint/config";
+import { packageLintConfig } from "../../../eslint.shared.ts";
+
+export default defineConfig(
+  packageLintConfig({
+    tsconfigRootDir: import.meta.dirname,
+    // Node-only by design: it is the command line, opening the store with node:sqlite and writing to the process's streams.
+    projects: ["./tsconfig.json"],
+  }),
+);
diff --git a/packages/targets/graph-cli/package.json b/packages/targets/graph-cli/package.json
new file mode 100644
index 0000000..bac13e5
--- /dev/null
+++ b/packages/targets/graph-cli/package.json
@@ -0,0 +1,88 @@
+{
+  "name": "@exadev/process-graph-cli",
+  "version": "0.0.0",
+  "description": "The process-graph command line: sync work from GitHub issues into a SQLite store, ask what is ready, blocked or on the critical path, explain a status, and show the model as a flowchart, swimlane, state machine or sequence diagram in Mermaid or Graphviz DOT.",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ExaDev/process-graph.git",
+    "directory": "packages/targets/graph-cli"
+  },
+  "homepage": "https://github.com/ExaDev/process-graph/tree/main/packages/targets/graph-cli#readme",
+  "bugs": {
+    "url": "https://github.com/ExaDev/process-graph/issues"
+  },
+  "bin": {
+    "process-graph-cli": "./dist/bin.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "sideEffects": [
+    "./dist/bin.js"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "turbo run _build",
+    "_build": "tsc -b tsconfig.build.json",
+    "lint": "turbo run _lint",
+    "_lint": "eslint . --cache --max-warnings 0",
+    "_lint:fix": "eslint . --fix --cache --max-warnings 0",
+    "typecheck": "turbo run _typecheck _typecheck:attw",
+    "_typecheck": "tsc -p tsconfig.json --noEmit",
+    "_typecheck:attw": "attw --pack --profile esm-only",
+    "test": "turbo run _test",
+    "_test": "vitest run --project unit",
+    "test:coverage": "turbo run _test:coverage",
+    "_test:coverage": "vitest run --project unit --coverage",
+    "test:smoke": "turbo run _test:smoke",
+    "_test:smoke": "vitest run --project smoke",
+    "test:mutation": "turbo run _test:mutation",
+    "_test:mutation": "stryker run stryker.config.ts",
+    "prepublishOnly": "pnpm run lint && pnpm run typecheck && pnpm run test && pnpm run build && publint && attw --pack --profile esm-only"
+  },
+  "keywords": [
+    "process-model",
+    "dependency-graph",
+    "cli",
+    "github-issues",
+    "mermaid",
+    "graphviz"
+  ],
+  "dependencies": {
+    "@exadev/process-graph-dag": "1.0.2",
+    "@exadev/process-graph-domain": "1.0.3",
+    "@exadev/process-graph-projection": "1.0.3",
+    "@exadev/process-graph-schema": "1.1.0",
+    "@exadev/process-graph-source-contract": "1.0.1",
+    "@exadev/process-graph-source-github-issues": "1.0.1",
+    "@exadev/process-graph-sqlite-node": "1.0.0",
+    "@exadev/process-graph-store-contract": "1.0.1",
+    "@orpc/server": "2.0.0-beta.41",
+    "commander": "15.0.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.5",
+    "@stryker-mutator/core": "10.0.0",
+    "@stryker-mutator/typescript-checker": "10.0.0",
+    "@stryker-mutator/vitest-runner": "10.0.0",
+    "@types/node": "26.6.4",
+    "@vitest/coverage-v8": "5.0.3",
+    "eslint": "10.12.0",
+    "publint": "0.3.25",
+    "typescript": "6.0.3",
+    "vitest": "5.0.3"
+  }
+}
diff --git a/packages/targets/graph-cli/src/bin.ts b/packages/targets/graph-cli/src/bin.ts
new file mode 100644
index 0000000..5feeddf
--- /dev/null
+++ b/packages/targets/graph-cli/src/bin.ts
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { packageVersion, runProcess } from "./node.ts";
+
+process.exitCode = await runProcess({
+  name: "process-graph-cli",
+  version: packageVersion(new URL("../package.json", import.meta.url)),
+});
diff --git a/packages/targets/graph-cli/src/cli-authoring.unit.test.ts b/packages/targets/graph-cli/src/cli-authoring.unit.test.ts
new file mode 100644
index 0000000..29b92d6
--- /dev/null
+++ b/packages/targets/graph-cli/src/cli-authoring.unit.test.ts
@@ -0,0 +1,552 @@
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { exitCodes } from "./exit-codes.ts";
+import {
+  createHarness,
+  runInOrder,
+  type Harness,
+} from "./test-support/harness.ts";
+
+let harness: Harness;
+
+beforeEach(() => {
+  harness = createHarness();
+});
+
+afterEach(() => {
+  harness.remove();
+});
+
+/** An order process built through `add`: a customer submits, the shop decides whether the order is in stock, then packs it or the customer is refunded. */
+const orderSteps: readonly (readonly string[])[] = [
+  ["add", "participant", "customer", "Customer"],
+  ["add", "participant", "shop", "Shop", "--kind", "system"],
+  ["add", "participant", "order", "Order", "--kind", "entity"],
+  ["add", "participant", "courier", "Courier", "--kind", "system"],
+  ["add", "activity", "submit", "Submit order", "--actor", "customer"],
+  ["add", "decision", "stock", "In stock?", "--actor", "shop"],
+  ["add", "activity", "pack", "Pack", "--actor", "shop"],
+  ["add", "activity", "refund", "Refund", "--actor", "customer"],
+  ["add", "transition", "submit", "stock", "--id", "t1"],
+  ["add", "transition", "stock", "pack", "--id", "t2", "--guard", "yes"],
+  ["add", "transition", "stock", "refund", "--id", "t3", "--guard", "no"],
+];
+
+describe("add", () => {
+  test("creates the model and reports each record with the revision it took", async () => {
+    const results = await runInOrder(harness, orderSteps.slice(0, 2));
+
+    expect(results).toEqual([
+      {
+        code: exitCodes.success,
+        stdout: "added participant customer at revision 1\n",
+        stderr: "",
+      },
+      {
+        code: exitCodes.success,
+        stdout: "added participant shop at revision 2\n",
+        stderr: "",
+      },
+    ]);
+  });
+
+  test("names a transition after its ends when no identifier is given", async () => {
+    await runInOrder(
+      harness,
+      orderSteps.filter(([, kind]) => kind !== "transition"),
+    );
+
+    expect(
+      JSON.parse(
+        (await harness.run("add", "transition", "submit", "stock", "--json"))
+          .stdout,
+      ),
+    ).toEqual({ added: "transition", id: "submit->stock", revision: 9 });
+  });
+
+  test("adds events, states and deliverable artefacts", async () => {
+    const results = await runInOrder(harness, [
+      ["add", "event", "paid", "Payment received"],
+      ["add", "state", "waiting", "Waiting"],
+      ["add", "artefact", "invoice", "Invoice", "--deliverable"],
+      ["validate", "--json"],
+    ]);
+
+    expect(results.map((result) => result.code)).toEqual([
+      exitCodes.success,
+      exitCodes.success,
+      exitCodes.success,
+      exitCodes.success,
+    ]);
+    expect(results.at(-1)?.stdout).toBe(
+      '{\n  "valid": true,\n  "issues": []\n}\n',
+    );
+  });
+
+  test("rejects a record that would leave the model invalid, and changes nothing", async () => {
+    await runInOrder(harness, orderSteps.slice(0, 1));
+    const duplicate = await harness.run(
+      "add",
+      "participant",
+      "customer",
+      "Again",
+    );
+    const dangling = await harness.run(
+      "add",
+      "transition",
+      "submit",
+      "nowhere",
+    );
+
+    expect(duplicate.code).toBe(exitCodes.invalidModel);
+    expect(duplicate.stderr).toContain("duplicate-id");
+    expect(dangling.code).toBe(exitCodes.invalidModel);
+    expect(dangling.stderr).toContain("unknown-reference");
+    expect(
+      JSON.parse((await harness.run("validate", "--json")).stdout),
+    ).toEqual({
+      valid: true,
+      issues: [],
+    });
+  });
+
+  test("rejects a participant kind outside its choices as a usage error", async () => {
+    const result = await harness.run(
+      "add",
+      "participant",
+      "x",
+      "X",
+      "--kind",
+      "robot",
+    );
+
+    expect(result.code).toBe(exitCodes.usage);
+    expect(result.stderr).toContain(
+      "error: option '--kind <kind>' argument 'robot' is invalid. Allowed choices are role, system, entity.",
+    );
+  });
+});
+
+describe("show", () => {
+  beforeEach(async () => {
+    const results = await runInOrder(harness, orderSteps);
+    expect(results.every((result) => result.code === exitCodes.success)).toBe(
+      true,
+    );
+  });
+
+  test("draws the flowchart in Mermaid by default", async () => {
+    expect(await harness.run("show")).toEqual({
+      code: exitCodes.success,
+      stdout: [
+        "flowchart TD",
+        '  n0["Submit order"]',
+        '  n1{"In stock?"}',
+        '  n2["Pack"]',
+        '  n3["Refund"]',
+        "  n0 --> n1",
+        '  n1 -->|"yes"| n2',
+        '  n1 -->|"no"| n3',
+        "",
+      ].join("\n"),
+      stderr: "",
+    });
+  });
+
+  test("draws the flowchart in DOT", async () => {
+    expect(
+      (await harness.run("show", "--view", "flowchart", "--format", "dot"))
+        .stdout,
+    ).toBe(
+      [
+        'digraph "flowchart" {',
+        '  rankdir="TB";',
+        '  "submit" [label="Submit order", shape="box"];',
+        '  "stock" [label="In stock?", shape="diamond"];',
+        '  "pack" [label="Pack", shape="box"];',
+        '  "refund" [label="Refund", shape="box"];',
+        '  "submit" -> "stock";',
+        '  "stock" -> "pack" [label="yes"];',
+        '  "stock" -> "refund" [label="no"];',
+        "}",
+        "",
+      ].join("\n"),
+    );
+  });
+
+  test("draws the swimlane with a lane per actor, an empty lane kept and hand-offs thick", async () => {
+    expect((await harness.run("show", "--view", "swimlane")).stdout).toBe(
+      [
+        "flowchart LR",
+        '  subgraph lane0["Customer"]',
+        '    n0["Submit order"]',
+        '    n3["Refund"]',
+        "  end",
+        '  subgraph lane1["Shop"]',
+        '    n1{"In stock?"}',
+        '    n2["Pack"]',
+        "  end",
+        '  subgraph lane2["Courier"]',
+        "  end",
+        "  n0 ==> n1",
+        '  n1 -->|"yes"| n2',
+        '  n1 ==>|"no"| n3',
+        "",
+      ].join("\n"),
+    );
+    expect(
+      (await harness.run("show", "--view", "swimlane", "--format", "dot"))
+        .stdout,
+    ).toBe(
+      [
+        'digraph "swimlane" {',
+        '  rankdir="LR";',
+        '  subgraph "cluster_lane0" {',
+        '    label="Customer";',
+        '    "submit" [label="Submit order", shape="box"];',
+        '    "refund" [label="Refund", shape="box"];',
+        "  }",
+        '  subgraph "cluster_lane1" {',
+        '    label="Shop";',
+        '    "stock" [label="In stock?", shape="diamond"];',
+        '    "pack" [label="Pack", shape="box"];',
+        "  }",
+        '  subgraph "cluster_lane2" {',
+        '    label="Courier";',
+        '    "cluster_lane2:empty" [shape="point", style="invis"];',
+        "  }",
+        '  "submit" -> "stock" [style="bold"];',
+        '  "stock" -> "pack" [label="yes"];',
+        '  "stock" -> "refund" [label="no", style="bold"];',
+        "}",
+        "",
+      ].join("\n"),
+    );
+  });
+
+  test("draws the state machine of a subject, with decisions folded into guards", async () => {
+    expect(
+      (await harness.run("show", "--view", "state", "--subject", "order"))
+        .stdout,
+    ).toBe(
+      [
+        "stateDiagram-v2",
+        '  state "Submit order" as s0',
+        '  state "Pack" as s1',
+        '  state "Refund" as s2',
+        "  s0 --> s1 : [yes]",
+        "  s0 --> s2 : [no]",
+        "",
+      ].join("\n"),
+    );
+    expect(
+      (
+        await harness.run(
+          "show",
+          "--view",
+          "state",
+          "--subject",
+          "order",
+          "--format",
+          "dot",
+        )
+      ).stdout,
+    ).toBe(
+      [
+        'digraph "state machine" {',
+        '  rankdir="LR";',
+        '  "submit" [label="Submit order", shape="box", style="rounded"];',
+        '  "pack" [label="Pack", shape="box", style="rounded"];',
+        '  "refund" [label="Refund", shape="box", style="rounded"];',
+        '  "submit" -> "pack" [label="[yes]"];',
+        '  "submit" -> "refund" [label="[no]"];',
+        "}",
+        "",
+      ].join("\n"),
+    );
+  });
+
+  test("draws a sequence diagram along a scenario", async () => {
+    expect(
+      (
+        await harness.run(
+          "show",
+          "--view",
+          "sequence",
+          "--scenario",
+          "t1",
+          "t3",
+        )
+      ).stdout,
+    ).toBe(
+      [
+        "sequenceDiagram",
+        "  participant p0 as Customer",
+        "  participant p1 as Shop",
+        "  p0->>p1: In stock?",
+        "  p1->>p0: Refund",
+        "",
+      ].join("\n"),
+    );
+    expect(
+      (
+        await harness.run(
+          "show",
+          "--view",
+          "sequence",
+          "--scenario",
+          "t1",
+          "t3",
+          "--format",
+          "dot",
+        )
+      ).stdout,
+    ).toBe(
+      [
+        'digraph "sequence" {',
+        '  rankdir="TB";',
+        '  "p0" [label="Customer", shape="box"];',
+        '  "p1" [label="Shop", shape="box"];',
+        '  { rank="same"; "p0"; "p1"; }',
+        '  "p0" -> "p1" [style="invis"];',
+        '  "p0.1" [shape="point", width="0"];',
+        '  "p1.1" [shape="point", width="0"];',
+        '  { rank="same"; "p0.1"; "p1.1"; }',
+        '  "p0.2" [shape="point", width="0"];',
+        '  "p1.2" [shape="point", width="0"];',
+        '  { rank="same"; "p0.2"; "p1.2"; }',
+        '  "p0" -> "p0.1" -> "p0.2" [style="dashed", arrowhead="none"];',
+        '  "p1" -> "p1.1" -> "p1.2" [style="dashed", arrowhead="none"];',
+        '  "p0.1" -> "p1.1" [label="1. In stock?", constraint="false"];',
+        '  "p1.2" -> "p0.2" [label="2. Refund", constraint="false"];',
+        "}",
+        "",
+      ].join("\n"),
+    );
+  });
+
+  test("writes the projection itself as JSON", async () => {
+    const flowchart: unknown = JSON.parse(
+      (await harness.run("show", "--format", "json")).stdout,
+    );
+
+    expect(flowchart).toMatchObject({
+      nodes: [
+        { id: "submit", label: "Submit order", shape: "process" },
+        { id: "stock", label: "In stock?", shape: "decision" },
+        { id: "pack", label: "Pack", shape: "process" },
+        { id: "refund", label: "Refund", shape: "process" },
+      ],
+      edges: [
+        { from: "submit", to: "stock" },
+        { from: "stock", to: "pack", label: "yes" },
+        { from: "stock", to: "refund", label: "no" },
+      ],
+    });
+    expect(JSON.parse((await harness.run("show", "--json")).stdout)).toEqual({
+      view: "flowchart",
+      format: "mermaid",
+      text: (await harness.run("show")).stdout,
+    });
+  });
+
+  test("needs a subject for the state view and a scenario for the sequence view", async () => {
+    expect(await harness.run("show", "--view", "state")).toEqual({
+      code: exitCodes.usage,
+      stdout: "",
+      stderr:
+        "the state view needs --subject <entity>: the model declares no state machine projection\n",
+    });
+    expect(
+      await harness.run("show", "--view", "state", "--subject", "shop"),
+    ).toEqual({
+      code: exitCodes.usage,
+      stdout: "",
+      stderr: '"shop" is a system; a state machine follows an entity\n',
+    });
+    expect(
+      (await harness.run("show", "--view", "state", "--subject", "nobody"))
+        .code,
+    ).toBe(exitCodes.notFound);
+    expect((await harness.run("show", "--view", "sequence")).code).toBe(
+      exitCodes.usage,
+    );
+    expect(
+      await harness.run("show", "--view", "sequence", "--scenario", "t1", "t9"),
+    ).toEqual({
+      code: exitCodes.notFound,
+      stdout: "",
+      stderr: 'no transition "t9" in the model\n',
+    });
+  });
+
+  test("rejects a view outside its choices as a usage error", async () => {
+    expect((await harness.run("show", "--view", "gantt")).code).toBe(
+      exitCodes.usage,
+    );
+  });
+});
+
+describe("cycles and validate", () => {
+  beforeEach(async () => {
+    await runInOrder(harness, [
+      ["add", "activity", "a", "A"],
+      ["add", "activity", "b", "B"],
+      ["add", "transition", "a", "b"],
+      ["add", "transition", "b", "a"],
+    ]);
+  });
+
+  test("cycles lists a cycle no decision closes and exits with the invalid model status", async () => {
+    expect(await harness.run("cycles")).toEqual({
+      code: exitCodes.invalidModel,
+      stdout: "a -> b -> a\n",
+      stderr: "",
+    });
+  });
+
+  test("validate reports the cycle as an issue", async () => {
+    expect(await harness.run("validate")).toEqual({
+      code: exitCodes.invalidModel,
+      stdout: "illegal-cycle\tcycle with no decision in it: a -> b -> a\n",
+      stderr: "",
+    });
+  });
+
+  test("a reasoning command refuses a model with an illegal cycle", async () => {
+    const result = await harness.run("ready");
+
+    expect(result.code).toBe(exitCodes.invalidModel);
+    expect(result.stderr).toBe(
+      "The graph contains a cycle: a -> b -> a; run cycles to list them\n",
+    );
+  });
+});
+
+describe("validate <file>", () => {
+  const write = (name: string, content: string): string => {
+    const path = join(harness.directory, name);
+    writeFileSync(path, content);
+
+    return path;
+  };
+
+  test("finds nothing wrong with a valid model document", async () => {
+    const path = write(
+      "model.json",
+      JSON.stringify({
+        participants: [{ id: "team", label: "Team", kind: "role" }],
+        events: [],
+        actions: [],
+        artefacts: [],
+        elements: [{ kind: "activity", id: "a", label: "A", actor: "team" }],
+        transitions: [],
+        fragments: [],
+        projections: [],
+      }),
+    );
+
+    expect(await harness.run("validate", path)).toEqual({
+      code: exitCodes.success,
+      stdout: "valid\n",
+      stderr: "",
+    });
+  });
+
+  test("locates each shape problem by JSON pointer", async () => {
+    const path = write(
+      "broken.json",
+      JSON.stringify({
+        participants: [{ id: "team", label: "Team", kind: "robot" }],
+        events: [],
+        actions: [],
+        artefacts: [],
+        elements: [],
+        transitions: [],
+        fragments: [],
+        projections: [],
+      }),
+    );
+    const result = await harness.run("validate", path, "--json");
+
+    expect(result.code).toBe(exitCodes.invalidModel);
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      valid: false,
+      issues: [{ code: "schema", pointer: "/participants/0/kind" }],
+    });
+  });
+
+  test("reports a reference to an undeclared element", async () => {
+    const path = write(
+      "dangling.json",
+      JSON.stringify({
+        participants: [],
+        events: [],
+        actions: [],
+        artefacts: [],
+        elements: [{ kind: "activity", id: "a", label: "A" }],
+        transitions: [{ id: "t", source: "a", target: "z" }],
+        fragments: [],
+        projections: [],
+      }),
+    );
+
+    expect(await harness.run("validate", path)).toEqual({
+      code: exitCodes.invalidModel,
+      stdout:
+        'unknown-reference\ttransition "t" target refers to unknown id "z"\n',
+      stderr: "",
+    });
+  });
+
+  test("reports text that is not JSON at the document itself", async () => {
+    const result = await harness.run(
+      "validate",
+      write("text.json", "not json"),
+    );
+
+    expect(result.code).toBe(exitCodes.invalidModel);
+    expect(result.stdout).toMatch(/^schema\t\/\tnot JSON: /u);
+  });
+});
+
+describe("the program", () => {
+  test("prints help with the exit statuses, and exits successfully", async () => {
+    const result = await harness.run("--help");
+
+    expect(result.code).toBe(exitCodes.success);
+    expect(result.stdout).toContain("Usage: process-graph [options] [command]");
+    expect(result.stdout).toContain(
+      "  4  the model has problems: validation issues, an illegal cycle, or a change the store rejected",
+    );
+    expect(result.stdout).not.toMatch(/ -- |—/u);
+  });
+
+  test("prints its version", async () => {
+    expect(await harness.run("--version")).toEqual({
+      code: exitCodes.success,
+      stdout: "0.0.0-test\n",
+      stderr: "",
+    });
+  });
+
+  test("rejects an unknown command as a usage error", async () => {
+    const result = await harness.run("frobnicate");
+
+    expect(result.code).toBe(exitCodes.usage);
+    expect(result.stderr).toContain("error: unknown command 'frobnicate'");
+  });
+
+  test("keeps models apart by --model and files apart by --data", async () => {
+    await harness.run("add", "activity", "a", "A", "--model", "one");
+    const other = join(harness.directory, "other.sqlite3");
+    await harness.run("add", "activity", "b", "B", "--data", other);
+
+    expect((await harness.run("ready", "--model", "one")).stdout).toBe(
+      "a\tA\n",
+    );
+    expect((await harness.run("ready", "--data", other)).stdout).toBe("b\tB\n");
+    expect((await harness.run("ready")).code).toBe(exitCodes.notFound);
+  });
+});
diff --git a/packages/targets/graph-cli/src/cli.unit.test.ts b/packages/targets/graph-cli/src/cli.unit.test.ts
new file mode 100644
index 0000000..4ea74cf
--- /dev/null
+++ b/packages/targets/graph-cli/src/cli.unit.test.ts
@@ -0,0 +1,296 @@
+import {
+  createFakeGraphSource,
+  GraphSourceError,
+  type GraphSourcePager,
+} from "@exadev/process-graph-source-contract";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { exitCodes } from "./exit-codes.ts";
+import { githubLikeSource, issues } from "./test-support/fixtures.ts";
+import { createHarness, type Harness } from "./test-support/harness.ts";
+
+const { design, api, ship, ui } = issues;
+
+let harness: Harness;
+
+beforeEach(() => {
+  harness = createHarness();
+});
+
+afterEach(() => {
+  harness.remove();
+});
+
+const syncFixture = async () =>
+  harness.run("sync", "github:acme/app", "github:acme/web");
+
+describe("sync", () => {
+  test("merges every page of every scope into the model and reports what it wrote", async () => {
+    const result = await harness.run(
+      "sync",
+      "github:acme/app",
+      "github:acme/web",
+      "github:acme/missing",
+    );
+
+    expect(result).toEqual({
+      code: exitCodes.success,
+      stdout:
+        'synced 4 activities, 4 transitions and 4 participants into "default" at revision 1\n' +
+        "gap\tnot-found\tgithub:acme/missing\tgithub:acme/missing does not exist\n",
+      stderr: "",
+    });
+  });
+
+  test("writes JSON with --json", async () => {
+    const result = await harness.run("sync", "github:acme/app", "--json");
+
+    expect(JSON.parse(result.stdout)).toEqual({
+      modelId: "default",
+      revision: 1,
+      participants: 4,
+      activities: 4,
+      transitions: 4,
+      gaps: [],
+    });
+  });
+
+  test("refreshes the model by identifier when synced again", async () => {
+    await syncFixture();
+    const again = await harness.run("sync", "github:acme/web");
+
+    expect(again.stdout).toBe(
+      'synced 1 activities, 0 transitions and 2 participants into "default" at revision 2\n',
+    );
+    expect((await harness.run("ready")).stdout).toBe(`${api}\tBuild the API\n`);
+  });
+
+  test("refuses --after with the scopes of more than one source", async () => {
+    harness.remove();
+    harness = createHarness(
+      createFakeGraphSource(githubLikeSource),
+      createFakeGraphSource({ source: "jira", scopes: { "jira:ACME": [] } }),
+    );
+
+    expect(
+      await harness.run("sync", "github:acme/app", "jira:ACME", "--after", "x"),
+    ).toEqual({
+      code: exitCodes.usage,
+      stdout: "",
+      stderr:
+        "--after resumes one source's sync: give only that source's scopes\n",
+    });
+  });
+
+  test("rejects a scope with no source prefix, and a prefix no source reads, as usage errors", async () => {
+    const bare = await harness.run("sync", "acme/app");
+    const jira = await harness.run("sync", "jira:ACME");
+
+    expect(bare.code).toBe(exitCodes.usage);
+    expect(bare.stderr).toBe(
+      '"acme/app" is not a scope: write <source>:<scope>, such as github:owner/repo\n',
+    );
+    expect(jira.code).toBe(exitCodes.usage);
+    expect(jira.stderr).toBe('no source reads "jira" scopes\n');
+  });
+
+  test("reports a cursor the source did not issue as a source failure", async () => {
+    const result = await harness.run(
+      "sync",
+      "github:acme/app",
+      "--after",
+      "bogus",
+    );
+
+    expect(result.code).toBe(exitCodes.sourceFailure);
+    expect(result.stderr).toBe(
+      '"bogus" is not a cursor for this scope\n' +
+        "resume with: sync github:acme/app --after bogus\n",
+    );
+  });
+
+  test("saves the pages read before a source fails and says how to resume", async () => {
+    const fake = createFakeGraphSource(githubLikeSource);
+    let reads = 0;
+    const failing: GraphSourcePager = {
+      source: fake.source,
+      page: async (request) => {
+        reads += 1;
+        if (reads > 1) {
+          throw new GraphSourceError({
+            kind: "rate-limited",
+            message: "rate limited",
+            resetAt: undefined,
+          });
+        }
+
+        return fake.page(request);
+      },
+    };
+    harness.remove();
+    harness = createHarness(
+      failing,
+      createFakeGraphSource({ source: "jira", scopes: { "jira:ACME": [] } }),
+    );
+
+    const result = await harness.run(
+      "sync",
+      "github:acme/app",
+      "jira:ACME",
+      "github:acme/web",
+    );
+
+    expect(result.code).toBe(exitCodes.sourceFailure);
+    expect(result.stderr).toBe(
+      "rate limited\n" +
+        "the pages read before the failure are saved\n" +
+        "resume with: sync github:acme/app github:acme/web --after github%3Aacme%2Fapp@0\n" +
+        "then: sync jira:ACME\n",
+    );
+    expect((await harness.run("ready")).stdout).toBe(`${api}\tBuild the API\n`);
+  });
+});
+
+describe("reasoning over a synced model", () => {
+  beforeEach(async () => {
+    await syncFixture();
+  });
+
+  test("ready lists the work that can start now", async () => {
+    expect(await harness.run("ready")).toEqual({
+      code: exitCodes.success,
+      stdout: `${api}\tBuild the API\n`,
+      stderr: "",
+    });
+    expect(JSON.parse((await harness.run("ready", "--json")).stdout)).toEqual({
+      elements: [{ id: api, label: "Build the API" }],
+    });
+  });
+
+  test("blocked lists the open work at the end of the blocked-by chain", async () => {
+    expect((await harness.run("blocked", ship)).stdout).toBe(
+      `${api}\tBuild the API\n`,
+    );
+    expect(
+      JSON.parse((await harness.run("blocked", ship, "--json")).stdout),
+    ).toEqual({
+      element: { id: ship, label: "Ship it", status: "blocked" },
+      blockedBy: [{ id: api, label: "Build the API" }],
+    });
+    expect((await harness.run("blocked", api)).stdout).toBe("");
+  });
+
+  test("impact lists the live work that depends on an element, in model order", async () => {
+    expect((await harness.run("impact", api)).stdout).toBe(
+      `${ship}\tShip it\n${ui}\tBuild the UI\n`,
+    );
+    expect((await harness.run("impact", ship)).stdout).toBe("");
+  });
+
+  test("handoffs lists the transitions that cross from one repository to another", async () => {
+    expect((await harness.run("handoffs")).stdout).toBe(
+      `${ui}->${ship}\tgithub:acme/web -> github:acme/app\n` +
+        `${api}->${ui}\tgithub:acme/app -> github:acme/web\n`,
+    );
+  });
+
+  test("path lists the longest chain of work still ahead", async () => {
+    expect((await harness.run("path")).stdout).toBe(
+      `${api}\tBuild the API\n${ui}\tBuild the UI\n${ship}\tShip it\n`,
+    );
+    expect(
+      JSON.parse((await harness.run("path", "--json")).stdout),
+    ).toMatchObject({
+      weight: 3,
+    });
+  });
+
+  test("cycles finds none and succeeds", async () => {
+    expect(await harness.run("cycles")).toEqual({
+      code: exitCodes.success,
+      stdout: "",
+      stderr: "",
+    });
+    expect(JSON.parse((await harness.run("cycles", "--json")).stdout)).toEqual({
+      cycles: [],
+    });
+  });
+
+  test("why explains a blocked element with its needs and blocked-by chain", async () => {
+    expect((await harness.run("why", ship)).stdout).toBe(
+      [
+        `${ship} is blocked: it waits on work that is not done`,
+        "needs:",
+        `  ${api} (ready) through ${api}->${ship}`,
+        `  ${ui} (blocked) through ${ui}->${ship}`,
+        "blocked-by chain:",
+        `  ${ship} (blocked) waits on ${api}, ${ui}`,
+        `  ${api} (ready)`,
+        `  ${ui} (blocked) waits on ${api}`,
+        "",
+      ].join("\n"),
+    );
+  });
+
+  test("why explains a ready and a done element by their rule alone", async () => {
+    expect((await harness.run("why", design)).stdout).toBe(
+      `${design} is done: its run state is done\n`,
+    );
+    expect((await harness.run("why", api)).stdout).toBe(
+      [
+        `${api} is ready: everything it needs is done`,
+        "needs:",
+        `  ${design} (done) through ${design}->${api}`,
+        "",
+      ].join("\n"),
+    );
+  });
+
+  test("set changes an element's run state and the reasoning follows it", async () => {
+    expect((await harness.run("set", api, "done")).stdout).toBe(
+      `set ${api} to done at revision 2\n`,
+    );
+    expect((await harness.run("ready")).stdout).toBe(`${ui}\tBuild the UI\n`);
+  });
+
+  test("validate finds nothing wrong with a synced model", async () => {
+    expect(await harness.run("validate")).toEqual({
+      code: exitCodes.success,
+      stdout: "valid\n",
+      stderr: "",
+    });
+  });
+
+  test.each(["blocked", "impact", "why"])(
+    "%s of an element the model lacks is not found",
+    async (command) => {
+      expect(await harness.run(command, "github:acme/app#99")).toEqual({
+        code: exitCodes.notFound,
+        stdout: "",
+        stderr: 'no element "github:acme/app#99" in the model\n',
+      });
+    },
+  );
+
+  test("set of an element the model lacks is not found", async () => {
+    expect((await harness.run("set", "github:acme/app#99", "done")).code).toBe(
+      exitCodes.notFound,
+    );
+  });
+});
+
+describe("a model that does not exist", () => {
+  test.each([
+    ["ready"],
+    ["path"],
+    ["cycles"],
+    ["handoffs"],
+    ["validate"],
+    ["show"],
+  ])("is not found by %s", async (command) => {
+    expect(await harness.run(command, "--model", "absent")).toEqual({
+      code: exitCodes.notFound,
+      stdout: "",
+      stderr: 'no model "absent" in the store; sync or add something first\n',
+    });
+  });
+});
diff --git a/packages/targets/graph-cli/src/edit.ts b/packages/targets/graph-cli/src/edit.ts
new file mode 100644
index 0000000..836cfc5
--- /dev/null
+++ b/packages/targets/graph-cli/src/edit.ts
@@ -0,0 +1,106 @@
+import type {
+  ArtefactDef,
+  Element,
+  EventDef,
+  Model,
+  OpenIds,
+  OverlayStatus,
+  Participant,
+  Transition,
+} from "@exadev/process-graph-schema";
+import { emptyModel } from "@exadev/process-graph-store-contract";
+import {
+  callOptions,
+  findRun,
+  loadRun,
+  requireElement,
+  type GraphSession,
+} from "./session.ts";
+
+/** A record to add to the model, by the part of the model it belongs to. */
+export type Addition =
+  | { readonly kind: "participant"; readonly record: Participant<string> }
+  | { readonly kind: "element"; readonly record: Element<string, OpenIds> }
+  | { readonly kind: "event"; readonly record: EventDef<string> }
+  | { readonly kind: "artefact"; readonly record: ArtefactDef<string> }
+  | {
+      readonly kind: "transition";
+      readonly record: Transition<string, OpenIds>;
+    };
+
+/** A change the store accepted. */
+export interface Written {
+  /** The revision the change took. */
+  readonly revision: number;
+}
+
+/** The model with one record appended to the part it belongs to. */
+const withAddition = (
+  model: Model<OpenIds>,
+  addition: Addition,
+): Model<OpenIds> => {
+  if (addition.kind === "participant") {
+    return { ...model, participants: [...model.participants, addition.record] };
+  }
+  if (addition.kind === "element") {
+    return { ...model, elements: [...model.elements, addition.record] };
+  }
+  if (addition.kind === "event") {
+    return { ...model, events: [...model.events, addition.record] };
+  }
+  if (addition.kind === "artefact") {
+    return { ...model, artefacts: [...model.artefacts, addition.record] };
+  }
+
+  return { ...model, transitions: [...model.transitions, addition.record] };
+};
+
+/**
+ * Adds a record to the session's model, creating the model when the store has none. The store checks the result, so a duplicate identifier or a reference to something undeclared is rejected and nothing changes.
+ *
+ * The model is read and then saved whole, so a write made by another process between the two is overwritten.
+ * @param session - The store and model.
+ * @param addition - The record to add.
+ * @returns The revision the save took.
+ */
+export const add = async (
+  session: GraphSession,
+  addition: Addition,
+): Promise<Written> => {
+  // A store with no such model yet starts it from the empty model, as a sync does.
+  const model = (await findRun(session))?.model ?? emptyModel;
+
+  return session.store.v1.models.save(
+    { modelId: session.modelId, model: withAddition(model, addition) },
+    callOptions(session.signal),
+  );
+};
+
+/** The run state an element was given. */
+export interface SetResult extends Written {
+  readonly element: string;
+  readonly state: OverlayStatus;
+}
+
+/**
+ * Sets an element's run state, leaving every other element's as it is.
+ * @param session - The store and model.
+ * @param id - The element.
+ * @param state - `done`, `open` or `unknown`.
+ * @returns The element, its new state and the revision the change took.
+ * @throws CliError with `notFound` when the model or the element does not exist.
+ */
+export const setState = async (
+  session: GraphSession,
+  id: string,
+  state: OverlayStatus,
+): Promise<SetResult> => {
+  const { model } = await loadRun(session);
+  requireElement(model, id);
+  const { revision } = await session.store.v1.overlay.set(
+    { modelId: session.modelId, overlay: { [id]: state } },
+    callOptions(session.signal),
+  );
+
+  return { element: id, state, revision };
+};
diff --git a/packages/targets/graph-cli/src/emit/dot.ts b/packages/targets/graph-cli/src/emit/dot.ts
new file mode 100644
index 0000000..b143f72
--- /dev/null
+++ b/packages/targets/graph-cli/src/emit/dot.ts
@@ -0,0 +1,275 @@
+import type {
+  Flowchart,
+  FlowNode,
+  SequenceDiagram,
+  SequenceItem,
+  SequenceMessage,
+  StateMachine,
+  StateMachineState,
+  Swimlane,
+} from "@exadev/process-graph-projection";
+import type { IdSpace } from "@exadev/process-graph-schema";
+import { transitionLabel } from "./mermaid.ts";
+import { dotString } from "./text.ts";
+
+const indent = "  ";
+
+/** DOT attributes as name and value pairs, in the order written. */
+type Attributes = readonly (readonly [string, string])[];
+
+/** A DOT attribute list from name and value pairs, each value quoted; empty when there are none. */
+const attributes = (pairs: Attributes): string =>
+  pairs.length === 0
+    ? ""
+    : ` [${pairs.map(([name, value]) => `${name}=${dotString(value)}`).join(", ")}]`;
+
+/** A flowchart node's DOT shape: an oval terminator, a box process, a diamond decision, and a filled bar for a fork or join. */
+const nodeShapes: Readonly<Record<FlowNode<IdSpace>["shape"], Attributes>> = {
+  terminator: [["shape", "oval"]],
+  process: [["shape", "box"]],
+  decision: [["shape", "diamond"]],
+  bar: [
+    ["shape", "box"],
+    ["style", "filled"],
+    ["fillcolor", "black"],
+    ["fontcolor", "white"],
+  ],
+};
+
+const dotNode = <I extends IdSpace>(node: FlowNode<I>, depth: string): string =>
+  `${depth}${dotString(node.id)}${attributes([["label", node.label], ...nodeShapes[node.shape]])};`;
+
+/** The edges of a flowchart, a hand-off (an edge whose ends are in different lanes) drawn bold. */
+const dotEdges = <I extends IdSpace>(
+  view: Flowchart<I>,
+  isHandoff: (from: I["element"], to: I["element"]) => boolean,
+): readonly string[] =>
+  view.edges.map(
+    (edge) =>
+      `${indent}${dotString(edge.from)} -> ${dotString(edge.to)}${attributes([
+        ...(edge.label === undefined ? [] : [["label", edge.label] as const]),
+        ...(isHandoff(edge.from, edge.to) ? [["style", "bold"] as const] : []),
+      ])};`,
+  );
+
+/**
+ * A flowchart as a Graphviz `digraph`, top to bottom. Nodes are named by their model identifiers, so the DOT source reads back to the model directly.
+ * @param view - The projected flowchart.
+ * @returns DOT source, ending with a line break.
+ */
+export const flowchartToDot = <I extends IdSpace>(view: Flowchart<I>): string =>
+  `${[
+    `digraph ${dotString("flowchart")} {`,
+    `${indent}rankdir="TB";`,
+    ...view.nodes.map((node) => dotNode(node, indent)),
+    ...dotEdges(view, () => false),
+    "}",
+  ].join("\n")}\n`;
+
+/**
+ * A swimlane as a Graphviz `digraph`, left to right, with one `cluster` subgraph per lane in the view's lane order and nodes with no actor outside every lane. An empty lane holds one invisible point so Graphviz still draws it. Hand-offs, the edges that change lane, are drawn bold.
+ * @param view - The projected swimlane.
+ * @returns DOT source, ending with a line break.
+ */
+export const swimlaneToDot = <I extends IdSpace>(view: Swimlane<I>): string => {
+  const nodes = new Map(view.nodes.map((node) => [node.id, node]));
+  const laneOf = new Map<I["element"], number>();
+  view.lanes.forEach((lane, index) => {
+    for (const id of lane.nodes) {
+      laneOf.set(id, index);
+    }
+  });
+  const declare = (id: I["element"], depth: string): string => {
+    const node = nodes.get(id);
+    if (node === undefined) {
+      throw new Error(`lane member "${id}" is not a node of the view`);
+    }
+
+    return dotNode(node, depth);
+  };
+
+  return `${[
+    `digraph ${dotString("swimlane")} {`,
+    `${indent}rankdir="LR";`,
+    ...view.lanes.flatMap((lane, index) => {
+      const cluster = `cluster_lane${String(index)}`;
+
+      return [
+        `${indent}subgraph ${dotString(cluster)} {`,
+        `${indent.repeat(2)}label=${dotString(lane.label)};`,
+        ...(lane.nodes.length === 0
+          ? [
+              `${indent.repeat(2)}${dotString(`${cluster}:empty`)}${attributes([
+                ["shape", "point"],
+                ["style", "invis"],
+              ])};`,
+            ]
+          : lane.nodes.map((id) => declare(id, indent.repeat(2)))),
+        `${indent}}`,
+      ];
+    }),
+    ...view.unassigned.map((id) => declare(id, indent)),
+    ...dotEdges(view, (from, to) => {
+      const fromLane = laneOf.get(from);
+      const toLane = laneOf.get(to);
+
+      return (
+        fromLane !== undefined && toLane !== undefined && fromLane !== toLane
+      );
+    }),
+    "}",
+  ].join("\n")}\n`;
+};
+
+/** A state's DOT shape: a filled point for an initial pseudo-state, a double circle for a final one, a rounded box for a state. */
+const stateShape = <I extends IdSpace>(
+  state: StateMachineState<I>,
+): Attributes => {
+  if (state.role === "initial") {
+    return [
+      ["label", ""],
+      ["shape", "point"],
+    ];
+  }
+  if (state.role === "final") {
+    return [
+      ["label", ""],
+      ["shape", "doublecircle"],
+    ];
+  }
+
+  return [
+    ["label", state.label],
+    ["shape", "box"],
+    ["style", "rounded"],
+  ];
+};
+
+/**
+ * A state machine as a Graphviz `digraph`, left to right. Each transition is labelled with its event, guard and effect.
+ * @param view - The projected state machine.
+ * @returns DOT source, ending with a line break.
+ */
+export const stateMachineToDot = <I extends IdSpace>(
+  view: StateMachine<I>,
+): string =>
+  `${[
+    `digraph ${dotString("state machine")} {`,
+    `${indent}rankdir="LR";`,
+    ...view.states.map(
+      (state) =>
+        `${indent}${dotString(state.id)}${attributes(stateShape(state))};`,
+    ),
+    ...view.transitions.map((transition) => {
+      const label = transitionLabel(transition);
+
+      return `${indent}${dotString(transition.source)} -> ${dotString(transition.target)}${attributes(label === "" ? [] : [["label", label]])};`;
+    }),
+    "}",
+  ].join("\n")}\n`;
+
+/** A message with the fragments around it, outermost first, each as its operator and the guard of the operand it is in. */
+interface PlacedMessage<I extends IdSpace> {
+  readonly message: SequenceMessage<I>;
+  readonly fragments: readonly string[];
+}
+
+const placeMessages = <I extends IdSpace>(
+  items: readonly SequenceItem<I>[],
+  fragments: readonly string[],
+): readonly PlacedMessage<I>[] =>
+  items.flatMap((item) =>
+    item.kind === "message"
+      ? [{ message: item.message, fragments }]
+      : item.operands.flatMap((operand) =>
+          placeMessages(operand.items, [
+            ...fragments,
+            operand.guard === undefined
+              ? item.operator
+              : `${item.operator} [${operand.guard}]`,
+          ]),
+        ),
+  );
+
+/**
+ * A sequence diagram as a Graphviz `digraph`. DOT has no sequence notation, so the diagram is drawn as a grid: a column per lifeline, headed by its participant's label, with one row per message in scenario order. Each message is an arrow across its row, numbered by its step and prefixed with the fragments around it (operator and guard, outermost first), since DOT cannot draw a box around arrows.
+ * @param view - The projected sequence diagram.
+ * @param participantLabel - The label of a lifeline's participant.
+ * @returns DOT source, ending with a line break.
+ */
+export const sequenceToDot = <I extends IdSpace>(
+  view: SequenceDiagram<I>,
+  participantLabel: (participant: I["actor"]) => string,
+): string => {
+  const columns = new Map(
+    view.lifelines.map((lifeline, index) => [lifeline, index]),
+  );
+  const column = (lifeline: I["actor"]): number => {
+    const index = columns.get(lifeline);
+    if (index === undefined) {
+      throw new Error(`"${lifeline}" is not a lifeline of the view`);
+    }
+
+    return index;
+  };
+  const head = (index: number): string => dotString(`p${String(index)}`);
+  const cell = (index: number, row: number): string =>
+    dotString(`p${String(index)}.${String(row)}`);
+  const placed = placeMessages(view.items, []);
+  const rows = placed.map((_, row) => row + 1);
+  const pointAttributes = attributes([
+    ["shape", "point"],
+    ["width", "0"],
+  ]);
+
+  return `${[
+    `digraph ${dotString("sequence")} {`,
+    `${indent}rankdir="TB";`,
+    ...view.lifelines.map(
+      (lifeline, index) =>
+        `${indent}${head(index)}${attributes([
+          ["label", participantLabel(lifeline)],
+          ["shape", "box"],
+        ])};`,
+    ),
+    `${indent}{ rank="same"; ${view.lifelines.map((_, index) => `${head(index)};`).join(" ")} }`,
+    ...view.lifelines
+      .slice(1)
+      .map(
+        (_, index) =>
+          `${indent}${head(index)} -> ${head(index + 1)}${attributes([["style", "invis"]])};`,
+      ),
+    ...rows.flatMap((row) => [
+      ...view.lifelines.map(
+        (_, index) => `${indent}${cell(index, row)}${pointAttributes};`,
+      ),
+      `${indent}{ rank="same"; ${view.lifelines.map((_, index) => `${cell(index, row)};`).join(" ")} }`,
+    ]),
+    ...(rows.length === 0
+      ? []
+      : view.lifelines.map(
+          (_, index) =>
+            `${indent}${[head(index), ...rows.map((row) => cell(index, row))].join(" -> ")}${attributes(
+              [
+                ["style", "dashed"],
+                ["arrowhead", "none"],
+              ],
+            )};`,
+        )),
+    ...placed.map(({ message, fragments }, index) => {
+      const row = index + 1;
+      const text =
+        fragments.length === 0
+          ? message.label
+          : `${fragments.join(" / ")}: ${message.label}`;
+
+      return `${indent}${cell(column(message.from), row)} -> ${cell(column(message.to), row)}${attributes(
+        [
+          ["label", `${String(row)}. ${text}`],
+          ["constraint", "false"],
+        ],
+      )};`;
+    }),
+    "}",
+  ].join("\n")}\n`;
+};
diff --git a/packages/targets/graph-cli/src/emit/emit.unit.test.ts b/packages/targets/graph-cli/src/emit/emit.unit.test.ts
new file mode 100644
index 0000000..d0d4406
--- /dev/null
+++ b/packages/targets/graph-cli/src/emit/emit.unit.test.ts
@@ -0,0 +1,279 @@
+import type {
+  Flowchart,
+  SequenceDiagram,
+  StateMachine,
+} from "@exadev/process-graph-projection";
+import type { OpenIds } from "@exadev/process-graph-schema";
+import { describe, expect, test } from "vitest";
+import { flowchartToDot, sequenceToDot, stateMachineToDot } from "./dot.ts";
+import {
+  flowchartToMermaid,
+  sequenceToMermaid,
+  stateMachineToMermaid,
+} from "./mermaid.ts";
+import { dotString, mermaidText } from "./text.ts";
+
+const lines = (...rows: readonly string[]): string => `${rows.join("\n")}\n`;
+
+describe("text", () => {
+  test("writes every character Mermaid reads as syntax as its entity code, and a line break as a space", () => {
+    expect(mermaidText('Fix "a|b" <now> & #3; then: go\nnext')).toBe(
+      "Fix #quot;a#124;b#quot; #lt;now#gt; #amp; #35;3#59; then#58; go next",
+    );
+  });
+
+  test("quotes a DOT string with backslashes, quotes and line breaks escaped", () => {
+    expect(dotString('a "b" \\ c\nd')).toBe('"a \\"b\\" \\\\ c\\nd"');
+  });
+});
+
+/** A flowchart with every node shape and an issue-style identifier. */
+const flowchart: Flowchart<OpenIds> = {
+  nodes: [
+    { id: "start", label: "Start", shape: "terminator" },
+    { id: "github:acme/app#1", label: 'Fix "login"', shape: "process" },
+    { id: "fork", label: "Fork", shape: "bar" },
+    { id: "ok", label: "OK?", shape: "decision" },
+  ],
+  edges: [
+    { from: "start", to: "github:acme/app#1" },
+    { from: "github:acme/app#1", to: "fork" },
+    { from: "fork", to: "ok", label: "a|b" },
+  ],
+  loss: [],
+};
+
+describe("flowchart", () => {
+  test("Mermaid names nodes by position and draws each shape", () => {
+    expect(flowchartToMermaid(flowchart)).toBe(
+      lines(
+        "flowchart TD",
+        '  n0(["Start"])',
+        '  n1["Fix #quot;login#quot;"]',
+        '  n2@{ shape: fork, label: "Fork" }',
+        '  n3{"OK?"}',
+        "  n0 --> n1",
+        "  n1 --> n2",
+        '  n2 -->|"a#124;b"| n3',
+      ),
+    );
+  });
+
+  test("DOT names nodes by their model identifiers and draws each shape", () => {
+    expect(flowchartToDot(flowchart)).toBe(
+      lines(
+        'digraph "flowchart" {',
+        '  rankdir="TB";',
+        '  "start" [label="Start", shape="oval"];',
+        '  "github:acme/app#1" [label="Fix \\"login\\"", shape="box"];',
+        '  "fork" [label="Fork", shape="box", style="filled", fillcolor="black", fontcolor="white"];',
+        '  "ok" [label="OK?", shape="diamond"];',
+        '  "start" -> "github:acme/app#1";',
+        '  "github:acme/app#1" -> "fork";',
+        '  "fork" -> "ok" [label="a|b"];',
+        "}",
+      ),
+    );
+  });
+});
+
+const stateMachine: StateMachine<OpenIds> = {
+  subject: "order",
+  states: [
+    { id: "begin", label: "Start", role: "initial" },
+    { id: "placed", label: "Placed", role: "state" },
+    { id: "paid", label: "Paid", role: "state" },
+    { id: "end", label: "End", role: "final" },
+  ],
+  transitions: [
+    { source: "begin", target: "placed" },
+    {
+      source: "placed",
+      target: "paid",
+      event: "pay",
+      guard: "card ok",
+      effect: "receipt",
+    },
+    { source: "paid", target: "end", effect: "archive" },
+  ],
+  loss: [],
+};
+
+describe("state machine", () => {
+  test("Mermaid draws initial and final pseudo-states as [*] and labels transitions with event, guard and effect", () => {
+    expect(stateMachineToMermaid(stateMachine)).toBe(
+      lines(
+        "stateDiagram-v2",
+        '  state "Placed" as s0',
+        '  state "Paid" as s1',
+        "  [*] --> s0",
+        "  s0 --> s1 : pay [card ok] / receipt",
+        "  s1 --> [*] : / archive",
+      ),
+    );
+  });
+
+  test("DOT draws an initial point, a final double circle and rounded states", () => {
+    expect(stateMachineToDot(stateMachine)).toBe(
+      lines(
+        'digraph "state machine" {',
+        '  rankdir="LR";',
+        '  "begin" [label="", shape="point"];',
+        '  "placed" [label="Placed", shape="box", style="rounded"];',
+        '  "paid" [label="Paid", shape="box", style="rounded"];',
+        '  "end" [label="", shape="doublecircle"];',
+        '  "begin" -> "placed";',
+        '  "placed" -> "paid" [label="pay [card ok] / receipt"];',
+        '  "paid" -> "end" [label="/ archive"];',
+        "}",
+      ),
+    );
+  });
+});
+
+const message = (transition: string, from: string, to: string, label: string) =>
+  ({ transition, from, to, label }) as const;
+
+/** A review loop holding an alternative: approved and published, or rejected; then a parallel notification. */
+const sequence: SequenceDiagram<OpenIds> = {
+  lifelines: ["author", "reviewer", "bot"],
+  messages: [
+    message("t1", "author", "reviewer", "Submit"),
+    message("t2", "reviewer", "author", "Approve"),
+    message("t3", "author", "bot", "Notify"),
+  ],
+  items: [
+    {
+      kind: "fragment",
+      fragment: "review",
+      operator: "loop",
+      operands: [
+        {
+          guard: "until approved",
+          items: [
+            {
+              kind: "message",
+              message: message("t1", "author", "reviewer", "Submit"),
+            },
+            {
+              kind: "fragment",
+              fragment: "verdict",
+              operator: "alt",
+              operands: [
+                {
+                  guard: "approved",
+                  items: [
+                    {
+                      kind: "message",
+                      message: message("t2", "reviewer", "author", "Approve"),
+                    },
+                  ],
+                },
+                { items: [] },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+    {
+      kind: "fragment",
+      fragment: "tell",
+      operator: "par",
+      operands: [
+        {
+          items: [
+            {
+              kind: "message",
+              message: message("t3", "author", "bot", "Notify"),
+            },
+          ],
+        },
+        { guard: "later", items: [] },
+      ],
+    },
+  ],
+  loss: [],
+};
+
+const labels: Readonly<Record<string, string>> = {
+  author: "Author",
+  reviewer: "Reviewer: lead",
+  bot: "Bot",
+};
+const labelOf = (id: string): string => labels[id] ?? id;
+
+describe("sequence diagram", () => {
+  test("Mermaid nests fragments, separating alt operands with else and par operands with and", () => {
+    expect(sequenceToMermaid(sequence, labelOf)).toBe(
+      lines(
+        "sequenceDiagram",
+        "  participant p0 as Author",
+        "  participant p1 as Reviewer#58; lead",
+        "  participant p2 as Bot",
+        "  loop until approved",
+        "    p0->>p1: Submit",
+        "    alt approved",
+        "      p1->>p0: Approve",
+        "    else",
+        "    end",
+        "  end",
+        "  par",
+        "    p0->>p2: Notify",
+        "  and later",
+        "  end",
+      ),
+    );
+  });
+
+  test("DOT draws a lifeline grid and prefixes each message with the fragments around it", () => {
+    expect(sequenceToDot(sequence, labelOf)).toBe(
+      lines(
+        'digraph "sequence" {',
+        '  rankdir="TB";',
+        '  "p0" [label="Author", shape="box"];',
+        '  "p1" [label="Reviewer: lead", shape="box"];',
+        '  "p2" [label="Bot", shape="box"];',
+        '  { rank="same"; "p0"; "p1"; "p2"; }',
+        '  "p0" -> "p1" [style="invis"];',
+        '  "p1" -> "p2" [style="invis"];',
+        '  "p0.1" [shape="point", width="0"];',
+        '  "p1.1" [shape="point", width="0"];',
+        '  "p2.1" [shape="point", width="0"];',
+        '  { rank="same"; "p0.1"; "p1.1"; "p2.1"; }',
+        '  "p0.2" [shape="point", width="0"];',
+        '  "p1.2" [shape="point", width="0"];',
+        '  "p2.2" [shape="point", width="0"];',
+        '  { rank="same"; "p0.2"; "p1.2"; "p2.2"; }',
+        '  "p0.3" [shape="point", width="0"];',
+        '  "p1.3" [shape="point", width="0"];',
+        '  "p2.3" [shape="point", width="0"];',
+        '  { rank="same"; "p0.3"; "p1.3"; "p2.3"; }',
+        '  "p0" -> "p0.1" -> "p0.2" -> "p0.3" [style="dashed", arrowhead="none"];',
+        '  "p1" -> "p1.1" -> "p1.2" -> "p1.3" [style="dashed", arrowhead="none"];',
+        '  "p2" -> "p2.1" -> "p2.2" -> "p2.3" [style="dashed", arrowhead="none"];',
+        '  "p0.1" -> "p1.1" [label="1. loop [until approved]: Submit", constraint="false"];',
+        '  "p1.2" -> "p0.2" [label="2. loop [until approved] / alt [approved]: Approve", constraint="false"];',
+        '  "p0.3" -> "p2.3" [label="3. par: Notify", constraint="false"];',
+        "}",
+      ),
+    );
+  });
+
+  test("an empty scenario draws the lifelines alone", () => {
+    expect(
+      sequenceToDot(
+        { lifelines: ["author"], messages: [], items: [], loss: [] },
+        labelOf,
+      ),
+    ).toBe(
+      lines(
+        'digraph "sequence" {',
+        '  rankdir="TB";',
+        '  "p0" [label="Author", shape="box"];',
+        '  { rank="same"; "p0"; }',
+        "}",
+      ),
+    );
+  });
+});
diff --git a/packages/targets/graph-cli/src/emit/mermaid.ts b/packages/targets/graph-cli/src/emit/mermaid.ts
new file mode 100644
index 0000000..94450c2
--- /dev/null
+++ b/packages/targets/graph-cli/src/emit/mermaid.ts
@@ -0,0 +1,233 @@
+import type {
+  Flowchart,
+  FlowNode,
+  SequenceDiagram,
+  SequenceItem,
+  StateMachine,
+  StateMachineTransition,
+  Swimlane,
+} from "@exadev/process-graph-projection";
+import type { IdSpace } from "@exadev/process-graph-schema";
+import { mermaidText } from "./text.ts";
+
+/**
+ * Model identifiers are free text (`github:org/repo#12`), which Mermaid does not accept as a node identifier, so every emitter names things by position in the view instead: a prefix and the index. The view's order is the model's order, so the same model always gives the same names.
+ */
+const positionalIds = <Id extends string>(
+  prefix: string,
+  ids: readonly Id[],
+): ReadonlyMap<Id, string> =>
+  new Map(ids.map((id, index) => [id, `${prefix}${String(index)}`]));
+
+/** Reads a name the emitter itself assigned, which exists for every identifier the view lists. */
+const nameIn = <Id extends string>(
+  names: ReadonlyMap<Id, string>,
+  id: Id,
+): string => {
+  const name = names.get(id);
+  if (name === undefined) {
+    throw new Error(`"${id}" is not part of the view being emitted`);
+  }
+
+  return name;
+};
+
+const indent = "  ";
+
+/** Each flowchart shape in Mermaid's syntax around a node name and quoted label: a stadium for a terminator, a rectangle for a process, a rhombus for a decision and a fork bar for a fork or join. */
+const mermaidShapes: Readonly<
+  Record<FlowNode<IdSpace>["shape"], (name: string, label: string) => string>
+> = {
+  terminator: (name, label) => `${name}(["${label}"])`,
+  process: (name, label) => `${name}["${label}"]`,
+  decision: (name, label) => `${name}{"${label}"}`,
+  bar: (name, label) => `${name}@{ shape: fork, label: "${label}" }`,
+};
+
+const mermaidNode = <I extends IdSpace>(
+  name: string,
+  node: FlowNode<I>,
+): string => mermaidShapes[node.shape](name, mermaidText(node.label));
+
+/** The edges of a flowchart, a hand-off (an edge whose ends are in different lanes) drawn thick. */
+const mermaidEdges = <I extends IdSpace>(
+  view: Flowchart<I>,
+  names: ReadonlyMap<I["element"], string>,
+  isHandoff: (from: I["element"], to: I["element"]) => boolean,
+): readonly string[] =>
+  view.edges.map((edge) => {
+    const arrow = isHandoff(edge.from, edge.to) ? "==>" : "-->";
+    const label =
+      edge.label === undefined ? "" : `|"${mermaidText(edge.label)}"|`;
+
+    return `${indent}${nameIn(names, edge.from)} ${arrow}${label} ${nameIn(names, edge.to)}`;
+  });
+
+/**
+ * A flowchart as a Mermaid `flowchart`, top to bottom. Nodes are declared in the view's order, then edges, each with its guard as the edge label.
+ * @param view - The projected flowchart.
+ * @returns Mermaid source, ending with a line break.
+ */
+export const flowchartToMermaid = <I extends IdSpace>(
+  view: Flowchart<I>,
+): string => {
+  const names = positionalIds(
+    "n",
+    view.nodes.map((node) => node.id),
+  );
+
+  return `${[
+    "flowchart TD",
+    ...view.nodes.map(
+      (node) => `${indent}${mermaidNode(nameIn(names, node.id), node)}`,
+    ),
+    ...mermaidEdges(view, names, () => false),
+  ].join("\n")}\n`;
+};
+
+/**
+ * A swimlane as a Mermaid `flowchart`, left to right, with one subgraph per lane in the view's lane order (an empty lane is an empty subgraph, so it stays visible) and nodes with no actor outside every lane. Hand-offs, the edges that change lane, are drawn thick.
+ * @param view - The projected swimlane.
+ * @returns Mermaid source, ending with a line break.
+ */
+export const swimlaneToMermaid = <I extends IdSpace>(
+  view: Swimlane<I>,
+): string => {
+  const names = positionalIds(
+    "n",
+    view.nodes.map((node) => node.id),
+  );
+  const nodes = new Map(view.nodes.map((node) => [node.id, node]));
+  const laneOf = new Map<I["element"], number>();
+  view.lanes.forEach((lane, index) => {
+    for (const id of lane.nodes) {
+      laneOf.set(id, index);
+    }
+  });
+  const declare = (id: I["element"], depth: string): string => {
+    const node = nodes.get(id);
+    if (node === undefined) {
+      throw new Error(`lane member "${id}" is not a node of the view`);
+    }
+
+    return `${depth}${mermaidNode(nameIn(names, id), node)}`;
+  };
+
+  return `${[
+    "flowchart LR",
+    ...view.lanes.flatMap((lane, index) => [
+      `${indent}subgraph lane${String(index)}["${mermaidText(lane.label)}"]`,
+      ...lane.nodes.map((id) => declare(id, indent.repeat(2))),
+      `${indent}end`,
+    ]),
+    ...view.unassigned.map((id) => declare(id, indent)),
+    ...mermaidEdges(view, names, (from, to) => {
+      const fromLane = laneOf.get(from);
+      const toLane = laneOf.get(to);
+
+      return (
+        fromLane !== undefined && toLane !== undefined && fromLane !== toLane
+      );
+    }),
+  ].join("\n")}\n`;
+};
+
+/** A state machine transition's label: its event, its guard in brackets and its effect after a slash, each only when present. */
+export const transitionLabel = <I extends IdSpace>(
+  transition: StateMachineTransition<I>,
+): string =>
+  [
+    transition.event,
+    transition.guard === undefined ? undefined : `[${transition.guard}]`,
+    transition.effect === undefined ? undefined : `/ ${transition.effect}`,
+  ]
+    .filter((part) => part !== undefined)
+    .join(" ");
+
+/**
+ * A state machine as a Mermaid `stateDiagram-v2`. Initial and final pseudo-states are Mermaid's `[*]`; every other state is declared with its label. Each transition carries its event, guard and effect.
+ * @param view - The projected state machine.
+ * @returns Mermaid source, ending with a line break.
+ */
+export const stateMachineToMermaid = <I extends IdSpace>(
+  view: StateMachine<I>,
+): string => {
+  const drawn = view.states.filter((state) => state.role === "state");
+  const names = new Map<I["element"], string>([
+    ...positionalIds(
+      "s",
+      drawn.map((state) => state.id),
+    ),
+    ...view.states
+      .filter((state) => state.role !== "state")
+      .map((state): [I["element"], string] => [state.id, "[*]"]),
+  ]);
+
+  return `${[
+    "stateDiagram-v2",
+    ...drawn.map(
+      (state) =>
+        `${indent}state "${mermaidText(state.label)}" as ${nameIn(names, state.id)}`,
+    ),
+    ...view.transitions.map((transition) => {
+      const label = transitionLabel(transition);
+
+      return `${indent}${nameIn(names, transition.source)} --> ${nameIn(names, transition.target)}${label === "" ? "" : ` : ${mermaidText(label)}`}`;
+    }),
+  ].join("\n")}\n`;
+};
+
+/** The Mermaid keyword that separates one operand of a fragment from the next, for the operators with more than one operand. */
+const operandSeparator = (operator: string): string =>
+  operator === "par" ? "and" : "else";
+
+/**
+ * A sequence diagram as a Mermaid `sequenceDiagram`. Lifelines are declared in order of first appearance, labelled through `participantLabel`; messages follow in scenario order, wrapped in the fragments the projection drew (`alt` operands separated by `else`, `par` operands by `and`), each operand headed by its guard.
+ * @param view - The projected sequence diagram.
+ * @param participantLabel - The label of a lifeline's participant.
+ * @returns Mermaid source, ending with a line break.
+ */
+export const sequenceToMermaid = <I extends IdSpace>(
+  view: SequenceDiagram<I>,
+  participantLabel: (participant: I["actor"]) => string,
+): string => {
+  const names = positionalIds("p", view.lifelines);
+  const items = (
+    list: readonly SequenceItem<I>[],
+    depth: number,
+  ): readonly string[] =>
+    list.flatMap((item) => {
+      const prefix = indent.repeat(depth);
+      if (item.kind === "message") {
+        const { message } = item;
+
+        return [
+          `${prefix}${nameIn(names, message.from)}->>${nameIn(names, message.to)}: ${mermaidText(message.label)}`,
+        ];
+      }
+
+      return [
+        ...item.operands.flatMap((operand, index) => {
+          const keyword =
+            index === 0 ? item.operator : operandSeparator(item.operator);
+          const guard =
+            operand.guard === undefined ? "" : ` ${mermaidText(operand.guard)}`;
+
+          return [
+            `${prefix}${keyword}${guard}`,
+            ...items(operand.items, depth + 1),
+          ];
+        }),
+        `${prefix}end`,
+      ];
+    });
+
+  return `${[
+    "sequenceDiagram",
+    ...view.lifelines.map(
+      (lifeline) =>
+        `${indent}participant ${nameIn(names, lifeline)} as ${mermaidText(participantLabel(lifeline))}`,
+    ),
+    ...items(view.items, 1),
+  ].join("\n")}\n`;
+};
diff --git a/packages/targets/graph-cli/src/emit/text.ts b/packages/targets/graph-cli/src/emit/text.ts
new file mode 100644
index 0000000..4482750
--- /dev/null
+++ b/packages/targets/graph-cli/src/emit/text.ts
@@ -0,0 +1,47 @@
+/**
+ * The Mermaid entity code for a character that would end or change the meaning of a label: quotes, statement and edge-label delimiters, the entity marker itself and HTML. A line break becomes a space, since every label is one line.
+ */
+const mermaidEntity = (character: string): string => {
+  switch (character) {
+    case "#":
+      return "#35;";
+    case '"':
+      return "#quot;";
+    case "<":
+      return "#lt;";
+    case ">":
+      return "#gt;";
+    case "&":
+      return "#amp;";
+    case ";":
+      return "#59;";
+    case "|":
+      return "#124;";
+    case ":":
+      return "#58;";
+    case "\r":
+    case "\n":
+      return " ";
+    default:
+      return character;
+  }
+};
+
+/**
+ * Text made safe to place inside any Mermaid label: every character that Mermaid reads as syntax is written as its entity code, so a label from a source (an issue title, a repository name) can never break the diagram.
+ * @param text - The label as written.
+ * @returns The label as Mermaid source.
+ */
+export const mermaidText = (text: string): string =>
+  text.replaceAll(/[#"<>&;|:\r\n]/gu, mermaidEntity);
+
+/**
+ * A Graphviz DOT double-quoted string: backslashes and quotes escaped, line breaks written as DOT's own centred line break. Any identifier or label is valid DOT once quoted this way.
+ * @param text - The text as written.
+ * @returns The quoted DOT string, quotes included.
+ */
+export const dotString = (text: string): string =>
+  `"${text
+    .replaceAll("\\", "\\\\")
+    .replaceAll('"', '\\"')
+    .replaceAll(/\r?\n/gu, "\\n")}"`;
diff --git a/packages/targets/graph-cli/src/errors.ts b/packages/targets/graph-cli/src/errors.ts
new file mode 100644
index 0000000..4b77684
--- /dev/null
+++ b/packages/targets/graph-cli/src/errors.ts
@@ -0,0 +1,116 @@
+import { CycleError, UnknownNodeError } from "@exadev/process-graph-dag";
+import { ModelParseError } from "@exadev/process-graph-schema";
+import { ORPCError } from "@orpc/server";
+import { CommanderError } from "commander";
+import { exitCodes, type ExitCode } from "./exit-codes.ts";
+
+/** A failure the command line reports with its own exit status and message, and nothing else. */
+export class CliError extends Error {
+  /** The exit status the failure maps to. */
+  readonly exitCode: ExitCode;
+
+  /**
+   * @param exitCode - The exit status to report.
+   * @param message - What went wrong, as one line for standard error.
+   * @param options - The underlying error, kept as the cause.
+   */
+  constructor(exitCode: ExitCode, message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+}
+
+/** The store's codes for a missing model or element and for a change that would leave the model invalid. */
+const notFoundCode = "NOT_FOUND";
+const unprocessableCode = "UNPROCESSABLE_CONTENT";
+
+/** The codes a source answers with when it refuses a sync. */
+const sourceRefusalCodes: ReadonlySet<string> = new Set([
+  "UNAUTHORIZED",
+  "TOO_MANY_REQUESTS",
+  "BAD_REQUEST",
+]);
+
+/** The issues an `UNPROCESSABLE_CONTENT` error carries, each as `code: message`, or nothing when its data has no issues. */
+const issueLines = (data: unknown): readonly string[] => {
+  if (
+    typeof data !== "object" ||
+    data === null ||
+    !("issues" in data) ||
+    !Array.isArray(data.issues)
+  ) {
+    return [];
+  }
+  const issues: readonly unknown[] = data.issues;
+
+  return issues.flatMap((issue) =>
+    typeof issue === "object" &&
+    issue !== null &&
+    "code" in issue &&
+    "message" in issue &&
+    typeof issue.code === "string" &&
+    typeof issue.message === "string"
+      ? [`${issue.code}: ${issue.message}`]
+      : [],
+  );
+};
+
+/** The exit status and message an error is reported with. */
+export interface Failure {
+  readonly exitCode: ExitCode;
+  readonly message: string;
+}
+
+/**
+ * Classifies anything a command threw into its exit status and the message for standard error. A commander usage error has already printed its own message, so it is reported with an empty one.
+ * @param error - What was thrown.
+ * @returns The exit status and message.
+ */
+export const failureOf = (error: unknown): Failure => {
+  if (error instanceof CliError) {
+    return { exitCode: error.exitCode, message: error.message };
+  }
+  if (error instanceof CommanderError) {
+    return {
+      exitCode:
+        error.exitCode === exitCodes.success
+          ? exitCodes.success
+          : exitCodes.usage,
+      message: "",
+    };
+  }
+  if (error instanceof CycleError) {
+    return {
+      exitCode: exitCodes.invalidModel,
+      message: `${error.message}; run cycles to list them`,
+    };
+  }
+  if (error instanceof UnknownNodeError) {
+    return { exitCode: exitCodes.notFound, message: error.message };
+  }
+  if (error instanceof ModelParseError) {
+    return { exitCode: exitCodes.invalidModel, message: error.message };
+  }
+  if (error instanceof ORPCError) {
+    const code: unknown = error.code;
+    const data: unknown = error.data;
+    if (code === notFoundCode) {
+      return { exitCode: exitCodes.notFound, message: error.message };
+    }
+    if (code === unprocessableCode) {
+      return {
+        exitCode: exitCodes.invalidModel,
+        message: [error.message, ...issueLines(data)].join("\n"),
+      };
+    }
+    if (typeof code === "string" && sourceRefusalCodes.has(code)) {
+      return { exitCode: exitCodes.sourceFailure, message: error.message };
+    }
+  }
+
+  return {
+    exitCode: exitCodes.failure,
+    message: error instanceof Error ? error.message : String(error),
+  };
+};
diff --git a/packages/targets/graph-cli/src/exit-codes.ts b/packages/targets/graph-cli/src/exit-codes.ts
new file mode 100644
index 0000000..9728210
--- /dev/null
+++ b/packages/targets/graph-cli/src/exit-codes.ts
@@ -0,0 +1,21 @@
+/**
+ * The exit status of every command, by meaning. A script tells the outcomes apart without reading the output: a model with problems is not a failure to run, and neither is an element that does not exist.
+ *
+ * - `success`: the command did what it was asked, and for `validate` and `cycles`, found nothing wrong.
+ * - `failure`: anything not listed below, such as a store that cannot be opened.
+ * - `usage`: the command line is wrong: an unknown command or option, a missing argument, a value outside its choices.
+ * - `notFound`: the model, an element or another identifier named on the command line does not exist.
+ * - `invalidModel`: the model has problems: `validate` found issues, `cycles` found an illegal cycle, a reasoning command met an illegal cycle, or the store rejected a change that would leave the model invalid.
+ * - `sourceFailure`: a source refused the sync: bad credentials, a rate limit or a scope it does not accept.
+ */
+export const exitCodes = {
+  success: 0,
+  failure: 1,
+  usage: 2,
+  notFound: 3,
+  invalidModel: 4,
+  sourceFailure: 5,
+} as const;
+
+/** One of the exit statuses in `exitCodes`. */
+export type ExitCode = (typeof exitCodes)[keyof typeof exitCodes];
diff --git a/packages/targets/graph-cli/src/index.ts b/packages/targets/graph-cli/src/index.ts
new file mode 100644
index 0000000..05a275d
--- /dev/null
+++ b/packages/targets/graph-cli/src/index.ts
@@ -0,0 +1,82 @@
+/**
+ * The process-graph command line as a library. `runCli` runs the whole command surface against injected ports and resolves with the exit status, so a host program (Switchboard's `sb graph`) mounts it as a subcommand; the operations behind each command (`ready`, `blocked`, `why` and the rest) return plain data for hosts that want results rather than text, such as tools served over MCP; and the Mermaid and DOT emitters draw any projected view. `nodePorts` wires the ports for a Node process: the SQLite store, the GitHub issues source with a token from the environment, and the process's streams.
+ */
+export { runCli, defaultModelId, type ProgramIdentity } from "./program.ts";
+export { exitCodes, type ExitCode } from "./exit-codes.ts";
+export { CliError, failureOf, type Failure } from "./errors.ts";
+export type { CliPorts, OpenedStore } from "./ports.ts";
+export {
+  defaultDataPath,
+  nodePorts,
+  packageVersion,
+  runProcess,
+  type NodePortsOptions,
+} from "./node.ts";
+export {
+  findRun,
+  loadRun,
+  type ElementSummary,
+  type GraphSession,
+  type StoredRun,
+} from "./session.ts";
+export {
+  blocked,
+  cycles,
+  handoffsOf,
+  impactOf,
+  path,
+  ready,
+  why,
+  type BlockedResult,
+  type CyclesResult,
+  type ElementStatus,
+  type HandoffsResult,
+  type ImpactResult,
+  type PathResult,
+  type ReadyResult,
+  type WhyLink,
+  type WhyResult,
+} from "./queries.ts";
+export {
+  emit,
+  formatNames,
+  project,
+  show,
+  viewNames,
+  type FormatName,
+  type ProjectedView,
+  type ShowRequest,
+  type ShowResult,
+  type ViewName,
+} from "./show.ts";
+export {
+  add,
+  setState,
+  type Addition,
+  type SetResult,
+  type Written,
+} from "./edit.ts";
+export {
+  validateDocument,
+  validateStored,
+  type ValidateResult,
+  type ValidationIssue,
+} from "./validate.ts";
+export {
+  sync,
+  type SourceLookup,
+  type SyncRequest,
+  type SyncResult,
+} from "./sync.ts";
+export {
+  flowchartToMermaid,
+  sequenceToMermaid,
+  stateMachineToMermaid,
+  swimlaneToMermaid,
+} from "./emit/mermaid.ts";
+export {
+  flowchartToDot,
+  sequenceToDot,
+  stateMachineToDot,
+  swimlaneToDot,
+} from "./emit/dot.ts";
diff --git a/packages/targets/graph-cli/src/node.ts b/packages/targets/graph-cli/src/node.ts
new file mode 100644
index 0000000..ce3fa4b
--- /dev/null
+++ b/packages/targets/graph-cli/src/node.ts
@@ -0,0 +1,173 @@
+import { mkdirSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import type { Facts } from "@exadev/process-graph-domain";
+import { createGraphSourceRouter } from "@exadev/process-graph-source-contract";
+import {
+  createGitHubIssuesSource,
+  githubSource,
+  type GitHubTokenPort,
+  type GraphqlFetch,
+} from "@exadev/process-graph-source-github-issues";
+import { githubTokenFromEnvironment } from "@exadev/process-graph-source-github-issues/node";
+import { openNodeGraphStore } from "@exadev/process-graph-sqlite-node";
+import { createGraphStoreRouter } from "@exadev/process-graph-store-contract";
+import { createRouterClient } from "@orpc/server";
+import type { CliPorts } from "./ports.ts";
+import type { ExitCode } from "./exit-codes.ts";
+import { runCli, type ProgramIdentity } from "./program.ts";
+
+/** Where a Node process finds its ports. Each is injectable, and each defaults to the real thing. */
+export interface NodePortsOptions {
+  /** The environment, for the data path and the GitHub token; `process.env` when absent. */
+  readonly env?: Readonly<Record<string, string | undefined>>;
+  /** The home directory the default data path falls back on; the user's when absent. */
+  readonly home?: string;
+  /** Supplies GitHub tokens; `GITHUB_TOKEN` or the GitHub CLI's token (`githubTokenFromEnvironment`) when absent. */
+  readonly token?: GitHubTokenPort;
+  /** How requests reach GitHub; the global `fetch` when absent. */
+  readonly fetch?: GraphqlFetch;
+  /** The clock, in milliseconds since the epoch, for a rate limit's retry time; `Date.now` when absent. */
+  readonly now?: () => number;
+  /** The facts decision conditions read and which input artefacts are provided; nothing is known when absent. */
+  readonly facts?: Facts;
+  /** Aborts every store and source call. */
+  readonly signal?: AbortSignal;
+  /** Standard output; the process's when absent. */
+  readonly stdout?: (text: string) => void;
+  /** Standard error; the process's when absent. */
+  readonly stderr?: (text: string) => void;
+}
+
+/** The variable that names the data file outright. */
+const dataVariable = "PROCESS_GRAPH_DATA";
+
+/** The data file's path under the data directory. */
+const dataFile = join("process-graph", "graph.sqlite3");
+
+/** `node:sqlite`'s path for a private database in memory, which has no directory to create. */
+const inMemory = ":memory:";
+
+/**
+ * The data file used when `--data` is not given: `PROCESS_GRAPH_DATA` when it is set and not empty, otherwise `process-graph/graph.sqlite3` under the XDG data directory (`XDG_DATA_HOME`, or `.local/share` in the home directory).
+ * @param env - The environment.
+ * @param home - The home directory.
+ * @returns The path.
+ */
+export const defaultDataPath = (
+  env: Readonly<Record<string, string | undefined>>,
+  home: string,
+): string => {
+  const named = env[dataVariable];
+  if (named !== undefined && named !== "") {
+    return named;
+  }
+  const xdg = env.XDG_DATA_HOME;
+
+  return join(
+    xdg !== undefined && xdg !== "" ? xdg : join(home, ".local", "share"),
+    dataFile,
+  );
+};
+
+/** A fact port that knows nothing: every condition is indeterminate and no input artefact is provided. */
+const noFacts: Facts = () => ({ found: false });
+
+/**
+ * The version in a package manifest, which `--version` prints. Each bin passes its own manifest, so the entry point reports its own version rather than this package's.
+ * @param manifest - The manifest's location, such as `new URL("../package.json", import.meta.url)` from a module in `dist/`.
+ * @returns The version.
+ * @throws Error when the manifest has no string `version`.
+ */
+export const packageVersion = (manifest: URL): string => {
+  const parsed: unknown = JSON.parse(readFileSync(manifest, "utf8"));
+  if (
+    typeof parsed !== "object" ||
+    parsed === null ||
+    !("version" in parsed) ||
+    typeof parsed.version !== "string"
+  ) {
+    throw new Error(`${manifest.pathname} has no version`);
+  }
+
+  return parsed.version;
+};
+
+/**
+ * The ports for a Node process: the SQLite store over `node:sqlite` (creating the data file's directory when needed), the GitHub issues source for `github:` scopes, the file system and the process's streams.
+ * @param options - Replacements for any of the defaults.
+ * @returns The ports.
+ */
+export const nodePorts = (options: NodePortsOptions = {}): CliPorts => {
+  const env = options.env ?? process.env;
+  const token = options.token ?? githubTokenFromEnvironment({ env });
+
+  return {
+    stdout:
+      options.stdout ??
+      ((text) => {
+        process.stdout.write(text);
+      }),
+    stderr:
+      options.stderr ??
+      ((text) => {
+        process.stderr.write(text);
+      }),
+    defaultDataPath: defaultDataPath(env, options.home ?? homedir()),
+    openStore: (path) => {
+      if (path !== inMemory) {
+        mkdirSync(dirname(path), { recursive: true });
+      }
+      const { store, close } = openNodeGraphStore(path);
+
+      return {
+        client: createRouterClient(createGraphStoreRouter(store)),
+        close,
+      };
+    },
+    source: (prefix) =>
+      prefix === githubSource
+        ? createRouterClient(
+            createGraphSourceRouter(
+              createGitHubIssuesSource({
+                token,
+                now: options.now ?? Date.now,
+                ...(options.fetch === undefined
+                  ? {}
+                  : { fetch: options.fetch }),
+              }),
+            ),
+          )
+        : undefined,
+    readFile: async (path, signal) =>
+      readFile(
+        path,
+        signal === undefined
+          ? { encoding: "utf8" }
+          : { encoding: "utf8", signal },
+      ),
+    facts: options.facts ?? noFacts,
+    signal: options.signal,
+  };
+};
+
+/**
+ * Runs the command line as the current process: its arguments, its streams and the real ports, with an interrupt aborting whatever the command is waiting on. It resolves with the exit status rather than exiting, so the bin sets `process.exitCode` and pending output is flushed.
+ * @param identity - The name and version the program presents.
+ * @returns The exit status.
+ */
+export const runProcess = async (
+  identity: ProgramIdentity,
+): Promise<ExitCode> => {
+  const controller = new AbortController();
+  process.once("SIGINT", () => {
+    controller.abort();
+  });
+
+  return runCli(
+    process.argv.slice(2),
+    nodePorts({ signal: controller.signal }),
+    identity,
+  );
+};
diff --git a/packages/targets/graph-cli/src/ports.ts b/packages/targets/graph-cli/src/ports.ts
new file mode 100644
index 0000000..1364188
--- /dev/null
+++ b/packages/targets/graph-cli/src/ports.ts
@@ -0,0 +1,43 @@
+import type { Facts } from "@exadev/process-graph-domain";
+import type { GraphSourceClient } from "@exadev/process-graph-source-contract";
+import type { GraphStoreClient } from "@exadev/process-graph-store-contract";
+
+/** A store opened for one command, and how to release it. */
+export interface OpenedStore {
+  /** The store, over whatever transport the opener chose. */
+  readonly client: GraphStoreClient;
+  /** Releases the store. Called once, after the command, whether it succeeded or not. */
+  readonly close: () => void | Promise<void>;
+}
+
+/**
+ * Everything the command line touches outside itself. Commands read and write only through these, so the whole command surface runs in a test, or inside another program such as Switchboard, with no process, file system or network of its own. `nodePorts` supplies them for a real process.
+ */
+export interface CliPorts {
+  /** Writes text to standard output, exactly as given. */
+  readonly stdout: (text: string) => void;
+  /** Writes text to standard error, exactly as given. */
+  readonly stderr: (text: string) => void;
+  /** Opens the store kept at a data path. */
+  readonly openStore: (path: string) => OpenedStore | Promise<OpenedStore>;
+  /** The data path used when `--data` is not given. */
+  readonly defaultDataPath: string;
+  /**
+   * The source that serves scopes with an identifier prefix, such as `github` for `github:owner/repo`, or `undefined` when no source has that prefix.
+   * @param prefix - The part of a scope identifier before its first colon.
+   */
+  readonly source: (prefix: string) => GraphSourceClient | undefined;
+  /**
+   * Reads a text file, for `validate <file>`.
+   * @param path - The file to read.
+   * @param signal - Aborts the read.
+   */
+  readonly readFile: (
+    path: string,
+    signal: AbortSignal | undefined,
+  ) => Promise<string>;
+  /** The facts that decision conditions read, and which input artefacts are provided. */
+  readonly facts: Facts;
+  /** Aborts every store and source call a command makes. */
+  readonly signal: AbortSignal | undefined;
+}
diff --git a/packages/targets/graph-cli/src/program.ts b/packages/targets/graph-cli/src/program.ts
new file mode 100644
index 0000000..8455289
--- /dev/null
+++ b/packages/targets/graph-cli/src/program.ts
@@ -0,0 +1,633 @@
+import {
+  overlayStatuses,
+  participantKinds,
+  type OverlayStatus,
+  type ParticipantKind,
+} from "@exadev/process-graph-schema";
+import { Argument, Command, Option } from "commander";
+import { add, setState, type Addition } from "./edit.ts";
+import { failureOf } from "./errors.ts";
+import { exitCodes, type ExitCode } from "./exit-codes.ts";
+import type { CliPorts } from "./ports.ts";
+import {
+  blocked,
+  cycles,
+  handoffsOf,
+  impactOf,
+  path,
+  ready,
+  why,
+} from "./queries.ts";
+import {
+  renderAdded,
+  renderBlocked,
+  renderCycles,
+  renderHandoffs,
+  renderImpact,
+  renderPath,
+  renderReady,
+  renderSet,
+  renderSync,
+  renderValidate,
+  renderWhy,
+} from "./render.ts";
+import type { GraphSession } from "./session.ts";
+import {
+  formatNames,
+  show,
+  viewNames,
+  type FormatName,
+  type ViewName,
+} from "./show.ts";
+import { sync } from "./sync.ts";
+import { validateDocument, validateStored } from "./validate.ts";
+
+/** How the program presents itself. */
+export interface ProgramIdentity {
+  /** The command name shown in help and usage, such as `process-graph`, or `sb graph` when embedded. */
+  readonly name: string;
+  /** The version `--version` prints. */
+  readonly version: string;
+}
+
+/** The model a command works on when `--model` is not given. */
+export const defaultModelId = "default";
+
+const exitStatusHelp = `
+Exit status:
+  ${String(exitCodes.success)}  success; for validate and cycles, nothing wrong was found
+  ${String(exitCodes.failure)}  failure not listed below
+  ${String(exitCodes.usage)}  usage error: unknown command or option, missing argument, value outside its choices
+  ${String(exitCodes.notFound)}  the model, an element or another identifier named does not exist
+  ${String(exitCodes.invalidModel)}  the model has problems: validation issues, an illegal cycle, or a change the store rejected
+  ${String(exitCodes.sourceFailure)}  a source refused the sync: credentials, rate limit or scope
+
+Every command writes JSON with --json. The store is a SQLite file, chosen with --data.`;
+
+/** What one command produced: the value `--json` writes, the text written otherwise, and the exit status. */
+interface Outcome {
+  readonly json: unknown;
+  readonly text: string;
+  readonly exitCode?: ExitCode;
+}
+
+/** The options every command shares, read from the program. */
+interface GlobalOptions {
+  readonly data: string;
+  readonly model: string;
+  readonly json: boolean;
+}
+
+const readGlobals = (command: Command, ports: CliPorts): GlobalOptions => {
+  const options: Record<string, unknown> = command.optsWithGlobals();
+  const { data, model, json } = options;
+
+  return {
+    data: typeof data === "string" ? data : ports.defaultDataPath,
+    model: typeof model === "string" ? model : defaultModelId,
+    json: json === true,
+  };
+};
+
+const isOneOf = <T extends string>(
+  values: readonly T[],
+  value: unknown,
+): value is T => values.some((candidate) => candidate === value);
+
+/** Reads an option whose choices commander has already checked, narrowing it to its type. */
+const choice = <T extends string>(
+  values: readonly T[],
+  value: unknown,
+  name: string,
+): T => {
+  if (!isOneOf(values, value)) {
+    throw new Error(`--${name} was not checked against its choices`);
+  }
+
+  return value;
+};
+
+/**
+ * Runs the command line with the given arguments, writing only through the ports, and resolves with the exit status. It never exits the process or reads its arguments itself, so a test or a host program such as Switchboard runs it as a function.
+ * @param args - The arguments after the program name, such as `["ready", "--json"]`.
+ * @param ports - Output, store, sources, facts and the abort signal.
+ * @param identity - The name and version the program presents.
+ * @returns The exit status, one of `exitCodes`.
+ */
+export const runCli = async (
+  args: readonly string[],
+  ports: CliPorts,
+  identity: ProgramIdentity,
+): Promise<ExitCode> => {
+  let exitCode: ExitCode = exitCodes.success;
+
+  const program = new Command(identity.name);
+  program
+    .description(
+      "Sync work from its sources into a process model, and ask what is ready, blocked, on the critical path or handed off, why, and what it looks like as a diagram.",
+    )
+    .version(identity.version)
+    .configureOutput({ writeOut: ports.stdout, writeErr: ports.stderr })
+    .configureHelp({ showGlobalOptions: true })
+    .exitOverride()
+    .option(
+      "--data <path>",
+      "the SQLite file the store keeps",
+      ports.defaultDataPath,
+    )
+    .option("--model <id>", "the model in the store", defaultModelId)
+    .option("--json", "write the result as JSON")
+    .addHelpText("after", exitStatusHelp)
+    .showHelpAfterError();
+
+  /** Writes a command's result, as JSON or text, and records its exit status. */
+  const respond = (globals: GlobalOptions, outcome: Outcome): void => {
+    ports.stdout(
+      globals.json
+        ? `${JSON.stringify(outcome.json, null, 2)}\n`
+        : outcome.text,
+    );
+    exitCode = outcome.exitCode ?? exitCodes.success;
+  };
+
+  /** Opens the store for one command, runs it, writes its result and records its exit status; the store is closed whatever happens. */
+  const withSession =
+    <Args extends unknown[]>(
+      handler: (session: GraphSession, ...values: Args) => Promise<Outcome>,
+    ) =>
+    async (command: Command, ...values: Args): Promise<void> => {
+      const globals = readGlobals(command, ports);
+      const opened = await ports.openStore(globals.data);
+      try {
+        const outcome = await handler(
+          {
+            store: opened.client,
+            modelId: globals.model,
+            facts: ports.facts,
+            signal: ports.signal,
+          },
+          ...values,
+        );
+        respond(globals, outcome);
+      } finally {
+        await opened.close();
+      }
+    };
+
+  program
+    .command("sync")
+    .description(
+      "read the scopes from their sources and merge them into the model",
+    )
+    .argument(
+      "<scope...>",
+      "source-qualified scopes, such as github:owner or github:owner/repo",
+    )
+    .option("--after <cursor>", "resume an interrupted sync after this cursor")
+    .action(
+      async (
+        scopes: readonly string[],
+        options: Record<string, unknown>,
+        command: Command,
+      ) => {
+        const { after } = options;
+        await withSession(async (session) => {
+          const result = await sync(
+            session,
+            ports.source,
+            typeof after === "string" ? { scopes, after } : { scopes },
+          );
+
+          return { json: result, text: renderSync(result) };
+        })(command);
+      },
+    );
+
+  program
+    .command("ready")
+    .description("list the work that can start now")
+    .action(async (_options: unknown, command: Command) => {
+      await withSession(async (session) => {
+        const result = await ready(session);
+
+        return { json: result, text: renderReady(result) };
+      })(command);
+    });
+
+  program
+    .command("blocked")
+    .description("list the open work an element is waiting on")
+    .argument("<id>", "the element")
+    .action(async (id: string, _options: unknown, command: Command) => {
+      await withSession(async (session) => {
+        const result = await blocked(session, id);
+
+        return { json: result, text: renderBlocked(result) };
+      })(command);
+    });
+
+  program
+    .command("impact")
+    .description("list the live work that depends on an element")
+    .argument("<id>", "the element")
+    .action(async (id: string, _options: unknown, command: Command) => {
+      await withSession(async (session) => {
+        const result = await impactOf(session, id);
+
+        return { json: result, text: renderImpact(result) };
+      })(command);
+    });
+
+  program
+    .command("path")
+    .description(
+      "list the critical path: the longest chain of work still ahead",
+    )
+    .action(async (_options: unknown, command: Command) => {
+      await withSession(async (session) => {
+        const result = await path(session);
+
+        return { json: result, text: renderPath(result) };
+      })(command);
+    });
+
+  program
+    .command("cycles")
+    .description(
+      "list the cycles no decision closes; exits with the invalid model status when there are any",
+    )
+    .action(async (_options: unknown, command: Command) => {
+      await withSession(async (session) => {
+        const result = await cycles(session);
+
+        return {
+          json: result,
+          text: renderCycles(result),
+          exitCode:
+            result.cycles.length === 0
+              ? exitCodes.success
+              : exitCodes.invalidModel,
+        };
+      })(command);
+    });
+
+  program
+    .command("handoffs")
+    .description("list the transitions from one actor's work to another's")
+    .action(async (_options: unknown, command: Command) => {
+      await withSession(async (session) => {
+        const result = await handoffsOf(session);
+
+        return { json: result, text: renderHandoffs(result) };
+      })(command);
+    });
+
+  program
+    .command("why")
+    .description(
+      "explain an element's status: the rule that decided it, its needs and the blocked-by chain",
+    )
+    .argument("<id>", "the element")
+    .action(async (id: string, _options: unknown, command: Command) => {
+      await withSession(async (session) => {
+        const result = await why(session, id);
+
+        return { json: result, text: renderWhy(result) };
+      })(command);
+    });
+
+  program
+    .command("show")
+    .description("draw the model as a view")
+    .addOption(
+      new Option("--view <view>", "the view to draw")
+        .choices(viewNames)
+        .default("flowchart"),
+    )
+    .addOption(
+      new Option("--format <format>", "the format to write")
+        .choices(formatNames)
+        .default("mermaid"),
+    )
+    .option(
+      "--subject <entity>",
+      "the entity a state view follows; defaults to the model's declared state machine projection",
+    )
+    .option(
+      "--scenario <transition...>",
+      "the transitions a sequence view follows, in order; defaults to the model's declared sequence projection",
+    )
+    .action(async (options: Record<string, unknown>, command: Command) => {
+      const view: ViewName = choice(viewNames, options.view, "view");
+      const format: FormatName = choice(formatNames, options.format, "format");
+      const { subject, scenario } = options;
+      await withSession(async (session) => {
+        const result = await show(session, {
+          view,
+          format,
+          ...(typeof subject === "string" ? { subject } : {}),
+          ...(Array.isArray(scenario)
+            ? {
+                scenario: scenario.filter(
+                  (id): id is string => typeof id === "string",
+                ),
+              }
+            : {}),
+        });
+
+        return {
+          json:
+            format === "json"
+              ? result.projection
+              : { view, format, text: result.text },
+          text: result.text,
+        };
+      })(command);
+    });
+
+  const addCommand = program
+    .command("add")
+    .description("add a record to the model, creating the model if needed");
+
+  const added = async (
+    command: Command,
+    addition: Addition,
+    kind: string,
+  ): Promise<void> =>
+    withSession(async (session) => {
+      const written = await add(session, addition);
+
+      return {
+        json: {
+          added: kind,
+          id: addition.record.id,
+          revision: written.revision,
+        },
+        text: renderAdded(kind, addition.record.id, written),
+      };
+    })(command);
+
+  addCommand
+    .command("participant")
+    .description(
+      "add a participant: a role or system that acts, or an entity with a lifecycle",
+    )
+    .argument("<id>", "its identifier")
+    .argument("<label>", "its label")
+    .addOption(
+      new Option("--kind <kind>", "what it is")
+        .choices(participantKinds)
+        .default("role"),
+    )
+    .action(
+      async (
+        id: string,
+        label: string,
+        options: Record<string, unknown>,
+        command: Command,
+      ) => {
+        const kind: ParticipantKind = choice(
+          participantKinds,
+          options.kind,
+          "kind",
+        );
+        await added(
+          command,
+          { kind: "participant", record: { id, label, kind } },
+          "participant",
+        );
+      },
+    );
+
+  addCommand
+    .command("activity")
+    .description("add an activity: a step of work")
+    .argument("<id>", "its identifier")
+    .argument("<label>", "its label")
+    .option("--actor <participant>", "the role or system that does it")
+    .action(
+      async (
+        id: string,
+        label: string,
+        options: Record<string, unknown>,
+        command: Command,
+      ) => {
+        const { actor } = options;
+        await added(
+          command,
+          {
+            kind: "element",
+            record: {
+              kind: "activity",
+              id,
+              label,
+              ...(typeof actor === "string" ? { actor } : {}),
+            },
+          },
+          "activity",
+        );
+      },
+    );
+
+  addCommand
+    .command("decision")
+    .description("add a decision: a point where the flow branches")
+    .argument("<id>", "its identifier")
+    .argument("<label>", "its label, the question it asks")
+    .option("--actor <participant>", "the role or system that decides")
+    .action(
+      async (
+        id: string,
+        label: string,
+        options: Record<string, unknown>,
+        command: Command,
+      ) => {
+        const { actor } = options;
+        await added(
+          command,
+          {
+            kind: "element",
+            record: {
+              kind: "decision",
+              id,
+              label,
+              ...(typeof actor === "string" ? { actor } : {}),
+            },
+          },
+          "decision",
+        );
+      },
+    );
+
+  addCommand
+    .command("state")
+    .description("add a state an entity rests in")
+    .argument("<id>", "its identifier")
+    .argument("<label>", "its label")
+    .option("--parent <state>", "the state it is nested in")
+    .action(
+      async (
+        id: string,
+        label: string,
+        options: Record<string, unknown>,
+        command: Command,
+      ) => {
+        const { parent } = options;
+        await added(
+          command,
+          {
+            kind: "element",
+            record: {
+              kind: "state",
+              id,
+              label,
+              ...(typeof parent === "string" ? { parent } : {}),
+            },
+          },
+          "state",
+        );
+      },
+    );
+
+  addCommand
+    .command("event")
+    .description("add an event that can trigger a transition")
+    .argument("<id>", "its identifier")
+    .argument("<name>", "its name")
+    .action(
+      async (id: string, name: string, _options: unknown, command: Command) => {
+        await added(command, { kind: "event", record: { id, name } }, "event");
+      },
+    );
+
+  addCommand
+    .command("artefact")
+    .description("add an artefact that activities consume or produce")
+    .argument("<id>", "its identifier")
+    .argument("<name>", "its name")
+    .option(
+      "--deliverable",
+      "mark it as an output the process exists to deliver",
+    )
+    .action(
+      async (
+        id: string,
+        name: string,
+        options: Record<string, unknown>,
+        command: Command,
+      ) => {
+        await added(
+          command,
+          {
+            kind: "artefact",
+            record:
+              options.deliverable === true
+                ? { id, name, deliverable: true }
+                : { id, name },
+          },
+          "artefact",
+        );
+      },
+    );
+
+  addCommand
+    .command("transition")
+    .description("add a transition: the target waits on the source")
+    .argument("<source>", "the element that comes first")
+    .argument("<target>", "the element that follows")
+    .option(
+      "--id <id>",
+      "its identifier; <source>-><target> when not given, as a source names its transitions",
+    )
+    .option("--guard <label>", "the label of the branch it takes")
+    .option("--trigger <event>", "the event that fires it")
+    .action(
+      async (
+        source: string,
+        target: string,
+        options: Record<string, unknown>,
+        command: Command,
+      ) => {
+        const { id, guard, trigger } = options;
+        await added(
+          command,
+          {
+            kind: "transition",
+            record: {
+              id: typeof id === "string" ? id : `${source}->${target}`,
+              source,
+              target,
+              ...(typeof guard === "string" ? { guard } : {}),
+              ...(typeof trigger === "string" ? { trigger } : {}),
+            },
+          },
+          "transition",
+        );
+      },
+    );
+
+  program
+    .command("set")
+    .description("set an element's run state")
+    .argument("<id>", "the element")
+    .addArgument(
+      new Argument("<state>", "its run state").choices(overlayStatuses),
+    )
+    .action(
+      async (
+        id: string,
+        state: string,
+        _options: unknown,
+        command: Command,
+      ) => {
+        const status: OverlayStatus = choice(overlayStatuses, state, "state");
+        await withSession(async (session) => {
+          const result = await setState(session, id, status);
+
+          return { json: result, text: renderSet(result) };
+        })(command);
+      },
+    );
+
+  program
+    .command("validate")
+    .description(
+      "check the stored model, or a model file, for problems; exits with the invalid model status when there are any",
+    )
+    .argument("[file]", "a model as JSON, checked instead of the stored model")
+    .action(
+      async (file: string | undefined, _options: unknown, command: Command) => {
+        const outcome = (
+          result: ReturnType<typeof validateDocument>,
+        ): Outcome => ({
+          json: result,
+          text: renderValidate(result),
+          exitCode: result.valid ? exitCodes.success : exitCodes.invalidModel,
+        });
+        if (file === undefined) {
+          await withSession(async (session) =>
+            outcome(await validateStored(session)),
+          )(command);
+
+          return;
+        }
+        respond(
+          readGlobals(command, ports),
+          outcome(validateDocument(await ports.readFile(file, ports.signal))),
+        );
+      },
+    );
+
+  try {
+    await program.parseAsync(args, { from: "user" });
+  } catch (error) {
+    const failure = failureOf(error);
+    if (failure.message !== "") {
+      ports.stderr(`${failure.message}\n`);
+    }
+
+    return failure.exitCode;
+  }
+
+  return exitCode;
+};
diff --git a/packages/targets/graph-cli/src/queries.ts b/packages/targets/graph-cli/src/queries.ts
new file mode 100644
index 0000000..1f55d9d
--- /dev/null
+++ b/packages/targets/graph-cli/src/queries.ts
@@ -0,0 +1,215 @@
+import {
+  blockedBy,
+  criticalPath,
+  deriveStatuses,
+  explainStatus,
+  illegalCycles,
+  impact,
+  readySet,
+  type ArtefactBasis,
+  type IncomingBasis,
+  type Status,
+  type StatusRule,
+} from "@exadev/process-graph-domain";
+import { handoffs, type Handoff } from "@exadev/process-graph-projection";
+import type { OpenIds } from "@exadev/process-graph-schema";
+import {
+  labelOf,
+  loadRun,
+  requireElement,
+  summarise,
+  type ElementSummary,
+  type GraphSession,
+} from "./session.ts";
+
+/** An element with its derived status. */
+export interface ElementStatus extends ElementSummary {
+  readonly status: Status;
+}
+
+/** Every element that can be worked on now. */
+export interface ReadyResult {
+  readonly elements: readonly ElementSummary[];
+}
+
+/** What an element is waiting on. */
+export interface BlockedResult {
+  readonly element: ElementStatus;
+  /** The open work to finish first: the ends of the element's blocked-by chain, in model order. */
+  readonly blockedBy: readonly ElementSummary[];
+}
+
+/** What finishing, delaying or dropping an element affects. */
+export interface ImpactResult {
+  readonly element: ElementStatus;
+  /** The live elements that transitively depend on it, in model order. */
+  readonly impacted: readonly ElementSummary[];
+}
+
+/** The longest chain of work still ahead. */
+export interface PathResult {
+  /** The chain in dependency order. */
+  readonly path: readonly ElementSummary[];
+  /** Its length in elements, each counting one step. */
+  readonly weight: number;
+}
+
+/** The cycles no decision closes. */
+export interface CyclesResult {
+  /** Each cycle as a closed path: each element needs the next, and the first is repeated at the end. */
+  readonly cycles: readonly (readonly string[])[];
+}
+
+/** The transitions between elements with different actors. */
+export interface HandoffsResult {
+  readonly handoffs: readonly Handoff<OpenIds>[];
+}
+
+/** One element of a blocked-by chain, with its label and status. */
+export interface WhyLink extends ElementStatus {
+  /** The unfinished needs it still waits on, in model order. */
+  readonly waitingOn: readonly string[];
+}
+
+/** Why an element has its status. */
+export interface WhyResult {
+  readonly element: ElementStatus;
+  /** The rule of the status derivation that decided it. */
+  readonly rule: StatusRule;
+  /** Its incoming transitions other than loop edges, each with its branch, its source's status and whether it is cut. */
+  readonly transitions: readonly IncomingBasis<OpenIds>[];
+  /** The artefacts it consumes, each with whether it is provided and its producers' statuses. */
+  readonly artefacts: readonly ArtefactBasis<OpenIds>[];
+  /** The element, then every unfinished need reached from it, in model order. */
+  readonly chain: readonly WhyLink[];
+}
+
+/** Each element counts as one step, so the critical path is the longest chain of elements. */
+const stepWeight = 1;
+
+/**
+ * The elements that are ready: not done, with every live need done.
+ * @param session - The store, model and facts.
+ */
+export const ready = async (session: GraphSession): Promise<ReadyResult> => {
+  const { model, overlay } = await loadRun(session);
+
+  return {
+    elements: summarise(model, readySet(model, overlay, session.facts)),
+  };
+};
+
+const statusOf = (
+  statuses: ReadonlyMap<string, Status>,
+  summary: ElementSummary,
+): ElementStatus => {
+  const status = statuses.get(summary.id);
+  if (status === undefined) {
+    throw new Error(`no status was derived for "${summary.id}"`);
+  }
+
+  return { ...summary, status };
+};
+
+/**
+ * What an element is waiting on.
+ * @param session - The store, model and facts.
+ * @param id - The element asked about.
+ */
+export const blocked = async (
+  session: GraphSession,
+  id: string,
+): Promise<BlockedResult> => {
+  const { model, overlay } = await loadRun(session);
+  const element = requireElement(model, id);
+  const statuses = deriveStatuses(model, overlay, session.facts);
+
+  return {
+    element: statusOf(statuses, { id, label: labelOf(element) }),
+    blockedBy: summarise(model, blockedBy(model, overlay, session.facts, id)),
+  };
+};
+
+/**
+ * What depends on an element.
+ * @param session - The store, model and facts.
+ * @param id - The element asked about.
+ */
+export const impactOf = async (
+  session: GraphSession,
+  id: string,
+): Promise<ImpactResult> => {
+  const { model, overlay } = await loadRun(session);
+  const element = requireElement(model, id);
+  const statuses = deriveStatuses(model, overlay, session.facts);
+
+  return {
+    element: statusOf(statuses, { id, label: labelOf(element) }),
+    impacted: summarise(model, impact(model, overlay, session.facts, id)),
+  };
+};
+
+/**
+ * The critical path: the longest chain through the work still ahead.
+ * @param session - The store, model and facts.
+ */
+export const path = async (session: GraphSession): Promise<PathResult> => {
+  const { model, overlay } = await loadRun(session);
+  const found = criticalPath(model, overlay, session.facts, () => stepWeight);
+
+  return { path: summarise(model, found.path), weight: found.weight };
+};
+
+/**
+ * The cycles of the model that no decision closes, which make every status undefined.
+ * @param session - The store and model.
+ */
+export const cycles = async (session: GraphSession): Promise<CyclesResult> => {
+  const { model } = await loadRun(session);
+
+  return { cycles: illegalCycles(model) };
+};
+
+/**
+ * The hand-offs: transitions from one actor's work to another's.
+ * @param session - The store and model.
+ */
+export const handoffsOf = async (
+  session: GraphSession,
+): Promise<HandoffsResult> => {
+  const { model } = await loadRun(session);
+
+  return { handoffs: handoffs(model) };
+};
+
+/**
+ * Why an element has its status, and the chain of unfinished work behind it.
+ * @param session - The store, model and facts.
+ * @param id - The element asked about.
+ */
+export const why = async (
+  session: GraphSession,
+  id: string,
+): Promise<WhyResult> => {
+  const { model, overlay } = await loadRun(session);
+  requireElement(model, id);
+  const explained = explainStatus(model, overlay, session.facts, id);
+  const chain = explained.chain.map((link) => ({
+    id: link.element,
+    label: labelOf(requireElement(model, link.element)),
+    status: link.status,
+    waitingOn: link.waitingOn,
+  }));
+  const [first] = chain;
+  if (first === undefined) {
+    throw new Error(`the explanation of "${id}" has no chain`);
+  }
+
+  return {
+    element: { id: first.id, label: first.label, status: first.status },
+    rule: explained.rule,
+    transitions: explained.transitions,
+    artefacts: explained.artefacts,
+    chain,
+  };
+};
diff --git a/packages/targets/graph-cli/src/render.ts b/packages/targets/graph-cli/src/render.ts
new file mode 100644
index 0000000..da8500c
--- /dev/null
+++ b/packages/targets/graph-cli/src/render.ts
@@ -0,0 +1,142 @@
+import type { Status, StatusRule } from "@exadev/process-graph-domain";
+import type { Written, SetResult } from "./edit.ts";
+import type {
+  BlockedResult,
+  CyclesResult,
+  HandoffsResult,
+  ImpactResult,
+  PathResult,
+  ReadyResult,
+  WhyResult,
+} from "./queries.ts";
+import type { ElementSummary } from "./session.ts";
+import type { SyncResult } from "./sync.ts";
+import type { ValidateResult } from "./validate.ts";
+
+/**
+ * Text renderings of each command's result. Lists are one item per line with tab-separated fields, so they cut, sort and grep cleanly, and an empty list prints nothing. Every rendering ends with a line break when it is not empty.
+ */
+const lines = (rows: readonly string[]): string =>
+  rows.length === 0 ? "" : `${rows.join("\n")}\n`;
+
+const elementRows = (elements: readonly ElementSummary[]): readonly string[] =>
+  elements.map((element) => `${element.id}\t${element.label}`);
+
+/** `ready`: each ready element's identifier and label. */
+export const renderReady = (result: ReadyResult): string =>
+  lines(elementRows(result.elements));
+
+/** `blocked`: each element at the end of the blocked-by chain. */
+export const renderBlocked = (result: BlockedResult): string =>
+  lines(elementRows(result.blockedBy));
+
+/** `impact`: each element that depends on the one asked about. */
+export const renderImpact = (result: ImpactResult): string =>
+  lines(elementRows(result.impacted));
+
+/** `path`: the critical path, one element per line in dependency order. */
+export const renderPath = (result: PathResult): string =>
+  lines(elementRows(result.path));
+
+/** `cycles`: each illegal cycle as a closed path. */
+export const renderCycles = (result: CyclesResult): string =>
+  lines(result.cycles.map((cycle) => cycle.join(" -> ")));
+
+/** `handoffs`: each hand-off's transition and the actors it passes between. */
+export const renderHandoffs = (result: HandoffsResult): string =>
+  lines(
+    result.handoffs.map(
+      (handoff) => `${handoff.transition}\t${handoff.from} -> ${handoff.to}`,
+    ),
+  );
+
+/** The sentence that says why each rule gives its status. `needs-met` gives a decision or pseudo-state `done` rather than `ready`, and says so. */
+const ruleSentences: Readonly<Record<StatusRule, string>> = {
+  "overlay-done": "its run state is done",
+  "overlay-unknown": "its run state is unknown",
+  "unknown-need":
+    "something it needs is unknown, or a condition on the way to it cannot be decided",
+  "all-cut": "every transition into it is cut",
+  "needs-met": "everything it needs is done",
+  waiting: "it waits on work that is not done",
+};
+
+const ruleSentence = (rule: StatusRule, status: Status): string =>
+  rule === "needs-met" && status === "done"
+    ? "it is a decision or pseudo-state and everything it needs is done"
+    : ruleSentences[rule];
+
+/** `why`: the status and the rule behind it, then its needs, its artefacts and the blocked-by chain, each section only when it has something in it. */
+export const renderWhy = (result: WhyResult): string => {
+  const { element } = result;
+  const needs = result.transitions.map((transition) => {
+    const notes = [
+      ...(transition.branch === "taken"
+        ? []
+        : [`condition ${transition.branch}`]),
+      ...(transition.cut ? ["cut"] : []),
+    ];
+
+    return `  ${transition.source} (${transition.sourceStatus}) through ${transition.transition}${notes.length === 0 ? "" : `, ${notes.join(", ")}`}`;
+  });
+  const artefacts = result.artefacts.map((artefact) => {
+    const producers =
+      artefact.producers.length === 0
+        ? "produced by nothing"
+        : `produced by ${artefact.producers
+            .map((producer) => `${producer.element} (${producer.status})`)
+            .join(", ")}`;
+
+    return `  ${artefact.artefact}: ${artefact.provided ? "provided" : "not provided"}, ${producers}`;
+  });
+  const chain =
+    result.chain.length > 1 ||
+    result.chain.some((link) => link.waitingOn.length > 0)
+      ? result.chain.map(
+          (link) =>
+            `  ${link.id} (${link.status})${link.waitingOn.length === 0 ? "" : ` waits on ${link.waitingOn.join(", ")}`}`,
+        )
+      : [];
+
+  return lines([
+    `${element.id} is ${element.status}: ${ruleSentence(result.rule, element.status)}`,
+    ...(needs.length === 0 ? [] : ["needs:", ...needs]),
+    ...(artefacts.length === 0 ? [] : ["artefacts:", ...artefacts]),
+    ...(chain.length === 0 ? [] : ["blocked-by chain:", ...chain]),
+  ]);
+};
+
+/** `add`: what was added and the revision it took. */
+export const renderAdded = (
+  kind: string,
+  id: string,
+  written: Written,
+): string =>
+  lines([`added ${kind} ${id} at revision ${String(written.revision)}`]);
+
+/** `set`: the element's new run state and the revision it took. */
+export const renderSet = (result: SetResult): string =>
+  lines([
+    `set ${result.element} to ${result.state} at revision ${String(result.revision)}`,
+  ]);
+
+/** `sync`: what was written, then each gap as its reason, target and message. */
+export const renderSync = (result: SyncResult): string =>
+  lines([
+    `synced ${String(result.activities)} activities, ${String(result.transitions)} transitions and ${String(result.participants)} participants into "${result.modelId}" at revision ${String(result.revision)}`,
+    ...result.gaps.map(
+      (gap) => `gap\t${gap.reason}\t${gap.target}\t${gap.message}`,
+    ),
+  ]);
+
+/** `validate`: `valid`, or each issue as its code, its JSON pointer when it has one, and its message. */
+export const renderValidate = (result: ValidateResult): string =>
+  result.valid
+    ? lines(["valid"])
+    : lines(
+        result.issues.map((issue) =>
+          issue.pointer === undefined
+            ? `${issue.code}\t${issue.message}`
+            : `${issue.code}\t${issue.pointer === "" ? "/" : issue.pointer}\t${issue.message}`,
+        ),
+      );
diff --git a/packages/targets/graph-cli/src/session.ts b/packages/targets/graph-cli/src/session.ts
new file mode 100644
index 0000000..a09ca38
--- /dev/null
+++ b/packages/targets/graph-cli/src/session.ts
@@ -0,0 +1,121 @@
+import type { Facts } from "@exadev/process-graph-domain";
+import type {
+  Element,
+  Model,
+  OpenIds,
+  Overlay,
+} from "@exadev/process-graph-schema";
+import type { GraphStoreClient } from "@exadev/process-graph-store-contract";
+import { ORPCError } from "@orpc/server";
+import { CliError } from "./errors.ts";
+import { exitCodes } from "./exit-codes.ts";
+
+/** What every operation works against: one model in one store, the facts its conditions read, and the signal that aborts its calls. */
+export interface GraphSession {
+  readonly store: GraphStoreClient;
+  /** The name the model is filed under in the store. */
+  readonly modelId: string;
+  readonly facts: Facts;
+  readonly signal: AbortSignal | undefined;
+}
+
+/** A stored model and its run state, as an operation reads them. */
+export interface StoredRun {
+  readonly revision: number;
+  readonly model: Model<OpenIds>;
+  readonly overlay: Overlay<OpenIds>;
+}
+
+/** An element as commands report it: its identifier and its human label. */
+export interface ElementSummary {
+  readonly id: string;
+  readonly label: string;
+}
+
+/**
+ * The oRPC client options carrying the session's signal. The key is left out when there is no signal, since the options type does not accept an explicit `undefined`.
+ * @param signal - The signal, if any.
+ */
+export const callOptions = (
+  signal: AbortSignal | undefined,
+): { readonly signal?: AbortSignal } =>
+  signal === undefined ? {} : { signal };
+
+/**
+ * Reads the session's model and run state, if the store has the model.
+ * @param session - The store and model.
+ * @returns The stored run, or `undefined` when the store has no such model.
+ */
+export const findRun = async (
+  session: GraphSession,
+): Promise<StoredRun | undefined> => {
+  try {
+    const stored = await session.store.v1.models.load(
+      { modelId: session.modelId },
+      callOptions(session.signal),
+    );
+
+    return {
+      revision: stored.revision,
+      model: stored.model,
+      overlay: stored.overlay,
+    };
+  } catch (error) {
+    if (error instanceof ORPCError && error.code === "NOT_FOUND") {
+      return undefined;
+    }
+    throw error;
+  }
+};
+
+/**
+ * Loads the session's model and run state.
+ * @param session - The store and model.
+ * @returns The stored run.
+ * @throws CliError with `notFound` when the store has no such model.
+ */
+export const loadRun = async (session: GraphSession): Promise<StoredRun> => {
+  const run = await findRun(session);
+  if (run === undefined) {
+    throw new CliError(
+      exitCodes.notFound,
+      `no model "${session.modelId}" in the store; sync or add something first`,
+    );
+  }
+
+  return run;
+};
+
+/** The label an element is shown with: its own label, or for a pseudo-state, its role. */
+export const labelOf = (element: Element<string, OpenIds>): string =>
+  element.kind === "pseudo" ? element.role : element.label;
+
+/**
+ * Looks an element up by identifier.
+ * @param model - The model to read.
+ * @param id - The element asked about.
+ * @returns The element.
+ * @throws CliError with `notFound` when the model declares no such element.
+ */
+export const requireElement = (
+  model: Model<OpenIds>,
+  id: string,
+): Element<string, OpenIds> => {
+  const element = model.elements.find((candidate) => candidate.id === id);
+  if (element === undefined) {
+    throw new CliError(exitCodes.notFound, `no element "${id}" in the model`);
+  }
+
+  return element;
+};
+
+/**
+ * Summaries of elements, in the order given.
+ * @param model - The model the identifiers belong to.
+ * @param ids - The element identifiers.
+ */
+export const summarise = (
+  model: Model<OpenIds>,
+  ids: readonly string[],
+): readonly ElementSummary[] =>
+  ids.map((id) => ({ id, label: labelOf(requireElement(model, id)) }));
diff --git a/packages/targets/graph-cli/src/show.ts b/packages/targets/graph-cli/src/show.ts
new file mode 100644
index 0000000..3fa9a3d
--- /dev/null
+++ b/packages/targets/graph-cli/src/show.ts
@@ -0,0 +1,222 @@
+import {
+  toFlowchart,
+  toSequence,
+  toStateMachine,
+  toSwimlane,
+  type Flowchart,
+  type SequenceDiagram,
+  type StateMachine,
+  type Swimlane,
+} from "@exadev/process-graph-projection";
+import type { Model, OpenIds } from "@exadev/process-graph-schema";
+import {
+  flowchartToDot,
+  sequenceToDot,
+  stateMachineToDot,
+  swimlaneToDot,
+} from "./emit/dot.ts";
+import {
+  flowchartToMermaid,
+  sequenceToMermaid,
+  stateMachineToMermaid,
+  swimlaneToMermaid,
+} from "./emit/mermaid.ts";
+import { CliError } from "./errors.ts";
+import { exitCodes } from "./exit-codes.ts";
+import { loadRun, type GraphSession } from "./session.ts";
+
+/** The views `show` draws, as named on the command line. */
+export const viewNames = [
+  "flowchart",
+  "swimlane",
+  "state",
+  "sequence",
+] as const;
+
+/** One of the views `show` draws. */
+export type ViewName = (typeof viewNames)[number];
+
+/** The formats `show` writes. */
+export const formatNames = ["json", "mermaid", "dot"] as const;
+
+/** One of the formats `show` writes. */
+export type FormatName = (typeof formatNames)[number];
+
+/** What to draw. */
+export interface ShowRequest {
+  readonly view: ViewName;
+  readonly format: FormatName;
+  /** The entity a state machine follows; the model's declared state machine projection when absent. */
+  readonly subject?: string;
+  /** The transitions a sequence diagram follows, in order; the model's declared sequence projection when absent. */
+  readonly scenario?: readonly string[];
+}
+
+/** A projected view, tagged by which it is. */
+export type ProjectedView =
+  | { readonly view: "flowchart"; readonly projection: Flowchart<OpenIds> }
+  | { readonly view: "swimlane"; readonly projection: Swimlane<OpenIds> }
+  | { readonly view: "state"; readonly projection: StateMachine<OpenIds> }
+  | {
+      readonly view: "sequence";
+      readonly projection: SequenceDiagram<OpenIds>;
+    };
+
+/** A drawn view: the projection, and its text in the requested format (the projection as JSON for `json`). */
+export type ShowResult = ProjectedView & {
+  readonly format: FormatName;
+  readonly text: string;
+};
+
+const subjectOf = (
+  model: Model<OpenIds>,
+  given: string | undefined,
+): string => {
+  const subject =
+    given ??
+    model.projections.find(
+      (projection) => projection.notation === "stateMachine",
+    )?.subject;
+  if (subject === undefined) {
+    throw new CliError(
+      exitCodes.usage,
+      "the state view needs --subject <entity>: the model declares no state machine projection",
+    );
+  }
+  const participant = model.participants.find(
+    (candidate) => candidate.id === subject,
+  );
+  if (participant === undefined) {
+    throw new CliError(
+      exitCodes.notFound,
+      `no participant "${subject}" in the model`,
+    );
+  }
+  if (participant.kind !== "entity") {
+    throw new CliError(
+      exitCodes.usage,
+      `"${subject}" is a ${participant.kind}; a state machine follows an entity`,
+    );
+  }
+
+  return subject;
+};
+
+const scenarioOf = (
+  model: Model<OpenIds>,
+  given: readonly string[] | undefined,
+): readonly string[] => {
+  const scenario =
+    given ??
+    model.projections.find((projection) => projection.notation === "sequence")
+      ?.scenario;
+  if (scenario === undefined) {
+    throw new CliError(
+      exitCodes.usage,
+      "the sequence view needs --scenario <transition...>: the model declares no sequence projection",
+    );
+  }
+  const declared = new Set(
+    model.transitions.map((transition) => transition.id),
+  );
+  const unknown = scenario.filter((id) => !declared.has(id));
+  if (unknown.length > 0) {
+    throw new CliError(
+      exitCodes.notFound,
+      `no transition ${unknown.map((id) => `"${id}"`).join(", ")} in the model`,
+    );
+  }
+
+  return scenario;
+};
+
+/**
+ * Projects a model into a view.
+ * @param model - The model.
+ * @param request - The view, and the subject or scenario it needs.
+ * @returns The projection, tagged by view.
+ * @throws CliError with `usage` when a state machine or sequence diagram has nothing to follow, or the subject is not an entity, and with `notFound` when the subject or a scenario transition does not exist.
+ */
+export const project = (
+  model: Model<OpenIds>,
+  request: Pick<ShowRequest, "view" | "subject" | "scenario">,
+): ProjectedView => {
+  if (request.view === "flowchart") {
+    return { view: "flowchart", projection: toFlowchart(model) };
+  }
+  if (request.view === "swimlane") {
+    return { view: "swimlane", projection: toSwimlane(model) };
+  }
+  if (request.view === "state") {
+    return {
+      view: "state",
+      projection: toStateMachine(model, subjectOf(model, request.subject)),
+    };
+  }
+
+  return {
+    view: "sequence",
+    projection: toSequence(model, scenarioOf(model, request.scenario)),
+  };
+};
+
+/**
+ * Writes a projected view as Mermaid or DOT source.
+ * @param model - The model, for participant labels.
+ * @param projected - The view.
+ * @param format - `mermaid` or `dot`.
+ * @returns The diagram source.
+ */
+export const emit = (
+  model: Model<OpenIds>,
+  projected: ProjectedView,
+  format: Exclude<FormatName, "json">,
+): string => {
+  const labels = new Map(
+    model.participants.map((participant) => [
+      participant.id,
+      participant.label,
+    ]),
+  );
+  // An actor a loaded model names without declaring has no label of its own, so it is shown by its identifier, as the swimlane projection labels its lane.
+  const participantLabel = (id: string): string => labels.get(id) ?? id;
+  const mermaid = format === "mermaid";
+  if (projected.view === "flowchart") {
+    return mermaid
+      ? flowchartToMermaid(projected.projection)
+      : flowchartToDot(projected.projection);
+  }
+  if (projected.view === "swimlane") {
+    return mermaid
+      ? swimlaneToMermaid(projected.projection)
+      : swimlaneToDot(projected.projection);
+  }
+  if (projected.view === "state") {
+    return mermaid
+      ? stateMachineToMermaid(projected.projection)
+      : stateMachineToDot(projected.projection);
+  }
+
+  return mermaid
+    ? sequenceToMermaid(projected.projection, participantLabel)
+    : sequenceToDot(projected.projection, participantLabel);
+};
+
+/**
+ * Draws the session's model as a view in a format.
+ * @param session - The store and model.
+ * @param request - The view, format, and the subject or scenario the view needs.
+ */
+export const show = async (
+  session: GraphSession,
+  request: ShowRequest,
+): Promise<ShowResult> => {
+  const { model } = await loadRun(session);
+  const projected = project(model, request);
+  const text =
+    request.format === "json"
+      ? `${JSON.stringify(projected.projection, null, 2)}\n`
+      : emit(model, projected, request.format);
+
+  return { ...projected, format: request.format, text };
+};
diff --git a/packages/targets/graph-cli/src/sync.ts b/packages/targets/graph-cli/src/sync.ts
new file mode 100644
index 0000000..4c813d6
--- /dev/null
+++ b/packages/targets/graph-cli/src/sync.ts
@@ -0,0 +1,175 @@
+import {
+  assembleSync,
+  type Gap,
+  type GraphSourceClient,
+  type SyncPage,
+} from "@exadev/process-graph-source-contract";
+import type { BoundActivity } from "@exadev/process-graph-store-contract";
+import { CliError, failureOf } from "./errors.ts";
+import { exitCodes } from "./exit-codes.ts";
+import { callOptions, type GraphSession } from "./session.ts";
+
+/** Finds the source that serves scopes with an identifier prefix, such as `github`. */
+export type SourceLookup = (prefix: string) => GraphSourceClient | undefined;
+
+/** What to sync. */
+export interface SyncRequest {
+  /** Source-qualified scope identifiers, such as `github:owner` or `github:owner/repo`, read in order. */
+  readonly scopes: readonly string[];
+  /** A cursor from an interrupted sync: the first source's sync continues after it. */
+  readonly after?: string;
+}
+
+/** What a sync wrote. */
+export interface SyncResult {
+  readonly modelId: string;
+  /** The revision the write took. */
+  readonly revision: number;
+  /** The participants, activities and transitions written, each identifier counted once. */
+  readonly participants: number;
+  readonly activities: number;
+  readonly transitions: number;
+  /** The parts of the scope the sources could not read, in the order they were met. */
+  readonly gaps: readonly Gap[];
+}
+
+/** The scopes of one source, in the order given. */
+interface SourceScopes {
+  readonly prefix: string;
+  readonly scopes: readonly string[];
+}
+
+const scopeSeparator = ":";
+
+/** Groups scopes by their source prefix, keeping the order in which each prefix first appears. */
+const bySource = (scopes: readonly string[]): readonly SourceScopes[] => {
+  const groups = new Map<string, string[]>();
+  for (const scope of scopes) {
+    const separator = scope.indexOf(scopeSeparator);
+    if (separator <= 0) {
+      throw new CliError(
+        exitCodes.usage,
+        `"${scope}" is not a scope: write <source>:<scope>, such as github:owner/repo`,
+      );
+    }
+    const prefix = scope.slice(0, separator);
+    groups.set(prefix, [...(groups.get(prefix) ?? []), scope]);
+  }
+
+  return [...groups].map(([prefix, grouped]) => ({ prefix, scopes: grouped }));
+};
+
+/** Bound activities are the only elements a sync assembles, since a page's activities are bound by schema. */
+const boundActivities = (pages: readonly SyncPage[]) => {
+  const { model, overlay, gaps } = assembleSync(pages);
+  const activities = model.elements.flatMap((element): BoundActivity[] =>
+    element.kind === "activity" && element.source !== undefined
+      ? [{ ...element, source: element.source }]
+      : [],
+  );
+
+  return {
+    items: {
+      participants: model.participants,
+      activities,
+      transitions: model.transitions,
+      overlay,
+    },
+    gaps,
+  };
+};
+
+/**
+ * Reads every page of the scopes from their sources and merges them into the session's model in one write, creating the model when the store has none. Records already in the model are replaced by identifier and the rest are kept, so syncing again refreshes what changed.
+ *
+ * When a source fails part way, the pages read before the failure are still written, and the error says how to resume: the failing source's scopes with `--after` and the cursor of its last page read.
+ * @param session - The store and model.
+ * @param sources - The source for each identifier prefix.
+ * @param request - The scopes, and a cursor to resume after.
+ * @returns What was written, and the gaps the sources reported.
+ * @throws CliError with `usage` for a scope with no source prefix, a prefix no source serves, or `after` with scopes of more than one source; and with the source's failure, the resume command added, when a source refuses the sync.
+ */
+export const sync = async (
+  session: GraphSession,
+  sources: SourceLookup,
+  request: SyncRequest,
+): Promise<SyncResult> => {
+  const groups = bySource(request.scopes);
+  if (request.after !== undefined && groups.length > 1) {
+    throw new CliError(
+      exitCodes.usage,
+      "--after resumes one source's sync: give only that source's scopes",
+    );
+  }
+  const clients = groups.map((group) => {
+    const client = sources(group.prefix);
+    if (client === undefined) {
+      throw new CliError(
+        exitCodes.usage,
+        `no source reads "${group.prefix}" scopes`,
+      );
+    }
+
+    return { ...group, client };
+  });
+
+  const pages: SyncPage[] = [];
+  const write = async () => {
+    const { items, gaps } = boundActivities(pages);
+    const { revision } = await session.store.v1.items.upsert(
+      { modelId: session.modelId, items },
+      callOptions(session.signal),
+    );
+
+    return {
+      modelId: session.modelId,
+      revision,
+      participants: items.participants.length,
+      activities: items.activities.length,
+      transitions: items.transitions.length,
+      gaps,
+    };
+  };
+
+  /** Reads the sources in order, each only after the one before has finished, since a source's failure must stop the ones after it. */
+  const readFrom = async (index: number): Promise<void> => {
+    const group = clients.at(index);
+    if (group === undefined) {
+      return;
+    }
+    let cursor = index === 0 ? request.after : undefined;
+    try {
+      const stream = await group.client.v1.sync.stream(
+        cursor === undefined
+          ? { scope: group.scopes }
+          : { scope: group.scopes, after: cursor },
+        callOptions(session.signal),
+      );
+      for await (const page of stream) {
+        pages.push(page);
+        cursor = page.next;
+      }
+    } catch (error) {
+      const failure = failureOf(error);
+      const saved = pages.length > 0;
+      if (saved) {
+        await write();
+      }
+      const later = clients.slice(index + 1).flatMap((next) => next.scopes);
+      throw new CliError(
+        failure.exitCode,
+        [
+          failure.message,
+          ...(saved ? ["the pages read before the failure are saved"] : []),
+          `resume with: sync ${group.scopes.join(" ")}${cursor === undefined ? "" : ` --after ${cursor}`}`,
+          ...(later.length === 0 ? [] : [`then: sync ${later.join(" ")}`]),
+        ].join("\n"),
+        { cause: error },
+      );
+    }
+    await readFrom(index + 1);
+  };
+  await readFrom(0);
+
+  return write();
+};
diff --git a/packages/targets/graph-cli/src/test-support/fixtures.ts b/packages/targets/graph-cli/src/test-support/fixtures.ts
new file mode 100644
index 0000000..6c2a709
--- /dev/null
+++ b/packages/targets/graph-cli/src/test-support/fixtures.ts
@@ -0,0 +1,90 @@
+import type {
+  FakeGraphSourceOptions,
+  FakePage,
+} from "@exadev/process-graph-source-contract";
+
+const acme = { id: "github:@acme", label: "acme", kind: "system" } as const;
+const app = {
+  id: "github:acme/app",
+  label: "acme/app",
+  kind: "system",
+} as const;
+const web = {
+  id: "github:acme/web",
+  label: "acme/web",
+  kind: "system",
+} as const;
+const alice = { id: "github:@alice", label: "alice", kind: "role" } as const;
+
+const issue = (
+  repo: typeof app | typeof web,
+  number: string,
+  label: string,
+) => {
+  const id = `${repo.id}#${number}`;
+
+  return { kind: "activity", id, source: id, label, actor: repo.id } as const;
+};
+
+const design = issue(app, "1", "Design the schema");
+const api = issue(app, "2", "Build the API");
+const ship = issue(app, "3", "Ship it");
+const ui = issue(web, "7", "Build the UI");
+
+const blocks = (
+  blocker: Readonly<{ id: string }>,
+  blocked: Readonly<{ id: string }>,
+) => ({
+  id: `${blocker.id}->${blocked.id}`,
+  source: blocker.id,
+  target: blocked.id,
+});
+
+const appFirst: FakePage = {
+  participants: [acme, app, alice],
+  activities: [design, api],
+  transitions: [blocks(design, api)],
+  relations: [
+    { kind: "part-of", from: app.id, to: acme.id },
+    { kind: "assigned-to", from: api.id, to: alice.id },
+  ],
+  overlay: { [design.id]: "done", [api.id]: "open" },
+  gaps: [],
+};
+
+const appSecond: FakePage = {
+  participants: [acme, app, web],
+  activities: [ship, ui],
+  transitions: [blocks(api, ship), blocks(ui, ship), blocks(api, ui)],
+  relations: [],
+  overlay: { [ship.id]: "open", [ui.id]: "open" },
+  gaps: [],
+};
+
+const webOnly: FakePage = {
+  participants: [acme, web],
+  activities: [ui],
+  transitions: [],
+  relations: [{ kind: "part-of", from: web.id, to: acme.id }],
+  overlay: { [ui.id]: "open" },
+  gaps: [],
+};
+
+/**
+ * Issues in two repositories of one organisation, shaped the way the GitHub issues source reports them: `acme/app` spans two pages and its last issue waits on work in `acme/web`, which waits on the API. Any other `github:` scope is a `not-found` gap.
+ */
+export const githubLikeSource: FakeGraphSourceOptions = {
+  source: "github",
+  scopes: {
+    "github:acme/app": [appFirst, appSecond],
+    "github:acme/web": [webOnly],
+  },
+};
+
+/** The identifiers of the fixture's issues, for assertions. */
+export const issues = {
+  design: design.id,
+  api: api.id,
+  ship: ship.id,
+  ui: ui.id,
+} as const;
diff --git a/packages/targets/graph-cli/src/test-support/harness.ts b/packages/targets/graph-cli/src/test-support/harness.ts
new file mode 100644
index 0000000..973c7fc
--- /dev/null
+++ b/packages/targets/graph-cli/src/test-support/harness.ts
@@ -0,0 +1,115 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { openNodeGraphStore } from "@exadev/process-graph-sqlite-node";
+import {
+  createFakeGraphSource,
+  createGraphSourceRouter,
+  type GraphSourcePager,
+} from "@exadev/process-graph-source-contract";
+import { createGraphStoreRouter } from "@exadev/process-graph-store-contract";
+import { createRouterClient } from "@orpc/server";
+import type { ExitCode } from "../exit-codes.ts";
+import type { CliPorts } from "../ports.ts";
+import { runCli } from "../program.ts";
+import { githubLikeSource } from "./fixtures.ts";
+
+/** What one run of the command line wrote and returned. */
+export interface Run {
+  readonly code: ExitCode;
+  readonly stdout: string;
+  readonly stderr: string;
+}
+
+/** A command line wired to a SQLite file in a fresh directory and an in-memory source, run as a function. */
+export interface Harness {
+  /** The data file the store keeps; the default data path. */
+  readonly dataPath: string;
+  /** The directory holding it, for other files a test writes. */
+  readonly directory: string;
+  /** Runs the command line with these arguments. */
+  readonly run: (...args: readonly string[]) => Promise<Run>;
+  /** Removes the directory. */
+  readonly remove: () => void;
+}
+
+/**
+ * Builds a harness whose sources serve their pages through the real oRPC router, and whose store is `node:sqlite` on a file, so every command runs exactly as it does in a process apart from the streams.
+ * @param pagers - The sources, each serving the scopes with its prefix; the fixture's `github` fake when none is given.
+ * @returns The harness.
+ */
+export const createHarness = (
+  ...pagers: readonly GraphSourcePager[]
+): Harness => {
+  const sources =
+    pagers.length === 0 ? [createFakeGraphSource(githubLikeSource)] : pagers;
+  const directory = mkdtempSync(join(tmpdir(), "process-graph-cli-"));
+  const dataPath = join(directory, "graph.sqlite3");
+
+  return {
+    dataPath,
+    directory,
+    run: async (...args) => {
+      let stdout = "";
+      let stderr = "";
+      const ports: CliPorts = {
+        stdout: (text) => {
+          stdout += text;
+        },
+        stderr: (text) => {
+          stderr += text;
+        },
+        defaultDataPath: dataPath,
+        openStore: (path) => {
+          const { store, close } = openNodeGraphStore(path);
+
+          return {
+            client: createRouterClient(createGraphStoreRouter(store)),
+            close,
+          };
+        },
+        source: (prefix) => {
+          const pager = sources.find(
+            (candidate) => candidate.source === prefix,
+          );
+
+          return pager === undefined
+            ? undefined
+            : createRouterClient(createGraphSourceRouter(pager));
+        },
+        readFile: async (path) => readFile(path, "utf8"),
+        facts: () => ({ found: false }),
+        signal: undefined,
+      };
+      const code = await runCli(args, ports, {
+        name: "process-graph",
+        version: "0.0.0-test",
+      });
+
+      return { code, stdout, stderr };
+    },
+    remove: () => {
+      rmSync(directory, { recursive: true, force: true });
+    },
+  };
+};
+
+/**
+ * Runs commands one after another, each after the one before has finished, since each reads what the one before wrote.
+ * @param harness - The harness to run them in.
+ * @param commands - The argument lists, in order.
+ * @returns Each run's result, in order.
+ */
+export const runInOrder = async (
+  harness: Harness,
+  commands: readonly (readonly string[])[],
+): Promise<readonly Run[]> => {
+  const [first, ...rest] = commands;
+  if (first === undefined) {
+    return [];
+  }
+  const result = await harness.run(...first);
+
+  return [result, ...(await runInOrder(harness, rest))];
+};
diff --git a/packages/targets/graph-cli/src/validate.ts b/packages/targets/graph-cli/src/validate.ts
new file mode 100644
index 0000000..bcde1ca
--- /dev/null
+++ b/packages/targets/graph-cli/src/validate.ts
@@ -0,0 +1,88 @@
+import { illegalCycles } from "@exadev/process-graph-domain";
+import {
+  ModelParseError,
+  parseModel,
+  validate,
+  validateOverlay,
+  type Model,
+  type OpenIds,
+} from "@exadev/process-graph-schema";
+import { loadRun, type GraphSession } from "./session.ts";
+
+/** One problem with a model. */
+export interface ValidationIssue {
+  /** What kind of problem: a `validate` issue code, `illegal-cycle`, or `schema` for a document whose shape is wrong. */
+  readonly code: string;
+  readonly message: string;
+  /** Where in a document the problem is, as a JSON pointer, for a shape problem. */
+  readonly pointer?: string;
+}
+
+/** Whether a model is valid, and every problem found. */
+export interface ValidateResult {
+  /** True exactly when `issues` is empty. */
+  readonly valid: boolean;
+  readonly issues: readonly ValidationIssue[];
+}
+
+/** A cycle that no decision closes, as an issue: status is undefined on it. */
+const cycleIssues = (model: Model<OpenIds>): readonly ValidationIssue[] =>
+  illegalCycles(model).map((cycle) => ({
+    code: "illegal-cycle",
+    message: `cycle with no decision in it: ${cycle.join(" -> ")}`,
+  }));
+
+const resultOf = (issues: readonly ValidationIssue[]): ValidateResult => ({
+  valid: issues.length === 0,
+  issues,
+});
+
+/**
+ * Checks the session's stored model and run state: the structural rules of `validate`, run state naming elements the model lacks, and cycles no decision closes.
+ * @param session - The store and model.
+ */
+export const validateStored = async (
+  session: GraphSession,
+): Promise<ValidateResult> => {
+  const { model, overlay } = await loadRun(session);
+
+  return resultOf([
+    ...validate(model),
+    ...validateOverlay(model, overlay),
+    ...cycleIssues(model),
+  ]);
+};
+
+/**
+ * Checks a model document, such as a file of JSON: its shape against the model schema (each problem located by JSON pointer), then the structural rules of `validate`, then cycles no decision closes. Text that is not JSON is one `schema` issue at the document itself.
+ * @param text - The document.
+ */
+export const validateDocument = (text: string): ValidateResult => {
+  let input: unknown;
+  try {
+    input = JSON.parse(text);
+  } catch (error) {
+    return resultOf([
+      {
+        code: "schema",
+        message: `not JSON: ${error instanceof Error ? error.message : String(error)}`,
+        pointer: "",
+      },
+    ]);
+  }
+  try {
+    return resultOf(cycleIssues(parseModel(input)));
+  } catch (error) {
+    if (!(error instanceof ModelParseError)) {
+      throw error;
+    }
+
+    return resultOf(
+      error.issues.map((issue) =>
+        issue.source === "schema"
+          ? { code: "schema", message: issue.message, pointer: issue.pointer }
+          : { code: issue.code, message: issue.message },
+      ),
+    );
+  }
+};
diff --git a/packages/targets/graph-cli/stryker.config.ts b/packages/targets/graph-cli/stryker.config.ts
new file mode 100644
index 0000000..3f6a9f3
--- /dev/null
+++ b/packages/targets/graph-cli/stryker.config.ts
@@ -0,0 +1,3 @@
+import { packageStrykerConfig } from "../../../stryker.shared.ts";
+
+export default packageStrykerConfig();
diff --git a/packages/targets/graph-cli/test/package.smoke.test.ts b/packages/targets/graph-cli/test/package.smoke.test.ts
new file mode 100644
index 0000000..27f75d0
--- /dev/null
+++ b/packages/targets/graph-cli/test/package.smoke.test.ts
@@ -0,0 +1,64 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, beforeEach, expect, test } from "vitest";
+// Deliberately imports the built dist/, not src/: this is the check that catches a wrong exports map or a build misconfiguration that a unit test importing straight from src/ never touches.
+import { exitCodes, nodePorts, runCli } from "../dist/index.js";
+
+const bin = fileURLToPath(new URL("../dist/bin.js", import.meta.url));
+
+/** Runs the built bin as a child process and waits for it. */
+const runBin = (args: readonly string[], data: string) =>
+  spawnSync(process.execPath, [bin, ...args], {
+    env: { ...process.env, PROCESS_GRAPH_DATA: data },
+    encoding: "utf8",
+  });
+
+let directory: string;
+
+beforeEach(() => {
+  directory = mkdtempSync(join(tmpdir(), "process-graph-cli-smoke-"));
+});
+
+afterEach(() => {
+  rmSync(directory, { recursive: true, force: true });
+});
+
+test("the built library runs a command against a SQLite file through the Node ports", async () => {
+  let stdout = "";
+  const ports = nodePorts({
+    env: { PROCESS_GRAPH_DATA: join(directory, "graph.sqlite3") },
+    stdout: (text) => {
+      stdout += text;
+    },
+  });
+  const identity = { name: "process-graph-cli", version: "0.0.0" };
+
+  await expect(
+    runCli(["add", "activity", "build", "Build"], ports, identity),
+  ).resolves.toBe(exitCodes.success);
+  await expect(runCli(["ready"], ports, identity)).resolves.toBe(
+    exitCodes.success,
+  );
+  expect(stdout).toBe("added activity build at revision 1\nbuild\tBuild\n");
+});
+
+test("the built bin runs as a process, creating its data directory, and reports its exit status", () => {
+  const data = join(directory, "nested", "graph.sqlite3");
+
+  expect(runBin(["add", "activity", "build", "Build"], data).status).toBe(
+    exitCodes.success,
+  );
+  const ready = runBin(["ready", "--json"], data);
+  expect(ready.status).toBe(exitCodes.success);
+  expect(JSON.parse(ready.stdout)).toEqual({
+    elements: [{ id: "build", label: "Build" }],
+  });
+  expect(runBin(["blocked", "nothing"], data)).toMatchObject({
+    status: exitCodes.notFound,
+    stdout: "",
+    stderr: 'no element "nothing" in the model\n',
+  });
+});
diff --git a/packages/targets/graph-cli/tsconfig.build.json b/packages/targets/graph-cli/tsconfig.build.json
new file mode 100644
index 0000000..63a34ba
--- /dev/null
+++ b/packages/targets/graph-cli/tsconfig.build.json
@@ -0,0 +1,37 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "noEmit": false,
+    "declaration": true,
+    "declarationMap": false,
+    "rootDir": "src",
+    "outDir": "dist",
+    "rewriteRelativeImportExtensions": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.test.ts", "src/test-support/**"],
+  "references": [
+    {
+      "path": "../../core/graph/schema/tsconfig.build.json"
+    },
+    {
+      "path": "../../core/graph/projection/tsconfig.build.json"
+    },
+    {
+      "path": "../../core/graph/domain/tsconfig.build.json"
+    },
+    {
+      "path": "../../core/graph/source-contract/tsconfig.build.json"
+    },
+    {
+      "path": "../../core/graph/store-contract/tsconfig.build.json"
+    },
+    {
+      "path": "../../adapters/graph/source-github-issues/tsconfig.build.json"
+    },
+    {
+      "path": "../../adapters/graph/sqlite-node/tsconfig.build.json"
+    }
+  ]
+}
diff --git a/packages/targets/graph-cli/tsconfig.json b/packages/targets/graph-cli/tsconfig.json
new file mode 100644
index 0000000..b336daf
--- /dev/null
+++ b/packages/targets/graph-cli/tsconfig.json
@@ -0,0 +1,8 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "lib": ["ES2024"],
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts", "test/**/*.ts", "*.config.ts"]
+}
diff --git a/packages/targets/graph-cli/vitest.config.ts b/packages/targets/graph-cli/vitest.config.ts
new file mode 100644
index 0000000..01b9391
--- /dev/null
+++ b/packages/targets/graph-cli/vitest.config.ts
@@ -0,0 +1,16 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    projects: [
+      {
+        extends: true,
+        test: { name: "unit", include: ["src/**/*.test.ts"] },
+      },
+      {
+        extends: true,
+        test: { name: "smoke", include: ["test/package.smoke.test.ts"] },
+      },
+    ],
+  },
+});
diff --git a/packages/targets/process-graph/README.md b/packages/targets/process-graph/README.md
index 1637d8c..a5b726f 100644
--- a/packages/targets/process-graph/README.md
+++ b/packages/targets/process-graph/README.md
@@ -47,7 +47,19 @@ Install `process-graph` to author, load, project and reason about a model. Insta
 | Domain     | `@exadev/process-graph-domain`     | flat                     |
 | DAG        | `@exadev/process-graph-dag`        | namespaced as `dag`      |
 
-Each package's own README documents its functions and rules; this package adds no behaviour of its own.
+Each package's own README documents its functions and rules; this package adds no behaviour of its own beyond the bin.
+
+## The command line
+
+The package carries the `process-graph` bin, the command line from [`@exadev/process-graph-cli`](../graph-cli/README.md): sync work from GitHub issues into a SQLite store, ask what is ready, blocked, affected, on the critical path or handed off, explain a status, and draw the model in Mermaid or Graphviz DOT.
+
+```sh
+npx process-graph sync github:ExaDev
+npx process-graph ready
+npx process-graph show --view swimlane
+```
+
+The bin delegates to that package's library entry, which this package does not re-export: the command line is Node-only, while everything this package exports runs unchanged in a browser or a Worker. A program that embeds the command line, or calls its operations for data, imports `@exadev/process-graph-cli` directly.
 
 ## What is exported, and under which name
 
diff --git a/packages/targets/process-graph/eslint.config.ts b/packages/targets/process-graph/eslint.config.ts
index b3ab58a..023a144 100644
--- a/packages/targets/process-graph/eslint.config.ts
+++ b/packages/targets/process-graph/eslint.config.ts
@@ -5,5 +5,7 @@ export default defineConfig(
   packageLintConfig({
     tsconfigRootDir: import.meta.dirname,
     isomorphic: true,
+    // The bin is a Node launcher that is run, never imported, so the library it carries stays isomorphic.
+    isomorphicExemptions: ["src/bin.ts"],
   }),
 );
diff --git a/packages/targets/process-graph/package.json b/packages/targets/process-graph/package.json
index ad35200..ed24348 100644
--- a/packages/targets/process-graph/package.json
+++ b/packages/targets/process-graph/package.json
@@ -1,7 +1,7 @@
 {
   "name": "process-graph",
   "version": "1.0.4",
-  "description": "A process and dependency graph model with projections into flowcharts, swimlanes, state machines and sequence diagrams, and reasoning over a run: one install for the model, projection, domain and DAG packages.",
+  "description": "A process and dependency graph model with projections into flowcharts, swimlanes, state machines and sequence diagrams, and reasoning over a run: one install for the model, projection, domain and DAG packages, and the process-graph command line.",
   "type": "module",
   "repository": {
     "type": "git",
@@ -12,6 +12,9 @@
   "bugs": {
     "url": "https://github.com/ExaDev/process-graph/issues"
   },
+  "bin": {
+    "process-graph": "./dist/bin.js"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -27,7 +30,9 @@
     "provenance": true,
     "registry": "https://registry.npmjs.org/"
   },
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/bin.js"
+  ],
   "license": "MIT",
   "scripts": {
     "build": "turbo run _build",
@@ -57,6 +62,7 @@
     "sequence-diagram"
   ],
   "dependencies": {
+    "@exadev/process-graph-cli": "0.0.0",
     "@exadev/process-graph-dag": "1.0.2",
     "@exadev/process-graph-domain": "1.0.3",
     "@exadev/process-graph-projection": "1.0.3",
diff --git a/packages/targets/process-graph/src/bin.ts b/packages/targets/process-graph/src/bin.ts
new file mode 100644
index 0000000..d5b9ab2
--- /dev/null
+++ b/packages/targets/process-graph/src/bin.ts
@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { packageVersion, runProcess } from "@exadev/process-graph-cli";
+
+process.exitCode = await runProcess({
+  name: "process-graph",
+  version: packageVersion(new URL("../package.json", import.meta.url)),
+});
diff --git a/packages/targets/process-graph/test/package.smoke.test.ts b/packages/targets/process-graph/test/package.smoke.test.ts
index aed190a..b0b31a3 100644
--- a/packages/targets/process-graph/test/package.smoke.test.ts
+++ b/packages/targets/process-graph/test/package.smoke.test.ts
@@ -1,3 +1,6 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import { expect, test } from "vitest";
 // Deliberately imports the built dist/, not src/: this is the check that catches a wrong exports map or a build misconfiguration that a unit test importing straight from src/ never touches.
 import {
@@ -40,3 +43,27 @@ test("the built package loads a model, projects it and derives its status throug
   expect(readySet(model, {}, facts)).toEqual(["submit"]);
   expect(typeof dag.criticalPath).toBe("function");
 });
+
+test("the built process-graph bin runs the command line as a process with this package's version", () => {
+  const bin = fileURLToPath(new URL("../dist/bin.js", import.meta.url));
+  const manifest: unknown = JSON.parse(
+    readFileSync(new URL("../package.json", import.meta.url), "utf8"),
+  );
+  const version =
+    typeof manifest === "object" &&
+    manifest !== null &&
+    "version" in manifest &&
+    typeof manifest.version === "string"
+      ? manifest.version
+      : undefined;
+
+  const result = spawnSync(process.execPath, [bin, "--version"], {
+    encoding: "utf8",
+  });
+  const help = spawnSync(process.execPath, [bin, "--help"], {
+    encoding: "utf8",
+  });
+
+  expect(result).toMatchObject({ status: 0, stdout: `${String(version)}\n` });
+  expect(help.stdout).toContain("Usage: process-graph [options] [command]");
+});
diff --git a/packages/targets/process-graph/tsconfig.build.json b/packages/targets/process-graph/tsconfig.build.json
index 76d317f..d97c05c 100644
--- a/packages/targets/process-graph/tsconfig.build.json
+++ b/packages/targets/process-graph/tsconfig.build.json
@@ -7,8 +7,11 @@
     "declarationMap": false,
     "rootDir": "src",
     "outDir": "dist",
-    "rewriteRelativeImportExtensions": true
+    "rewriteRelativeImportExtensions": true,
+    "types": ["node"]
   },
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.test.ts", "src/test-support/**"],
   "references": [
     {
       "path": "../../core/graph/dag/tsconfig.build.json"
@@ -21,6 +24,9 @@
     },
     {
       "path": "../../core/graph/domain/tsconfig.build.json"
+    },
+    {
+      "path": "../graph-cli/tsconfig.build.json"
     }
   ]
 }
diff --git a/packages/targets/process-graph/tsconfig.json b/packages/targets/process-graph/tsconfig.json
index 871926f..9ef2ac0 100644
--- a/packages/targets/process-graph/tsconfig.json
+++ b/packages/targets/process-graph/tsconfig.json
@@ -5,5 +5,5 @@
     "types": []
   },
   "include": ["src/**/*.ts"],
-  "exclude": ["src/**/*.test.ts", "src/test-support/**"]
+  "exclude": ["src/**/*.test.ts", "src/test-support/**", "src/bin.ts"]
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 338141b..3f87eee 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -713,8 +713,75 @@ importers:
         specifier: 5.0.3
         version: 5.0.3(@types/node@26.6.4)(@vitest/coverage-v8@5.0.3)(vite@8.3.2(@types/node@26.6.4)(jiti@2.7.0)(yaml@2.9.1))
 
+  packages/targets/graph-cli:
+    dependencies:
+      '@exadev/process-graph-dag':
+        specifier: 1.0.2
+        version: link:../../core/graph/dag
+      '@exadev/process-graph-domain':
+        specifier: 1.0.3
+        version: link:../../core/graph/domain
+      '@exadev/process-graph-projection':
+        specifier: 1.0.3
+        version: link:../../core/graph/projection
+      '@exadev/process-graph-schema':
+        specifier: 1.1.0
+        version: link:../../core/graph/schema
+      '@exadev/process-graph-source-contract':
+        specifier: 1.0.1
+        version: link:../../core/graph/source-contract
+      '@exadev/process-graph-source-github-issues':
+        specifier: 1.0.1
+        version: link:../../adapters/graph/source-github-issues
+      '@exadev/process-graph-sqlite-node':
+        specifier: 1.0.0
+        version: link:../../adapters/graph/sqlite-node
+      '@exadev/process-graph-store-contract':
+        specifier: 1.0.1
+        version: link:../../core/graph/store-contract
+      '@orpc/server':
+        specifier: 2.0.0-beta.41
+        version: 2.0.0-beta.41
+      commander:
+        specifier: 15.0.0
+        version: 15.0.0
+    devDependencies:
+      '@arethetypeswrong/cli':
+        specifier: 0.18.5
+        version: 0.18.5
+      '@stryker-mutator/core':
+        specifier: 10.0.0
+        version: 10.0.0(@types/node@26.6.4)
+      '@stryker-mutator/typescript-checker':
+        specifier: 10.0.0
+        version: 10.0.0(@stryker-mutator/core@10.0.0(@types/node@26.6.4))(typescript@6.0.3)
+      '@stryker-mutator/vitest-runner':
+        specifier: 10.0.0
+        version: 10.0.0(@stryker-mutator/core@10.0.0(@types/node@26.6.4))(vitest@5.0.3)
+      '@types/node':
+        specifier: 26.6.4
+        version: 26.6.4
+      '@vitest/coverage-v8':
+        specifier: 5.0.3
+        version: 5.0.3(vitest@5.0.3)
+      eslint:
+        specifier: 10.12.0
+        version: 10.12.0(jiti@2.7.0)(supports-color@7.2.0)
+      publint:
+        specifier: 0.3.25
+        version: 0.3.25
+      typescript:
+        specifier: 6.0.3
+        version: 6.0.3
+      vitest:
+        specifier: 5.0.3
+        version: 5.0.3(@types/node@26.6.4)(@vitest/coverage-v8@5.0.3)(vite@8.3.2(@types/node@26.6.4)(jiti@2.7.0)(yaml@2.9.1))
+
   packages/targets/process-graph:
     dependencies:
+      '@exadev/process-graph-cli':
+        specifier: 0.0.0
+        version: link:../graph-cli
       '@exadev/process-graph-dag':
         specifier: 1.0.2
         version: link:../../core/graph/dag
diff --git a/tsconfig.build.json b/tsconfig.build.json
index 9c492a3..9da5bd8 100644
--- a/tsconfig.build.json
+++ b/tsconfig.build.json
@@ -31,6 +31,9 @@
     {
       "path": "packages/adapters/graph/sqlite-node/tsconfig.build.json"
     },
+    {
+      "path": "packages/targets/graph-cli/tsconfig.build.json"
+    },
     {
       "path": "packages/targets/process-graph/tsconfig.build.json"
     }