diff --git a/README.md b/README.md
index adcaf34..ebafd7e 100644
--- a/README.md
+++ b/README.md
@@ -8,16 +8,16 @@
 # Triplex
 
 > [!WARNING]
-> Triplex is pre-1.0 and currently published only as canaries under the npm `next` tag. It requires
-> the Effect v4 release candidate `effect@4.0.0-rc.112`; Effect 3 is not compatible. KV and SQLite
-> are the supported baseline, PostgreSQL is a production candidate, and Cloudflare and FoundationDB
-> are experimental. See [Current state](docs/current-state.md) for the exact maturity contract.
+> Triplex is pre-1.0. The new `@triplex-build` packages are not yet published; use a source checkout
+> for evaluation. The current tree requires `effect@4.0.0-rc.112`; Effect 3 is not compatible. KV
+> and SQLite are the supported baseline, PostgreSQL is a production candidate, and Cloudflare and
+> FoundationDB are experimental. See [Current state](docs/current-state.md) for the exact maturity
+> contract.
 
 An Effect-native fact database for applications that have to explain themselves.
 
 [Documentation](https://triplex.build) ·
 [GitHub](https://github.com/bjacobso/triplex) ·
-[npm](https://www.npmjs.com/package/@triplex-build/triplex) ·
 [Security](SECURITY.md)
 
 Triplex stores what is true, what was true, which versioned rules governed each write, and what
@@ -65,19 +65,24 @@ causal record of every change.
 **Not a fit:** high-volume telemetry, blob storage, or workloads that only need a relational table
 and never ask about history or provenance. Triplex is a system of record, not a cache or a queue.
 
-## Installation
+## Installation and evaluation
 
-Install the current canary explicitly:
+As of September 10, 2026, npm returns `404` for the new `@triplex-build` package family. Run the
+checked examples from a source checkout until the first release gates are complete:
 
 ```sh
-pnpm add @triplex-build/triplex@next effect@4.0.0-rc.112
+git clone https://github.com/bjacobso/triplex.git
+cd triplex
+corepack enable
+pnpm install --frozen-lockfile
+pnpm exec tsx --tsconfig docs/snippets/tsconfig.json docs/snippets/getting-started.ts
 ```
 
-Use `@next` until the reviewed stable `0.1.0` release: npm assigned the initial bootstrap snapshot
-to `latest` when the package records were created. Triplex is ESM-only, targets Node.js 22+, and is
-aligned to `effect@4.0.0-rc.112`. The browser-safe core also runs in modern browsers and edge
-runtimes. The coordinated package and canary process is documented in
-[Releasing Triplex](docs/releasing.md).
+Do not use the superseded `@bjacobso` canaries for new work. Triplex is ESM-only, targets Node.js
+22+, and is aligned to `effect@4.0.0-rc.112`. The browser-safe core also runs in modern browsers and
+edge runtimes. The [website quickstart](docs/getting-started.md) includes expected output, Effect
+layer lifetime, and SQLite persistence. The coordinated package publication process is documented
+in [Releasing Triplex](docs/releasing.md).
 
 ## Quick start
 
@@ -151,7 +156,9 @@ of scattering unchecked string casts through domain code. Raw Datalog keeps stri
 one term can represent an entity, attribute, transaction, rule, or scalar value; its runtime schema
 validates identity positions before execution.
 
-Run `pnpm example:demo` for the smallest executable example.
+Run
+`pnpm exec tsx --tsconfig docs/snippets/tsconfig.json examples/demo/demo.ts`
+for the smallest executable example from a fresh source checkout.
 
 ## Integrating Triplex into an application
 
@@ -391,10 +398,12 @@ typed CLI modules. It is JSON-first, non-interactive, schema-validates external
 SQLite, PostgreSQL, and database-scoped PostgreSQL:
 
 ```sh
-pnpm --silent triplex --sqlite ./app.db describe
-pnpm --silent triplex --sqlite ./app.db entity types
-pnpm --silent triplex --sqlite ./app.db --pretty config object form quiz/bitemporal-facts
-pnpm --silent triplex --sqlite ./app.db query run --input query.json
+pnpm turbo run build --filter=@triplex-build/triplex-cli...
+triplex() { node --disable-warning=ExperimentalWarning packages/cli/dist/cli.js "$@"; }
+triplex --sqlite ./app.db describe
+triplex --sqlite ./app.db entity types
+triplex --sqlite ./app.db --pretty config object form quiz/bitemporal-facts
+triplex --sqlite ./app.db query run --input query.json
 ```
 
 Agents can inspect entity types and bitemporal facts, page entity audit history, run or explain raw
@@ -552,17 +561,23 @@ for Triplex adapter packages. Public exports resolve only to built `dist` files.
 
 ## Documentation
 
-| Document                                                 | Purpose                                             |
-| -------------------------------------------------------- | --------------------------------------------------- |
-| [Current state](docs/current-state.md)                   | Delivered behavior, maturity, limitations, releases |
-| [Datalog](docs/datalog.md)                               | Query syntax and backend-independent semantics      |
-| [Configuration](docs/configuration.md)                   | Types, releases, refs, validation, and proofs       |
-| [Derivations](docs/derivations.md)                       | Candidates, provenance, materialization, overlays   |
-| [Operational primitives](docs/operational-primitives.md) | Transactions, journal, concurrency, projections     |
-| [Architecture](ARCHITECTURE.md)                          | Package boundaries and dependency direction         |
-| [Roadmap](docs/roadmap.md)                               | Release gates and future work                       |
-| [Host integration](docs/host-integration.md)             | Runtime composition and data-migration guidance     |
-| [Source provenance](docs/provenance.md)                  | Imported repository history                         |
+| Document                                                      | Purpose                                               |
+| ------------------------------------------------------------- | ----------------------------------------------------- |
+| [Getting started](docs/getting-started.md)                    | First runnable program, output, and persistence       |
+| [Playground](docs/playground.md)                              | Local in-browser database with selectable domains     |
+| [Core concepts](docs/concepts.md)                             | Facts, time, configuration, derivation, and ownership |
+| [Configuration walkthrough](docs/configuration-versioning.md) | Publish, promote, pin, inspect, and roll back config  |
+| [CLI and dashboard](docs/tools.md)                            | Operate and explore a source-checkout database        |
+| [Troubleshooting](docs/troubleshooting.md)                    | Common failures and surprising semantics              |
+| [Current state](docs/current-state.md)                        | Delivered behavior, maturity, limitations, releases   |
+| [Datalog](docs/datalog.md)                                    | Query syntax and backend-independent semantics        |
+| [Configuration reference](docs/configuration.md)              | Types, releases, refs, validation, and proofs         |
+| [Derivations](docs/derivations.md)                            | Candidates, provenance, materialization, overlays     |
+| [Operational primitives](docs/operational-primitives.md)      | Transactions, journal, concurrency, projections       |
+| [Host integration](docs/host-integration.md)                  | Runtime composition and data-migration guidance       |
+| [Architecture](ARCHITECTURE.md)                               | Package boundaries and dependency direction           |
+| [Roadmap](docs/roadmap.md)                                    | Release gates and future work                         |
+| [Source provenance](docs/provenance.md)                       | Imported repository history                           |
 
 The focused configuration explorer remains under [`examples/config-explorer`](examples/config-explorer),
 and the full database dashboard lives under [`packages/dashboard`](packages/dashboard).
diff --git a/docs/.vitepress/config.ts b/docs/.vitepress/config.ts
index 718a501..dcd169e 100644
--- a/docs/.vitepress/config.ts
+++ b/docs/.vitepress/config.ts
@@ -12,6 +12,16 @@ export default defineConfig({
   cleanUrls: true,
   lastUpdated: true,
   outDir: resolve(import.meta.dirname, "../../dist"),
+  vite: {
+    resolve: {
+      alias: [
+        {
+          find: /^@triplex-build\/triplex$/,
+          replacement: resolve(import.meta.dirname, "../../packages/core/src/index.ts"),
+        },
+      ],
+    },
+  },
   head: [
     ["link", { rel: "icon", type: "image/svg+xml", href: "/mark.svg" }],
     ["meta", { name: "theme-color", content: "#0b1020" }],
@@ -51,41 +61,65 @@ export default defineConfig({
     logo: { src: "/mark.svg", alt: "Triplex" },
     siteTitle: "Triplex",
     nav: [
-      { text: "Current state", link: "/current-state" },
-      { text: "Datalog", link: "/datalog" },
-      { text: "Configuration", link: "/configuration" },
+      { text: "Get started", link: "/getting-started" },
+      { text: "Playground", link: "/playground" },
+      { text: "Concepts", link: "/concepts" },
+      {
+        text: "Reference",
+        items: [
+          { text: "Datalog", link: "/datalog" },
+          { text: "Configuration", link: "/configuration" },
+          { text: "Operational primitives", link: "/operational-primitives" },
+          { text: "HTTP API", link: "/http-api" },
+        ],
+      },
+      { text: "Operate", link: "/tools" },
     ],
     sidebar: [
       {
         text: "Start",
         items: [
+          { text: "Getting started", link: "/getting-started" },
+          { text: "Playground", link: "/playground" },
+          { text: "Core concepts", link: "/concepts" },
           { text: "Current state", link: "/current-state" },
-          {
-            text: "Architecture",
-            link: "https://github.com/bjacobso/triplex/blob/main/ARCHITECTURE.md",
-          },
         ],
       },
       {
-        text: "Core",
+        text: "Learn",
         items: [
           { text: "Datalog", link: "/datalog" },
-          { text: "Configuration", link: "/configuration" },
+          { text: "Configuration walkthrough", link: "/configuration-versioning" },
           { text: "Derivations", link: "/derivations" },
           { text: "Provenance", link: "/provenance" },
         ],
       },
       {
-        text: "Operate",
+        text: "Reference",
         items: [
+          { text: "Configuration", link: "/configuration" },
           { text: "Operational primitives", link: "/operational-primitives" },
-          { text: "Host integration", link: "/host-integration" },
           { text: "Configuration HTTP API", link: "/http-api" },
           { text: "Performance", link: "/performance" },
+          {
+            text: "Architecture",
+            link: "https://github.com/bjacobso/triplex/blob/main/ARCHITECTURE.md",
+          },
+        ],
+      },
+      {
+        text: "Operate",
+        items: [
+          { text: "CLI and dashboard", link: "/tools" },
+          { text: "Host integration", link: "/host-integration" },
+          { text: "Troubleshooting and FAQ", link: "/troubleshooting" },
           { text: "Releasing", link: "/releasing" },
-          { text: "Roadmap", link: "/roadmap" },
         ],
       },
+      {
+        text: "Project",
+        items: [{ text: "Roadmap", link: "/roadmap" }],
+      },
     ],
     search: {
       provider: "local",
diff --git a/docs/.vitepress/theme/Playground.vue b/docs/.vitepress/theme/Playground.vue
new file mode 100644
index 0000000..8b6e492
--- /dev/null
+++ b/docs/.vitepress/theme/Playground.vue
@@ -0,0 +1,1085 @@
+<script setup lang="ts">
+import { computed, onBeforeUnmount, onMounted, ref } from "vue";
+import { Effect, ManagedRuntime, Option, Schema } from "effect";
+import {
+  DatalogQuery,
+  EntityId,
+  KvTriples,
+  TransactRequest,
+  Triples,
+  ref as reference,
+  string,
+  type TransactionRecord,
+  type Triple,
+  type TripleId,
+} from "@triplex-build/triplex";
+
+type Runtime = ManagedRuntime.ManagedRuntime<Triples, never>;
+
+interface Domain {
+  readonly label: string;
+  readonly description: string;
+  readonly question: string;
+  readonly action: string;
+  readonly explanation: string;
+  readonly empty: string;
+  readonly focusEntity: string;
+  readonly operations: ReadonlyArray<(typeof TransactRequest.Type)["operations"][number]>;
+  readonly query: object;
+  readonly transaction: object;
+}
+
+const domains: Record<string, Domain> = {
+  learning: {
+    label: "Learning",
+    description: "Mina submitted a quiz. Give it a score and watch it leave the grading queue.",
+    question: "Which submissions need grading?",
+    action: "Grade Mina’s quiz",
+    explanation:
+      "Adding a score makes this submission stop matching the query. The submission stays in the database.",
+    empty: "No submissions need grading. The query finds submitted work without a score.",
+    focusEntity: "submission:mina-temporal-data",
+    operations: [
+      {
+        op: "assert",
+        entityId: EntityId.make("student:mina"),
+        entityType: "Student",
+        attribute: ":person/name",
+        value: string("Mina Patel"),
+      },
+      {
+        op: "assert",
+        entityId: EntityId.make("quiz:temporal-data"),
+        entityType: "Quiz",
+        attribute: ":quiz/title",
+        value: string("Temporal data"),
+      },
+      {
+        op: "assert",
+        entityId: EntityId.make("submission:mina-temporal-data"),
+        entityType: "Submission",
+        attribute: ":submission/student",
+        value: reference(EntityId.make("student:mina")),
+      },
+      {
+        op: "assert",
+        entityId: EntityId.make("submission:mina-temporal-data"),
+        entityType: "Submission",
+        attribute: ":submission/quiz",
+        value: reference(EntityId.make("quiz:temporal-data")),
+      },
+      {
+        op: "assert",
+        entityId: EntityId.make("submission:mina-temporal-data"),
+        entityType: "Submission",
+        attribute: ":submission/status",
+        value: string("submitted"),
+      },
+    ],
+    query: {
+      find: ["?submission", "?studentName", "?quizTitle"],
+      where: [
+        ["?submission", ":submission/status", "submitted"],
+        ["?submission", ":submission/student", "?student"],
+        ["?student", ":person/name", "?studentName"],
+        ["?submission", ":submission/quiz", "?quiz"],
+        ["?quiz", ":quiz/title", "?quizTitle"],
+        ["not", ["?submission", ":submission/score", "?score"]],
+      ],
+      orderBy: [{ variable: "?submission", direction: "asc" }],
+    },
+    transaction: {
+      operations: [
+        {
+          op: "assert",
+          entityId: "submission:mina-temporal-data",
+          entityType: "Submission",
+          attribute: ":submission/score",
+          value: { type: "number", value: 92 },
+        },
+      ],
+      meta: {
+        actor: "user:playground",
+        commandId: "playground/grade-mina/v1",
+      },
+    },
+  },
+  compliance: {
+    label: "Site compliance",
+    description:
+      "Maria is assigned to Harbor. Record her safety training and watch the outstanding requirement clear.",
+    question: "Who still needs safety training?",
+    action: "Record Maria’s training",
+    explanation:
+      "Linking a training record to Maria and Harbor satisfies this query’s missing-training check.",
+    empty:
+      "No placements are missing training. The query checks for training that matches both worker and site.",
+    focusEntity: "training:maria-harbor",
+    operations: [
+      {
+        op: "assert",
+        entityId: EntityId.make("worker:maria"),
+        entityType: "Worker",
+        attribute: ":worker/name",
+        value: string("Maria"),
+      },
+      {
+        op: "assert",
+        entityId: EntityId.make("site:harbor"),
+        entityType: "Site",
+        attribute: ":site/name",
+        value: string("Harbor"),
+      },
+      {
+        op: "assert",
+        entityId: EntityId.make("placement:maria-harbor"),
+        entityType: "Placement",
+        attribute: ":placement/worker",
+        value: reference(EntityId.make("worker:maria")),
+      },
+      {
+        op: "assert",
+        entityId: EntityId.make("placement:maria-harbor"),
+        entityType: "Placement",
+        attribute: ":placement/site",
+        value: reference(EntityId.make("site:harbor")),
+      },
+    ],
+    query: {
+      find: ["?worker", "?workerName", "?site"],
+      where: [
+        ["?placement", ":placement/worker", "?worker"],
+        ["?placement", ":placement/site", "?site"],
+        ["?worker", ":worker/name", "?workerName"],
+        [
+          "not",
+          ["?training", ":training/worker", "?worker"],
+          ["?training", ":training/site", "?site"],
+        ],
+      ],
+      orderBy: [{ variable: "?worker", direction: "asc" }],
+    },
+    transaction: {
+      operations: [
+        {
+          op: "assert",
+          entityId: "training:maria-harbor",
+          entityType: "Training",
+          attribute: ":training/worker",
+          value: { type: "ref", value: "worker:maria" },
+        },
+        {
+          op: "assert",
+          entityId: "training:maria-harbor",
+          entityType: "Training",
+          attribute: ":training/site",
+          value: { type: "ref", value: "site:harbor" },
+        },
+      ],
+      meta: {
+        actor: "user:playground",
+        commandId: "playground/train-maria/v1",
+      },
+    },
+  },
+  blank: {
+    label: "Blank database",
+    description: "Start with no facts and use the transaction editor to create your own domain.",
+    question: "Which example names are stored?",
+    action: "Add your first fact",
+    explanation: "Create a named example entity. Its name will appear in the query results.",
+    empty: "No example names yet. Add your first fact to see a result here.",
+    focusEntity: "example:first",
+    operations: [],
+    query: {
+      find: ["?entity", "?name"],
+      where: [["?entity", ":example/name", "?name"]],
+      orderBy: [{ variable: "?entity", direction: "asc" }],
+    },
+    transaction: {
+      operations: [
+        {
+          op: "assert",
+          entityId: "example:first",
+          entityType: "Example",
+          attribute: ":example/name",
+          value: { type: "string", value: "My first fact" },
+        },
+      ],
+      meta: {
+        actor: "user:playground",
+        commandId: "playground/create-example/v1",
+      },
+    },
+  },
+};
+
+const selectedDomain = ref("learning");
+const queryText = ref("");
+const transactionText = ref("");
+const queryOutput = ref("Run the sample query to see actual bindings.");
+const queryRows = ref<ReadonlyArray<Record<string, unknown>>>([]);
+const queryColumns = ref<readonly string[]>([]);
+const querySucceeded = ref(false);
+const hasMoreResults = ref(false);
+const lastQueryIsSample = ref(true);
+const guidedIds = ref<readonly TripleId[]>([]);
+const score = ref(92);
+const exampleName = ref("My first fact");
+const changeMessage = ref("");
+const transactionOutput = ref("");
+const facts = ref<readonly Triple[]>([]);
+const transactions = ref<readonly TransactionRecord[]>([]);
+const selectedEntity = ref("");
+const busy = ref(false);
+const error = ref("");
+let runtime: Runtime | undefined;
+let runtimeSequence = 0;
+
+const currentDomain = computed(() => domains[selectedDomain.value] ?? domains["learning"]!);
+const activeGuidedIds = computed(() =>
+  guidedIds.value.filter((id) => facts.value.some((fact) => fact.id === id)),
+);
+const displayValue = (value: unknown): string =>
+  typeof value === "string" ? value : (JSON.stringify(value) ?? "—");
+const columnLabel = (column: string): string =>
+  column.replace(/^\?/, "").replace(/([a-z])([A-Z])/g, "$1 $2");
+const entityIds = computed(() => [...new Set(facts.value.map((fact) => fact.entityId))].sort());
+const entityFacts = computed(() =>
+  facts.value
+    .filter((fact) => fact.entityId === selectedEntity.value)
+    .map((fact) => ({
+      id: fact.id,
+      attribute: fact.attribute,
+      value: fact.value,
+      type: Option.getOrNull(fact.entityType),
+      validFrom: fact.validFrom,
+      validTo: Option.getOrNull(fact.validTo),
+    })),
+);
+
+const formatError = (cause: unknown): string =>
+  cause instanceof Error ? cause.message : String(cause);
+
+const refresh = async () => {
+  if (runtime === undefined) return;
+  const state = await runtime.runPromise(
+    Effect.gen(function* () {
+      const triples = yield* Triples;
+      const allFacts = yield* triples.match({});
+      const journal = yield* triples.transactions({ after: 0, limit: 50 });
+      return {
+        allFacts: allFacts.filter((fact) => !fact.entityId.startsWith("_")),
+        journal: journal.transactions,
+      };
+    }),
+  );
+  facts.value = state.allFacts;
+  transactions.value = state.journal;
+  if (!entityIds.value.some((entityId) => entityId === selectedEntity.value)) {
+    selectedEntity.value = entityIds.value[0] ?? "";
+  }
+};
+
+const executeQuery = async () => {
+  if (runtime === undefined) return;
+  const source = JSON.parse(queryText.value) as unknown;
+  const query = await Effect.runPromise(Schema.decodeUnknownEffect(DatalogQuery)(source));
+  const result = await runtime.runPromise(
+    Effect.gen(function* () {
+      const triples = yield* Triples;
+      return yield* triples.query(query, { pageSize: 100, debug: true });
+    }),
+  );
+  queryRows.value = result.results;
+  queryColumns.value = [...new Set(result.results.flatMap((row) => Object.keys(row)))];
+  querySucceeded.value = true;
+  hasMoreResults.value = Boolean(result.nextCursor);
+  lastQueryIsSample.value = JSON.stringify(source) === JSON.stringify(currentDomain.value.query);
+  queryOutput.value = JSON.stringify(
+    {
+      results: result.results,
+      nextCursor: result.nextCursor ?? null,
+      metrics: result.debug?.metrics ?? null,
+    },
+    null,
+    2,
+  );
+};
+
+const runQuery = async () => {
+  busy.value = true;
+  error.value = "";
+  try {
+    await executeQuery();
+  } catch (cause) {
+    error.value = formatError(cause);
+    querySucceeded.value = false;
+    queryOutput.value = "Query failed. Fix the JSON or query and try again.";
+  } finally {
+    busy.value = false;
+  }
+};
+
+const applyTransaction = async (sourceText = transactionText.value, guided = false) => {
+  if (runtime === undefined) return;
+  busy.value = true;
+  error.value = "";
+  let committed = false;
+  try {
+    const source = JSON.parse(sourceText) as unknown;
+    const request = await Effect.runPromise(Schema.decodeUnknownEffect(TransactRequest)(source));
+    const meta = request.meta;
+    const actor = meta?.actor;
+    const commandId = meta?.commandId;
+    const correlationId = meta?.correlationId;
+    const causationId = meta?.causationId;
+    const configSnapshot = meta?.configSnapshot;
+    const enforce = meta?.enforce;
+    const preconditions = meta?.preconditions;
+    if (actor === undefined || commandId === undefined) {
+      throw new Error("Playground transactions require meta.actor and meta.commandId.");
+    }
+    const result = await runtime.runPromise(
+      Effect.gen(function* () {
+        const triples = yield* Triples;
+        return yield* triples.transact(request.operations, {
+          actor,
+          commandId,
+          ...(correlationId === undefined ? {} : { correlationId }),
+          ...(causationId === undefined ? {} : { causationId }),
+          ...(configSnapshot === undefined ? {} : { configSnapshot }),
+          ...(enforce === undefined ? {} : { enforce }),
+          ...(preconditions === undefined ? {} : { preconditions }),
+        });
+      }),
+    );
+    committed = true;
+    if (guided) guidedIds.value = result.triples.map((fact) => fact.id);
+    changeMessage.value = `Commit #${result.position}: ${result.triples.length} fact${result.triples.length === 1 ? "" : "s"} added, ${result.retracted} retracted.`;
+    transactionOutput.value = JSON.stringify(
+      {
+        transactionId: result.txId,
+        position: result.position,
+        asserted: result.triples.length,
+        retracted: result.retracted,
+      },
+      null,
+      2,
+    );
+    await refresh();
+    if (guided) selectedEntity.value = currentDomain.value.focusEntity;
+    await runQuery();
+  } catch (cause) {
+    error.value = committed
+      ? `The write committed, but refreshing the view failed: ${formatError(cause)}`
+      : formatError(cause);
+    if (!committed) transactionOutput.value = "Transaction failed; no partial write was applied.";
+  } finally {
+    busy.value = false;
+  }
+};
+
+const applyGuidedChange = async () => {
+  const request = JSON.parse(JSON.stringify(currentDomain.value.transaction));
+  request.meta.commandId = `playground/guided/${crypto.randomUUID()}`;
+  if (selectedDomain.value === "learning") request.operations[0].value.value = score.value;
+  if (selectedDomain.value === "blank") request.operations[0].value.value = exampleName.value;
+  transactionText.value = JSON.stringify(request, null, 2);
+  await applyTransaction(transactionText.value, true);
+};
+
+const retractGuidedChange = async () => {
+  const request = {
+    operations: activeGuidedIds.value.map((id) => ({ op: "retract", id })),
+    meta: { actor: "user:playground", commandId: `playground/retract/${crypto.randomUUID()}` },
+  };
+  transactionText.value = JSON.stringify(request, null, 2);
+  await applyTransaction();
+};
+
+const restoreQuery = async () => {
+  queryText.value = JSON.stringify(currentDomain.value.query, null, 2);
+  await runQuery();
+};
+
+const reset = async () => {
+  busy.value = true;
+  error.value = "";
+  transactionOutput.value = "";
+  changeMessage.value = "";
+  guidedIds.value = [];
+  queryRows.value = [];
+  querySucceeded.value = false;
+  queryOutput.value = "Run the sample query to see actual bindings.";
+  try {
+    await runtime?.dispose();
+    runtimeSequence += 1;
+    runtime = ManagedRuntime.make(
+      KvTriples.layerWithScope(`docs-playground-${runtimeSequence}-${selectedDomain.value}`),
+    );
+    const domain = currentDomain.value;
+    queryText.value = JSON.stringify(domain.query, null, 2);
+    transactionText.value = JSON.stringify(domain.transaction, null, 2);
+    if (domain.operations.length > 0) {
+      await runtime.runPromise(
+        Effect.gen(function* () {
+          const triples = yield* Triples;
+          yield* triples.transact(domain.operations, {
+            actor: "triplex/docs-playground",
+            commandId: `playground/seed/${selectedDomain.value}/v1`,
+          });
+        }),
+      );
+    }
+    await refresh();
+    if (entityIds.value.some((id) => id === domain.focusEntity))
+      selectedEntity.value = domain.focusEntity;
+    await executeQuery();
+  } catch (cause) {
+    error.value = formatError(cause);
+  } finally {
+    busy.value = false;
+  }
+};
+
+const chooseDomain = async () => reset();
+
+onMounted(reset);
+onBeforeUnmount(() => {
+  void runtime?.dispose();
+  runtime = undefined;
+});
+</script>
+
+<template>
+  <section class="playground" aria-label="Triplex in-memory playground">
+    <header class="playground__header">
+      <div>
+        <p class="playground__eyebrow">Your own live database</p>
+        <h2>Small change. Live result.</h2>
+        <p>{{ currentDomain.description }}</p>
+      </div>
+      <div class="playground__controls">
+        <label for="playground-domain">Domain</label>
+        <select
+          id="playground-domain"
+          v-model="selectedDomain"
+          :disabled="busy"
+          @change="chooseDomain"
+        >
+          <option v-for="(domain, key) in domains" :key="key" :value="key">
+            {{ domain.label }}
+          </option>
+        </select>
+        <button type="button" :disabled="busy" @click="reset">Reset database</button>
+      </div>
+    </header>
+
+    <p class="playground__notice">
+      Runs in your browser · No setup · Resets when you reload, leave, or change domain
+    </p>
+    <p v-if="error" class="playground__error" role="alert">{{ error }}</p>
+
+    <div class="playground__grid playground__experiment">
+      <article class="playground__panel">
+        <div class="playground__panel-heading">
+          <div>
+            <p class="playground__eyebrow">1 · Ask the database</p>
+            <h3>{{ lastQueryIsSample ? currentDomain.question : "Your query results" }}</h3>
+          </div>
+        </div>
+        <div class="playground__results" aria-live="polite" aria-label="Query results">
+          <template v-if="querySucceeded">
+            <p class="playground__result-count">
+              <strong>{{ queryRows.length }}</strong>
+              {{ queryRows.length === 1 ? "match" : "matches" }}
+            </p>
+            <div v-if="queryRows.length" class="playground__table-scroll">
+              <table>
+                <thead>
+                  <tr>
+                    <th v-for="column in queryColumns" :key="column">{{ columnLabel(column) }}</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  <tr v-for="(row, index) in queryRows" :key="index">
+                    <td v-for="column in queryColumns" :key="column">
+                      {{ displayValue(row[column]) }}
+                    </td>
+                  </tr>
+                </tbody>
+              </table>
+            </div>
+            <p v-else class="playground__empty">
+              {{
+                lastQueryIsSample
+                  ? currentDomain.empty
+                  : "No matches. Check the attributes, values, and joins in your query."
+              }}
+            </p>
+            <p v-if="hasMoreResults" class="playground__hint">
+              Showing the first 100 rows. The raw response includes a cursor for the next page.
+            </p>
+          </template>
+          <p v-else>
+            {{
+              busy
+                ? "Reading the database…"
+                : "Query failed. Check the error above and edit the query below."
+            }}
+          </p>
+        </div>
+        <p class="playground__hint">
+          This query runs on load and after every write. Open the editors below to change what it
+          asks.
+        </p>
+      </article>
+
+      <article class="playground__panel playground__action">
+        <div class="playground__panel-heading">
+          <div>
+            <p class="playground__eyebrow">2 · Change a fact</p>
+            <h3>{{ currentDomain.action }}</h3>
+          </div>
+        </div>
+        <p>{{ currentDomain.explanation }}</p>
+        <div v-if="selectedDomain === 'learning'" class="playground__field">
+          <label for="playground-score">Quiz score</label>
+          <input
+            id="playground-score"
+            v-model.number="score"
+            type="number"
+            min="0"
+            max="100"
+            :disabled="busy || activeGuidedIds.length > 0"
+          />
+          <span>out of 100</span>
+        </div>
+        <div v-if="selectedDomain === 'blank'" class="playground__field">
+          <label for="playground-name">Example name</label>
+          <input
+            id="playground-name"
+            v-model="exampleName"
+            :disabled="busy || activeGuidedIds.length > 0"
+          />
+        </div>
+        <button
+          v-if="activeGuidedIds.length === 0"
+          class="playground__primary"
+          type="button"
+          :disabled="
+            busy ||
+            (selectedDomain === 'learning' &&
+              (!Number.isFinite(score) || score < 0 || score > 100)) ||
+            (selectedDomain === 'blank' && !exampleName.trim())
+          "
+          @click="applyGuidedChange"
+        >
+          {{ currentDomain.action }}
+        </button>
+        <template v-else>
+          <p class="playground__success">
+            Fact added. Check the query result, then try reversing the change.
+          </p>
+          <button type="button" :disabled="busy" @click="retractGuidedChange">
+            Retract this change
+          </button>
+          <p class="playground__hint">
+            Retraction removes the new fact from current reads. Both commits remain in the journal.
+          </p>
+        </template>
+      </article>
+    </div>
+    <p v-if="changeMessage" class="playground__change" role="status">{{ changeMessage }}</p>
+
+    <div class="playground__grid playground__grid--inspect">
+      <article class="playground__panel">
+        <div class="playground__panel-heading">
+          <div>
+            <p class="playground__eyebrow">3 · See what changed</p>
+            <h3>Facts in the database</h3>
+          </div>
+          <span>{{ facts.length }} visible facts</span>
+        </div>
+        <label for="playground-entity">Entity</label>
+        <select id="playground-entity" v-model="selectedEntity">
+          <option v-if="entityIds.length === 0" value="">No entities yet</option>
+          <option v-for="entityId in entityIds" :key="entityId" :value="entityId">
+            {{ entityId }}
+          </option>
+        </select>
+        <div v-if="entityFacts.length" class="playground__table-scroll">
+          <table>
+            <thead>
+              <tr>
+                <th>Attribute</th>
+                <th>Value</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="(fact, index) in entityFacts" :key="index">
+                <td>
+                  <code>{{ fact.attribute }}</code>
+                </td>
+                <td>
+                  {{ displayValue(fact.value.value) }}
+                  <span v-if="fact.value.type === 'ref'" class="playground__ref-label"
+                    >relationship</span
+                  >
+                </td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+        <p v-else class="playground__hint">Add a fact to create your first entity.</p>
+        <details v-if="entityFacts.length">
+          <summary>Raw facts and valid time</summary>
+          <pre>{{ JSON.stringify(entityFacts, null, 2) }}</pre>
+        </details>
+      </article>
+
+      <article class="playground__panel">
+        <div class="playground__panel-heading">
+          <div>
+            <p class="playground__eyebrow">Every write leaves a record</p>
+            <h3>Transaction journal</h3>
+          </div>
+          <span
+            >{{ transactions.length }} {{ transactions.length === 1 ? "commit" : "commits" }}</span
+          >
+        </div>
+        <ol v-if="transactions.length > 0" class="playground__journal">
+          <li v-for="transaction in [...transactions].reverse()" :key="transaction.txId">
+            <strong>#{{ transaction.position }}</strong>
+            <div>
+              <span>{{
+                transaction.commandId?.startsWith("playground/seed/")
+                  ? "Loaded the sample domain"
+                  : `${transaction.changes.length} ${transaction.changes.length === 1 ? "change" : "changes"} by ${transaction.actor || "unattributed"}`
+              }}</span>
+              <details>
+                <summary>Commit details</summary>
+                <pre>{{ JSON.stringify(transaction, null, 2) }}</pre>
+              </details>
+            </div>
+          </li>
+        </ol>
+        <p v-else>No transactions yet.</p>
+        <p class="playground__hint">
+          Most recent first · Up to the first 50 commits in this session
+        </p>
+      </article>
+    </div>
+
+    <details class="playground__editors">
+      <summary>
+        Go further: edit queries and transactions <span>Public Triplex JSON APIs</span>
+      </summary>
+      <p>
+        Change the query to explore other relationships, or write your own transaction. Each new
+        transaction needs a unique <code>meta.commandId</code>. Guided actions fill in the
+        transaction editor for you.
+      </p>
+      <div class="playground__grid">
+        <article class="playground__panel">
+          <div class="playground__panel-heading">
+            <h3>Datalog query</h3>
+            <button type="button" :disabled="busy" @click="runQuery">Run query</button>
+          </div>
+          <p class="playground__hint">
+            <code>find</code> selects result columns. <code>where</code> matches facts and joins
+            shared variables; <code>not</code> checks for missing facts.
+          </p>
+          <label class="playground__sr-only" for="playground-query">Datalog query JSON</label>
+          <textarea
+            id="playground-query"
+            v-model="queryText"
+            rows="16"
+            spellcheck="false"
+            :disabled="busy"
+          />
+          <button type="button" :disabled="busy" @click="restoreQuery">Restore sample query</button>
+          <details>
+            <summary>Raw query response and metrics</summary>
+            <pre>{{ queryOutput }}</pre>
+          </details>
+        </article>
+        <article class="playground__panel">
+          <div class="playground__panel-heading">
+            <h3>Atomic transaction</h3>
+            <button type="button" :disabled="busy" @click="applyTransaction()">
+              Apply transaction
+            </button>
+          </div>
+          <p class="playground__hint">
+            An <code>assert</code> adds a fact. A <code>retract</code> uses an existing fact’s ID.
+            Operations in one transaction commit together.
+          </p>
+          <label class="playground__sr-only" for="playground-transaction">Transaction JSON</label>
+          <textarea
+            id="playground-transaction"
+            v-model="transactionText"
+            rows="16"
+            spellcheck="false"
+            :disabled="busy"
+          />
+          <details>
+            <summary>Raw transaction receipt</summary>
+            <pre>{{ transactionOutput || "No transaction applied yet." }}</pre>
+          </details>
+        </article>
+      </div>
+    </details>
+  </section>
+</template>
+
+<style scoped>
+.playground {
+  margin-top: 28px;
+}
+
+.playground__header,
+.playground__panel-heading {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 20px;
+}
+
+.playground__header h2,
+.playground__panel h3,
+.playground__panel h4 {
+  margin: 0;
+  padding: 0;
+  border: 0;
+}
+
+.playground__header p {
+  max-width: 680px;
+  margin: 8px 0 0;
+}
+
+.playground__eyebrow {
+  margin: 0 0 6px !important;
+  color: var(--vp-c-brand-1) !important;
+  font-family: var(--vp-font-family-mono);
+  font-size: 0.72rem;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+.playground__controls {
+  display: grid;
+  grid-template-columns: auto auto;
+  gap: 6px 10px;
+  flex: none;
+}
+
+.playground__controls button {
+  grid-column: 1 / -1;
+}
+
+.playground__notice,
+.playground__error {
+  margin: 22px 0;
+  border: 1px solid var(--vp-c-divider);
+  border-radius: 7px;
+  background: var(--vp-c-bg-alt);
+  padding: 12px 14px;
+  font-size: 0.9rem;
+}
+
+.playground__notice {
+  padding: 0;
+  border: 0;
+  background: transparent;
+  color: var(--vp-c-text-2);
+  font-size: 0.82rem;
+}
+
+.playground__experiment {
+  grid-template-columns: minmax(0, 1.2fr) minmax(0, 1fr);
+}
+
+.playground__action {
+  background: var(--vp-c-brand-soft) !important;
+}
+
+.playground__action p {
+  margin: 8px 0 16px;
+}
+
+.playground__hint {
+  color: var(--vp-c-text-2);
+  font-size: 0.82rem;
+  line-height: 1.6;
+}
+
+.playground__result-count {
+  margin: 0 0 12px;
+  color: var(--vp-c-text-2);
+}
+
+.playground__result-count strong {
+  font-size: 1.8rem;
+  color: var(--vp-c-text-1);
+}
+
+.playground__empty {
+  padding: 14px;
+  border: 1px dashed var(--vp-c-divider);
+  border-radius: 6px;
+  font-size: 0.9rem;
+}
+
+.playground__field {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin: 18px 0;
+  font-size: 0.9rem;
+}
+
+.playground__field input {
+  min-width: 0;
+  max-width: 100%;
+  padding: 7px 10px;
+}
+
+.playground__field input[type="number"] {
+  width: 80px;
+}
+
+.playground button.playground__primary {
+  background: var(--vp-c-brand-1);
+  color: var(--vp-c-bg);
+  border-color: transparent;
+}
+
+.playground__change,
+.playground__success {
+  color: var(--vp-c-text-1);
+  font-size: 0.88rem;
+}
+
+.playground__change {
+  padding: 12px 16px;
+  background: var(--vp-c-brand-soft);
+  border-radius: 6px;
+}
+
+.playground__table-scroll {
+  overflow-x: auto;
+  margin: 12px 0;
+}
+
+.playground table {
+  display: table;
+  width: 100%;
+  margin: 0;
+  font-size: 0.82rem;
+}
+
+.playground th,
+.playground td {
+  padding: 9px 10px;
+  text-align: left;
+  overflow-wrap: anywhere;
+}
+
+.playground td code {
+  white-space: normal;
+}
+
+.playground th {
+  text-transform: capitalize;
+}
+
+.playground__ref-label {
+  display: block;
+  color: var(--vp-c-text-2);
+  font-size: 0.7rem;
+}
+
+.playground details {
+  min-width: 0;
+  margin-top: 14px;
+}
+
+.playground summary {
+  cursor: pointer;
+  color: var(--vp-c-brand-1);
+  font-size: 0.85rem;
+  font-weight: 600;
+}
+
+.playground__editors {
+  padding: 20px;
+  border: 1px solid var(--vp-c-divider);
+  border-radius: 8px;
+}
+
+.playground__editors > summary {
+  font-size: 1rem;
+}
+
+.playground__editors > summary span {
+  display: block;
+  margin: 6px 0 0 18px;
+  color: var(--vp-c-text-2);
+  font-size: 0.8rem;
+  font-weight: 400;
+}
+
+.playground__error {
+  border-color: var(--vp-c-danger-1);
+  color: var(--vp-c-danger-1);
+}
+
+.playground__grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 20px;
+}
+
+.playground__grid--inspect {
+  margin-top: 20px;
+}
+
+.playground__panel {
+  min-width: 0;
+  border: 1px solid var(--vp-c-divider);
+  border-radius: 8px;
+  background: var(--vp-c-bg-elv);
+  padding: 18px;
+}
+
+.playground__panel-heading {
+  align-items: center;
+  margin-bottom: 14px;
+}
+
+.playground__panel-heading span {
+  color: var(--vp-c-text-2);
+  font-size: 0.82rem;
+}
+
+.playground button,
+.playground select,
+.playground input,
+.playground textarea {
+  border: 1px solid var(--vp-c-divider);
+  border-radius: 5px;
+  background: var(--vp-c-bg);
+  color: var(--vp-c-text-1);
+  font: inherit;
+}
+
+.playground button {
+  cursor: pointer;
+  padding: 7px 11px;
+  color: var(--vp-c-brand-1);
+  font-weight: 600;
+}
+
+.playground button:hover:not(:disabled) {
+  border-color: var(--vp-c-brand-1);
+}
+
+.playground button:disabled {
+  cursor: not-allowed;
+  opacity: 0.55;
+}
+
+.playground :is(button, select, input, textarea, summary):focus-visible {
+  outline: 2px solid var(--vp-c-brand-1);
+  outline-offset: 3px;
+}
+
+.playground select {
+  max-width: 100%;
+  padding: 6px 8px;
+}
+
+.playground textarea {
+  box-sizing: border-box;
+  width: 100%;
+  resize: vertical;
+  padding: 12px;
+  font-family: var(--vp-font-family-mono);
+  font-size: 0.78rem;
+  line-height: 1.55;
+}
+
+.playground pre {
+  min-height: 74px;
+  max-height: 340px;
+  margin: 10px 0 0;
+  overflow: auto;
+  border-radius: 5px;
+  padding: 12px;
+  background: var(--vp-c-bg-alt);
+  color: var(--vp-c-text-1);
+  font-size: 0.76rem;
+  line-height: 1.5;
+}
+
+.playground__journal {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.playground__journal li {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr);
+  gap: 3px 12px;
+  padding: 10px 0;
+  border-bottom: 1px solid var(--vp-c-divider);
+  font-size: 0.84rem;
+}
+
+.playground__journal li > div {
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+.playground__journal code {
+  overflow: hidden;
+  color: var(--vp-c-text-2);
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.playground__sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+
+@media (max-width: 820px) {
+  .playground__header,
+  .playground__panel-heading {
+    align-items: stretch;
+    flex-direction: column;
+  }
+
+  .playground__controls,
+  .playground__grid {
+    grid-template-columns: 1fr;
+    width: 100%;
+  }
+
+  .playground__controls button {
+    grid-column: auto;
+  }
+}
+</style>
diff --git a/docs/.vitepress/theme/index.ts b/docs/.vitepress/theme/index.ts
index 54743a5..bba4de8 100644
--- a/docs/.vitepress/theme/index.ts
+++ b/docs/.vitepress/theme/index.ts
@@ -7,6 +7,7 @@ import { h } from "vue";
 
 import "@shikijs/vitepress-twoslash/style.css";
 import "./custom.css";
+import Playground from "./Playground.vue";
 
 export default {
   extends: DefaultTheme,
@@ -14,11 +15,12 @@ export default {
     h(DefaultTheme.Layout, null, {
       "layout-top": () =>
         h("div", { class: "triplex-prerelease", role: "status" }, [
-          "Pre-1.0 canary · install with @next · requires effect@4.0.0-rc.112 · ",
+          "Pre-1.0 · new npm scope not published yet · use source checkout · ",
           h("a", { href: "/current-state" }, "current state"),
         ]),
     }),
   enhanceApp({ app }) {
+    app.component("TriplexPlayground", Playground);
     app.use(TwoslashFloatingVue, {
       themes: {
         twoslash: {
diff --git a/docs/concepts.md b/docs/concepts.md
new file mode 100644
index 0000000..b2cdcc1
--- /dev/null
+++ b/docs/concepts.md
@@ -0,0 +1,159 @@
+# Core concepts
+
+Triplex stores facts, not mutable rows. It keeps when each assertion was recorded, when it was valid
+in the domain, which configuration release governed a write, and which facts supported derived
+results. This guide uses one safety-training example to connect those ideas.
+
+## Facts and relationships
+
+Suppose worker Maria is placed at the Harbor site and has a safety certificate. Triplex represents
+that state as small typed facts:
+
+| Entity              | Attribute             | Value               |
+| ------------------- | --------------------- | ------------------- |
+| `worker:maria`      | `:worker/name`        | `"Maria"`           |
+| `placement:harbor`  | `:placement/worker`   | `ref(worker:maria)` |
+| `placement:harbor`  | `:placement/site`     | `ref(site:harbor)`  |
+| `certificate:maria` | `:certificate/worker` | `ref(worker:maria)` |
+| `certificate:maria` | `:certificate/site`   | `ref(site:harbor)`  |
+
+An entity ID groups facts for convenient entity reads. A reference value creates a relationship to
+another entity. There is no separate relationship table or hidden object graph: queries join facts
+by their values.
+
+Entity type names such as `Worker` and global attribute names such as `:worker/name` are different
+identities. Configuration can say how an entity type uses an attribute—required, single-valued,
+unique, or reference-constrained—but those rules are not automatically enforced on every write.
+
+## Assertions, retractions, and correction
+
+An assertion says that a typed fact holds over a valid-time interval. A retraction closes that
+assertion's **recorded** visibility; it does not erase the original fact or rewrite its history.
+Corrections therefore append evidence:
+
+1. retract the assertion that is no longer part of the current recorded view;
+2. assert the corrected interval or value; and
+3. do both in one attributed `Triples.transact` call.
+
+`history(entityId)` includes retracted assertions. Current `entity` and `match` reads show only
+facts visible at their requested bitemporal basis.
+
+## Recorded time and valid time
+
+The two clocks answer different questions:
+
+- **Recorded time:** what the database knew at an instant.
+- **Valid time:** when the fact was true in the domain.
+
+Imagine this certificate history:
+
+- On January 5, the host records that Maria's certificate is valid from January 1 through December 31.
+- On March 1, the host learns it was actually revoked effective February 1. In one correction
+  transaction it retracts the original assertion and records the corrected January interval.
+
+The same `validAt` date can produce a different answer as knowledge changes:
+
+| Read basis                    | Certificate visible? | Why                                          |
+| ----------------------------- | -------------------- | -------------------------------------------- |
+| recorded Feb 15, valid Feb 15 | Yes                  | The revocation was not known yet.            |
+| recorded Mar 2, valid Feb 15  | No                   | The corrected interval ended on Feb 1.       |
+| recorded Mar 2, valid Jan 15  | Yes                  | The corrected assertion still covers Jan 15. |
+
+Public reads accept one `{ recordedAt?, validAt? }` basis for the complete read, including every
+clause of a Datalog query. Times are non-negative epoch milliseconds and interval ends are
+exclusive. If `recordedAt` is omitted, Triplex uses the latest recorded state; if `validAt` is
+omitted, it uses the runtime's current time. Setting only one axis does not freeze the other.
+
+Recorded time is assigned by the Triplex transaction boundary, not supplied as application data.
+Use the journal's ordered commit positions when exact ordering matters; timestamps alone may not
+distinguish commits in the same millisecond.
+
+## Datalog asks across relationships
+
+A structural query can identify placed workers who lack a certificate for the same site:
+
+```ts
+const openTraining = {
+  find: ["?worker", "?site"],
+  where: [
+    ["?placement", ":placement/worker", "?worker"],
+    ["?placement", ":placement/site", "?site"],
+    [
+      "not",
+      ["?certificate", ":certificate/worker", "?worker"],
+      ["?certificate", ":certificate/site", "?site"],
+    ],
+  ],
+} as const;
+```
+
+Variables beginning with `?` join clauses. The `not` clause is safe because `?worker` and `?site`
+are already bound by the placement clauses. Before the corrected February basis the placement does
+not match; afterward it does. See [Datalog](/datalog) for predicates, disjunction, aggregation,
+recursion, and snapshot-stable pagination.
+
+## Configuration releases and refs
+
+Triplex configuration is a separate typed graph for schemas, forms, policies, routines, and other
+application-defined objects. A commit records the **complete** graph as an immutable release:
+
+- a `ConfigNode` has a stable logical `(kind, key)` and a content ID;
+- a revision records a version of one logical object and its dependency closure;
+- a `ConfigSnapshot` pins the full release and its revision set; and
+- a movable ref such as `test` or `live` points to one existing snapshot.
+
+Promoting or rolling back configuration means moving a ref. It does not copy nodes, mutate an old
+release, reverse operational facts, or run a data migration. Operational transactions should store
+the actual snapshot ID returned by `commit`/`resolveRef` in `meta.configSnapshot`, rather than only
+the movable ref name. Follow the [complete versioning walkthrough](/configuration-versioning).
+
+## Entity snapshots are not configuration snapshots
+
+Both use content identity, but they answer different questions:
+
+| Identity         | Represents                                             | Changes when                                      |
+| ---------------- | ------------------------------------------------------ | ------------------------------------------------- |
+| `EntitySnapshot` | one fact entity materialized at a transaction or basis | that entity's visible facts change                |
+| `ConfigSnapshot` | one immutable release of a configuration graph         | a new complete configuration release is committed |
+
+Neither replaces the transaction journal. Entity snapshots are projections whose source position
+must be checked for freshness; configuration snapshots are immutable release roots addressed by
+configuration APIs.
+
+## Derived work and provenance
+
+A derivation pins a Datalog query, candidate identity, configuration snapshot, and dependency set.
+For the query above, a candidate might mean “Maria needs Harbor training.” Triplex can retain the
+source triple IDs and assertion transactions that explain the candidate, compare one evaluation
+with another, and report `added`, `removed`, `changed`, and `unchanged` candidates.
+
+The host decides what those changes mean. Triplex does not automatically create or cancel a task,
+send a notification, retry a delivery, or assign an owner. Materialized derivations are projections
+and report `current`, `stale`, or `unmaterialized`; a stale result is last-known data, not current
+truth. The host owns catch-up and timer delivery, including waking at a derivation's next valid-time
+boundary.
+
+Exact derivation provenance currently covers patterns, predicates, and negation. Derivations reject
+recursive rules, disjunction, aggregation, pagination, dynamic attributes, and transaction-binding
+clauses where Triplex cannot preserve a complete explanation. Raw Datalog supports more of those
+features when provenance is not requested.
+
+## Constraints and responsibility boundaries
+
+The ontology DSL produces requiredness, cardinality, uniqueness, and reference-target constraints.
+They become atomic write guards only when a host passes the rules in `meta.enforce`, normally from
+the same snapshot pinned in `meta.configSnapshot`. Observation-only validation remains useful for
+migrations and audits. Direct adapter writes and unconstrained commands are outside enforcement.
+
+Triplex owns facts, temporal reads, atomic transactions, the causal journal, configuration identity,
+and derivation mechanics. The host still owns authentication, authorization, database/tenant
+selection, domain commands, higher-order business invariants, durable workflow lifecycle, external
+delivery, retries, migrations, monitoring, retention, backup, and recovery. See [Host
+integration](/host-integration) for the operational boundary.
+
+## Where Triplex fits
+
+Triplex is designed for domains where history and rules are part of the answer: compliance,
+onboarding, eligibility, entitlements, governed back-office work, and agent-driven systems that
+need a durable causal record. It is usually a poor fit for high-volume telemetry, blob storage,
+queue-only workloads, or simple state that never needs temporal or provenance questions.
diff --git a/docs/configuration-versioning.md b/docs/configuration-versioning.md
new file mode 100644
index 0000000..ffd8cc9
--- /dev/null
+++ b/docs/configuration-versioning.md
@@ -0,0 +1,115 @@
+# Configuration releases and rollback
+
+This walkthrough defines a typed course schema, publishes two immutable releases, promotes them
+through refs, pins operational writes to the actual returned snapshot IDs, inspects history, and
+rolls `live` back. It uses the in-memory layer so the whole program is executable from a source
+checkout.
+
+For the underlying node, revision, compatibility, validation, and enforcement contracts, see the
+[configuration reference](/configuration).
+
+## Complete runnable example
+
+From the repository root, run:
+
+```sh
+pnpm exec tsx --tsconfig docs/snippets/tsconfig.json docs/snippets/config-versioning.ts
+```
+
+<<< @/snippets/config-versioning.ts{ts}
+
+The two snapshot values in the output are real IDs returned by `ConfigStore.commit`; never copy a
+made-up `sha256-…` placeholder into transaction metadata. The exact hashes are deterministic for
+this history, but application code should treat them as opaque.
+
+The stable outcomes are:
+
+- `testBeforePromotion` and `historicalV2` are `courses-2026.2`;
+- the change list contains the added `:course/status` attribute and changed `Course` schema;
+- `v2WritePin` equals the returned v2 snapshot ID;
+- after rollback, `liveAfterRollback` is `courses-2026.1`; and
+- `advancedFactsAfterRollback` is still `2`.
+
+## 1. Define typed schema objects
+
+`Attribute` owns a global keyword and value type. `EntityType` owns how that attribute is used by
+one entity type. Adding `status` as required changes the `Course` entity schema in v2 without
+changing the identity or definition of `:course/title`.
+
+`CourseV1.nodes` and `CourseV2.nodes` each evaluate to the complete configuration nodes needed by
+that schema, including generated graph-constraint nodes nested under the entity schema. A commit
+takes a complete object set, not a patch against the previous release.
+
+## 2. Publish without promoting
+
+Passing `ref: "test"` commits the release and moves `test` in the same atomic Triplex transaction.
+The example does not point `live` at arbitrary authoring state: it calls `setRef("live",
+v1.snapshot.id)` with the exact ID returned by the successful commit.
+
+The v2 commit moves only `test`, so `live` remains on v1 during inspection. `resolveRef("test")`
+returns the immutable snapshot behind the current pointer. A deployment tool can inspect that
+snapshot and its changes before promotion.
+
+## 3. Promote and pin writes
+
+Promotion is another `setRef` call. Moving a ref copies no configuration, and compare-and-retract
+prevents a stale concurrent writer from silently replacing a newer ref target.
+
+The operational transactions use:
+
+```ts
+{
+  configSnapshot: v2.snapshot.id,
+  enforce: GraphConstraint.enforcement(CourseV2.constraints)
+}
+```
+
+The snapshot pin records which rules governed the command. `enforce` is separate and opt-in: a
+snapshot ID in metadata does not itself turn constraints on. In a long-running host, resolve the
+intended ref once at the command boundary, collect constraints from that immutable snapshot when
+the TypeScript handles are not already present, and use that same snapshot and rule set throughout
+the transaction.
+
+## 4. Inspect an older release
+
+`snapshotById(id)` resolves an immutable historical release whether or not a ref still points to
+it. `load()` exposes the reference store model, and
+`InMemoryConfigStore.changesBetween(state, from, to)` reports added, removed, and changed logical
+objects. The detailed reference also exposes node-level Merkle diffs, revision history, reverse
+dependencies, and impact candidates.
+
+The CLI and dashboard provide operator views over the same records. See [CLI and
+dashboard](/tools#inspect-configuration) for commands that list releases, resolve a ref, inspect one
+object's immutable history, and move a ref.
+
+## 5. Understand rollback
+
+The final `setRef("live", v1.snapshot.id)` is a configuration rollback. It changes what future
+code resolving `live` sees. It does **not**:
+
+- retract or rewrite facts written while v2 was live;
+- change the `configSnapshot` stored on earlier transaction receipts;
+- delete v2, its object revisions, or its dependency graph;
+- transform data so it conforms to v1; or
+- reverse external work already performed by the host.
+
+That is why the v2 course still has two operational facts after rollback and its receipt still
+points to v2. Data migration, compensating commands, validation, and external side-effect recovery
+are separate host-owned operations. Plan them explicitly when a configuration change alters what
+old or new data means.
+
+## Durable version
+
+For persistence, compose `ConfigStore.layer` over one shared SQLite or PostgreSQL `Triples` layer.
+Do not create separate database layers for operational facts and configuration if they must share
+an atomic boundary:
+
+```ts
+const AppLayer = ConfigStore.layer.pipe(
+  Layer.provideMerge(SqliteTriples.layer({ filename: "./triplex.db" })),
+);
+```
+
+This is a focused composition fragment; imports and the complete in-memory program appear above.
+See [Getting started](/getting-started#use-durable-sqlite) and [Host
+integration](/host-integration) for runtime and migration choices.
diff --git a/docs/configuration.md b/docs/configuration.md
index cab191f..544efa8 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -3,6 +3,11 @@
 Triplex configuration is immutable, typed, and content-addressed. It is separate from operational
 facts even when persisted through the same `Triples` service:
 
+::: tip Looking for the release workflow?
+Start with the [complete publish, promote, pin, inspect, and rollback
+walkthrough](/configuration-versioning). This page is the detailed configuration contract.
+:::
+
 - an `EntitySnapshot` materializes one fact entity at a transaction or time;
 - a `ConfigSnapshot` is an immutable release root containing revisions, schema stamps, dependency
   closures, and refs.
@@ -206,8 +211,13 @@ Validation observations remain useful for migrations and audit even when enforce
 Applications normally resolve one pinned release, collect its rules, and pass both its
 `configSnapshot` and enforcement set at the command boundary.
 
-## Browser explorer
+## Explore configuration
+
+The repository dashboard exposes typed nodes, releases, refs, immutable object history, and impact
+analysis over its demo database or a supplied SQLite/PostgreSQL database. The CLI provides the same
+operator-oriented history and ref controls as stable JSON. See [CLI and
+dashboard](/tools#inspect-configuration).
 
-The standalone [`examples/config-explorer`](https://github.com/bjacobso/triplex/tree/main/examples/config-explorer) workspace demonstrates
-typed nodes, releases, refs, impact analysis, evaluation, and proof tamper detection without
-importing source files from another package.
+Continue to [Derivations](/derivations) to use a pinned configuration snapshot in explainable
+derived work, or [Troubleshooting](/troubleshooting#does-moving-a-config-ref-roll-back-data) for
+common release and rollback surprises.
diff --git a/docs/current-state.md b/docs/current-state.md
index e113cac..32e7276 100644
--- a/docs/current-state.md
+++ b/docs/current-state.md
@@ -86,11 +86,12 @@ outside the normal test matrix.
 ## Honest limitations
 
 - The seven public packages are prepared for coordinated publication under the `@triplex-build`
-  organization scope. Stable `0.1.0` has not been published. The GitHub repository is
-  `bjacobso/triplex`, and the local `origin` uses that canonical URL.
-- npm assigned the package family's first bootstrap snapshot to `latest` as well as `next`, and the
-  registry rejects removing the only `latest` tag. Consumers must request `@next` explicitly until
-  stable `0.1.0` replaces it.
+  organization scope, but no package under that scope is available from npm yet. Stable `0.1.0` has
+  not been published. The GitHub repository is `bjacobso/triplex`, and the local `origin` uses that
+  canonical URL.
+- The superseded `@bjacobso` bootstrap packages are not the installation path for new consumers.
+  Evaluation uses a current source checkout until the scoped package bootstrap and registry checks
+  pass.
 - `SubscriptionManager` discovers dependencies and reports possible invalidations. It does not
   push result deltas or automatically re-run queries.
 - Entity snapshots, validation results, and derivation materializations are projections. Callers
@@ -114,9 +115,11 @@ outside the normal test matrix.
 
 ## First-release gates
 
-1. Merge the initial Changesets version PR, which advances the public packages from `0.0.0` to
+1. Bootstrap the `@triplex-build` package records, configure npm trusted publishing, and verify a
+   registry-only `next` consumer for the whole coordinated package family.
+2. Merge the initial Changesets version PR, which advances the public packages from `0.0.0` to
    `0.1.0`.
-2. Publish the scoped stable packages together and verify their peer dependency, provenance, CLI,
+3. Publish the scoped stable packages together and verify their peer dependency, provenance, CLI,
    and exports behavior from the registry.
 
 Cloudflare and FoundationDB are private for the first release. Their source stays in the monorepo
diff --git a/docs/datalog.md b/docs/datalog.md
index 12d607b..89ca701 100644
--- a/docs/datalog.md
+++ b/docs/datalog.md
@@ -4,6 +4,12 @@ Triplex exposes bounded Datalog pages through `Triples.query` and a wrapped form
 `Triples.queryPage`. Both default to 100 bindings and allow at most 1,000 per page. The in-memory KV and SQL engines share one schema, semantic preflight, result
 identity, ordering contract, and bitemporal basis.
 
+If facts, relationships, or the two time axes are new, read [Core concepts](/concepts) first. A
+Datalog clause is a pattern over `(entity, attribute, value)`. Reusing a `?variable` joins clauses;
+the `find` list selects the bindings returned to the caller. For example, joining a worker's
+placement site to a certificate site answers whether the same relationship exists—not merely
+whether either entity has some site fact.
+
 ## Query shape
 
 ```ts
diff --git a/docs/derivations.md b/docs/derivations.md
index aa4f74b..fb971b0 100644
--- a/docs/derivations.md
+++ b/docs/derivations.md
@@ -5,6 +5,10 @@ with explicit identity, provenance, temporal basis, and configuration identity.
 engine, not a workflow engine: applications decide whether a candidate opens a task, updates a
 projection, triggers an integration, or has no operational consequence.
 
+For an accessible example of a placement producing safety-training work, start with [Derived work
+and provenance](/concepts#derived-work-and-provenance). This page defines the detailed evaluation,
+materialization, reconciliation, and overlay contracts.
+
 ## Definitions and candidates
 
 ```ts
diff --git a/docs/getting-started.md b/docs/getting-started.md
new file mode 100644
index 0000000..80e3124
--- /dev/null
+++ b/docs/getting-started.md
@@ -0,0 +1,106 @@
+# Getting started
+
+This guide writes three facts to an in-memory Triplex database, joins them with Datalog, and prints
+the result. It is the shortest complete path from a source checkout to a running program.
+
+::: warning Package availability
+As of September 10, 2026, the new `@triplex-build` packages are **not yet available from npm**.
+The registry returns `404` for the core, SQLite, and CLI packages. Use the source-checkout path
+below until the [first release gates](/current-state#first-release-gates) are complete. Do not use
+the superseded `@bjacobso` package names for new work.
+:::
+
+## Prerequisites
+
+- Git
+- Node.js 22 or newer
+- Corepack and pnpm 10.11.0 (the repository declares the exact package-manager version)
+
+## Run the example
+
+Clone the repository and install its locked dependencies:
+
+```sh
+git clone https://github.com/bjacobso/triplex.git
+cd triplex
+corepack enable
+pnpm install --frozen-lockfile
+```
+
+Run the checked quickstart directly from the checkout:
+
+```sh
+pnpm exec tsx --tsconfig docs/snippets/tsconfig.json docs/snippets/getting-started.ts
+```
+
+The complete program is:
+
+<<< @/snippets/getting-started.ts{ts}
+
+It prints:
+
+```json
+{
+  "relationships": [
+    {
+      "person": "Alice",
+      "company": "Acme"
+    }
+  ]
+}
+```
+
+The repository's smaller demo is another executable starting point:
+
+```sh
+pnpm exec tsx --tsconfig docs/snippets/tsconfig.json examples/demo/demo.ts
+```
+
+## What the Effect code is doing
+
+You only need four Effect ideas for this example:
+
+1. `Triples` is a service tag. `yield* Triples` asks the current Effect context for the database.
+2. `Effect.gen` lets the program sequence database effects with generator syntax.
+3. `KvTriples.layer` constructs the in-memory implementation of that service.
+4. `Effect.provide` supplies the layer, and `Effect.runPromise` runs the fully provided program.
+
+Create and share a layer at your application boundary. Do not construct a new layer inside each
+request: each `KvTriples.layer` runtime owns a fresh in-memory database, and its contents disappear
+when that runtime/process ends.
+
+The transaction records three typed values atomically. `ref(acme)` is a relationship because its
+value is another `EntityId`; the Datalog query follows that relationship by using the same
+`?company` variable in two clauses. `query` returns one bounded page, which is enough for this
+one-row example. Follow `nextCursor` for larger results or use `queryAll` only for trusted batch
+work that intentionally needs the complete result set.
+
+## Use durable SQLite
+
+SQLite is the supported local persistent backend. Once the scoped packages are published, a
+registry consumer will install the exact compatible releases of core, SQLite, and Effect. Until
+then, use them from this workspace checkout.
+
+Replace the in-memory layer with a file-backed layer:
+
+```ts
+import { SqliteTriples } from "@triplex-build/triplex-sqlite";
+
+const DatabaseLive = SqliteTriples.layer({ filename: "./triplex.db" });
+const relationships = await Effect.runPromise(program.pipe(Effect.provide(DatabaseLive)));
+```
+
+This is a focused replacement fragment: `program` is the complete program above. The convenience
+layer opens the SQLite file and applies Triplex's current migration. Create it once and share it for
+the application lifetime. Production hosts that separate schema migration from runtime startup
+should use the explicit unmigrated composition described in [Host integration](/host-integration).
+
+## Next steps
+
+- Experiment without installing anything in the browser [Playground](/playground).
+- Read [Core concepts](/concepts) before modeling a domain with historical facts.
+- Follow [Configuration releases and rollback](/configuration-versioning) to version rules and pin
+  operational writes to them.
+- Learn query clauses and pagination in [Datalog](/datalog).
+- Explore a database through the [CLI and dashboard](/tools).
+- Check the [current maturity contract](/current-state) before choosing a production backend.
diff --git a/docs/host-integration.md b/docs/host-integration.md
index f1da7e3..e4196c9 100644
--- a/docs/host-integration.md
+++ b/docs/host-integration.md
@@ -5,6 +5,10 @@ an application that also owns relational operational records. The host remains r
 authentication, authorization, HTTP contracts, durable work, response caching, external effects,
 and product-specific invariants.
 
+Start with [Core concepts](/concepts#constraints-and-responsibility-boundaries) if that separation
+is unfamiliar. Use [CLI and dashboard](/tools) for local inspection and
+[Troubleshooting](/troubleshooting) for common runtime and freshness failures.
+
 The executable companion is
 [`examples/compliance-host`](https://github.com/bjacobso/triplex/tree/main/examples/compliance-host).
 Despite its focused scenario, it uses only generic Triplex primitives: content-addressed
diff --git a/docs/index.md b/docs/index.md
index 0d32df6..01a3263 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -9,10 +9,10 @@ pageClass: triplex-index
 ---
 
 ::: warning Pre-1.0 release candidate
-Triplex is published only as npm canaries under the `next` tag and requires
-`effect@4.0.0-rc.112`. Effect 3 is not compatible. KV and SQLite are the supported baseline;
-PostgreSQL is a production candidate, while Cloudflare and FoundationDB are experimental.
-[Read the exact maturity contract](/current-state).
+The new `@triplex-build` packages are not yet published. Run Triplex from a source checkout; the
+current tree requires `effect@4.0.0-rc.112`, and Effect 3 is not compatible. KV and SQLite are the
+supported baseline; PostgreSQL is a production candidate, while Cloudflare and FoundationDB are
+experimental. [Read the exact maturity contract](/current-state).
 :::
 
 <div class="triplex-home">
@@ -24,9 +24,10 @@ PostgreSQL is a production candidate, while Cloudflare and FoundationDB are expe
       Bitemporal facts, Datalog, and typed, content-addressed configuration—built on Effect.
 </p>
 <div class="triplex-home__actions">
-<a class="triplex-home__primary" href="/current-state">
+<a class="triplex-home__primary" href="/getting-started">
         Get started<span class="vpi-arrow-right triplex-home__link-icon" aria-hidden="true"></span>
 </a>
+<a class="triplex-home__secondary" href="/playground">Try the playground</a>
 <a class="triplex-home__secondary" href="https://github.com/bjacobso/triplex">GitHub</a>
 </div>
 </header>
@@ -133,9 +134,12 @@ PostgreSQL is a production candidate, while Cloudflare and FoundationDB are expe
 </section>
 
 <nav class="triplex-home__guides" aria-label="Guides">
+<a href="/getting-started">Quickstart<span class="vpi-arrow-right triplex-home__link-icon" aria-hidden="true"></span></a>
+<a href="/playground">Playground<span class="vpi-arrow-right triplex-home__link-icon" aria-hidden="true"></span></a>
+<a href="/concepts">Core concepts<span class="vpi-arrow-right triplex-home__link-icon" aria-hidden="true"></span></a>
 <a href="/datalog">Datalog<span class="vpi-arrow-right triplex-home__link-icon" aria-hidden="true"></span></a>
 <a href="/configuration">Typed configuration<span class="vpi-arrow-right triplex-home__link-icon" aria-hidden="true"></span></a>
 <a href="/derivations">Derived facts<span class="vpi-arrow-right triplex-home__link-icon" aria-hidden="true"></span></a>
-<a href="/operational-primitives">Operations<span class="vpi-arrow-right triplex-home__link-icon" aria-hidden="true"></span></a>
+<a href="/tools">CLI and dashboard<span class="vpi-arrow-right triplex-home__link-icon" aria-hidden="true"></span></a>
 </nav>
 </div>
diff --git a/docs/operational-primitives.md b/docs/operational-primitives.md
index 9bd3d9b..4e91c83 100644
--- a/docs/operational-primitives.md
+++ b/docs/operational-primitives.md
@@ -4,6 +4,10 @@ Triplex is a durable substrate for applications that need temporal facts, deriva
 This specification separates database/runtime guarantees that belong in Triplex from workflow and
 product concepts that belong in a host application.
 
+Read [Core concepts](/concepts) for the beginner-oriented model and [Host
+integration](/host-integration) for application composition. This page is the low-level operational
+contract.
+
 ## Implemented foundation
 
 ### Atomic transactions
diff --git a/docs/playground.md b/docs/playground.md
new file mode 100644
index 0000000..d2bba6a
--- /dev/null
+++ b/docs/playground.md
@@ -0,0 +1,40 @@
+---
+title: Playground
+description: Run an in-memory Triplex database, Datalog queries, and transactions in your browser.
+aside: false
+---
+
+# Playground
+
+See how facts become answers. Pick a domain, try a change, and watch a real Triplex database
+update in your browser. No installation or JSON editing needed to get started.
+
+<ClientOnly>
+  <TriplexPlayground />
+
+<template #fallback>
+
+<p>Loading the in-memory Triplex runtime…</p>
+</template>
+</ClientOnly>
+
+## What this demonstrates
+
+The sample query runs automatically. Add a score or a training record to change its answer, then
+use **Retract this change** to see the original result return. Retraction changes which facts are
+currently visible; the journal keeps both writes. **Reset database** starts a fresh session,
+including a fresh journal.
+
+Open **Go further: edit queries and transactions** to experiment with the underlying JSON. The
+guided actions populate the transaction editor, so you can inspect the exact assertion or
+retraction you just ran. Raw entity facts include IDs you can use in your own retractions.
+
+The playground keeps one `ManagedRuntime` alive while you interact with a domain, so every command
+resolves the same `Triples` service and in-memory KV store. Switching domains or resetting disposes
+that runtime and builds a new one. This is the browser equivalent of the layer-lifetime guidance in
+[Getting started](/getting-started#what-the-effect-code-is-doing).
+
+The query and transaction editors decode the same public `DatalogQuery` and `TransactRequest`
+schemas used by Triplex hosts and the CLI. Results are bounded to 100 rows. For durable data, graph
+constraints, configuration authoring, or a larger operator interface, continue to [CLI and
+dashboard](/tools).
diff --git a/docs/releasing.md b/docs/releasing.md
index 09fc5cd..b25a75d 100644
--- a/docs/releasing.md
+++ b/docs/releasing.md
@@ -65,9 +65,9 @@ For a new package added to the family, repeat the minimal bootstrap sequence:
 
 Do not put an npm token in the repository, a shell command, or a checked-in `.npmrc`.
 
-npm assigned the first bootstrap snapshot to both `latest` and `next` and rejects deleting the
-package's only `latest` tag. Until stable `0.1.0` replaces it, documentation and consumer checks
-must always install `@next` explicitly.
+The new scope currently has no published package records. During bootstrap, verify which dist-tags
+npm assigns and keep consumer checks on explicit `@next` versions until stable `0.1.0` is released;
+do not assume the registry state in documentation before checking it.
 
 The six pre-stable packages under `@bjacobso` are a superseded bootstrap line. After the
 `@triplex-build` stable release is available, deprecate every old version with a message directing
@@ -106,7 +106,7 @@ share the `triplex` stack's `prod` state. Secrets Store Edit is required to bind
 secret when a fresh runner authenticates; Secrets Store Read alone is insufficient. See
 [Cloudflare's Secrets Store permissions](https://developers.cloudflare.com/secrets-store/access-control/).
 
-## Verify the canary
+## Verify the canary after bootstrap
 
 Install from the registry in a clean directory outside this monorepo:
 
diff --git a/docs/snippets/config-versioning.ts b/docs/snippets/config-versioning.ts
new file mode 100644
index 0000000..2de4b2e
--- /dev/null
+++ b/docs/snippets/config-versioning.ts
@@ -0,0 +1,113 @@
+import { Effect, Layer } from "effect";
+import { EntityId, KvTriples, Triples } from "@triplex-build/triplex";
+import {
+  Attribute,
+  ConfigStore,
+  EntityType,
+  GraphConstraint,
+  InMemoryConfigStore,
+} from "@triplex-build/triplex/config";
+
+const CourseTitle = Attribute.text(":course/title");
+const CourseStatus = Attribute.enumOf(":course/status", ["draft", "published"]);
+
+const CourseV1 = EntityType.make("Course", {
+  attributes: {
+    title: Attribute.use(CourseTitle, { required: true }),
+  },
+});
+
+const CourseV2 = EntityType.make("Course", {
+  attributes: {
+    title: Attribute.use(CourseTitle, { required: true }),
+    status: Attribute.use(CourseStatus, { required: true }),
+  },
+});
+
+const program = Effect.gen(function* () {
+  const config = yield* ConfigStore.ConfigStore;
+  const triples = yield* Triples;
+
+  // Publish v1 to test, then promote that exact returned snapshot to live.
+  const v1 = yield* config.commit({
+    label: "courses-2026.1",
+    objects: yield* CourseV1.nodes,
+    ref: "test",
+  });
+  yield* config.setRef("live", v1.snapshot.id);
+
+  yield* triples.transact(
+    [
+      {
+        op: "assert",
+        entityId: EntityId.make("course:intro"),
+        entityType: CourseV1.entityType,
+        ...CourseV1.title.assertion("Introduction to temporal data"),
+      },
+    ],
+    {
+      actor: "user:publisher",
+      commandId: "courses/create-intro/v1",
+      configSnapshot: v1.snapshot.id,
+      enforce: GraphConstraint.enforcement(CourseV1.constraints),
+    },
+  );
+
+  // Publish a complete v2 graph without changing live, inspect it, then promote it.
+  const v2 = yield* config.commit({
+    label: "courses-2026.2",
+    objects: yield* CourseV2.nodes,
+    ref: "test",
+  });
+  const testBeforePromotion = yield* config.resolveRef("test");
+  yield* config.setRef("live", v2.snapshot.id);
+
+  yield* triples.transact(
+    [
+      {
+        op: "assert",
+        entityId: EntityId.make("course:advanced"),
+        entityType: CourseV2.entityType,
+        ...CourseV2.title.assertion("Advanced temporal data"),
+      },
+      {
+        op: "assert",
+        entityId: EntityId.make("course:advanced"),
+        entityType: CourseV2.entityType,
+        ...CourseV2.status.assertion("published"),
+      },
+    ],
+    {
+      actor: "user:publisher",
+      commandId: "courses/create-advanced/v1",
+      configSnapshot: v2.snapshot.id,
+      enforce: GraphConstraint.enforcement(CourseV2.constraints),
+    },
+  );
+
+  const state = yield* config.load();
+  const changes = InMemoryConfigStore.changesBetween(state, v1.snapshot, v2.snapshot);
+  const historicalV2 = yield* config.snapshotById(v2.snapshot.id);
+  const v2Receipt = yield* triples.transactionByCommand("courses/create-advanced/v1");
+
+  // Roll back configuration by moving live. Operational facts and their pins remain.
+  yield* config.setRef("live", v1.snapshot.id);
+  const liveAfterRollback = yield* config.resolveRef("live");
+  const advancedCourse = yield* triples.entity(EntityId.make("course:advanced"));
+
+  return {
+    v1Snapshot: v1.snapshot.id,
+    v2Snapshot: v2.snapshot.id,
+    testBeforePromotion: testBeforePromotion?.label,
+    changedObjects: changes.map((change) => `${change.kind}:${change.key}`),
+    historicalV2: historicalV2?.label,
+    v2WritePin: v2Receipt?.configSnapshot,
+    liveAfterRollback: liveAfterRollback?.label,
+    advancedFactsAfterRollback: advancedCourse.length,
+  };
+});
+
+const AppLayer = ConfigStore.layer.pipe(Layer.provideMerge(KvTriples.layer));
+const result = await Effect.runPromise(program.pipe(Effect.provide(AppLayer)));
+
+console.log(JSON.stringify(result, null, 2));
diff --git a/docs/snippets/getting-started.ts b/docs/snippets/getting-started.ts
new file mode 100644
index 0000000..764bbda
--- /dev/null
+++ b/docs/snippets/getting-started.ts
@@ -0,0 +1,56 @@
+import { Effect } from "effect";
+import { EntityId, KvTriples, Triples, ref, string } from "@triplex-build/triplex";
+
+const program = Effect.gen(function* () {
+  const triples = yield* Triples;
+  const alice = EntityId.make("person:alice");
+  const acme = EntityId.make("company:acme");
+
+  yield* triples.transact(
+    [
+      {
+        op: "assert",
+        entityId: alice,
+        entityType: "Person",
+        attribute: ":person/name",
+        value: string("Alice"),
+      },
+      {
+        op: "assert",
+        entityId: alice,
+        entityType: "Person",
+        attribute: ":person/employer",
+        value: ref(acme),
+      },
+      {
+        op: "assert",
+        entityId: acme,
+        entityType: "Company",
+        attribute: ":company/name",
+        value: string("Acme"),
+      },
+    ],
+    {
+      actor: "quickstart",
+      commandId: "quickstart/create-alice/v1",
+    },
+  );
+
+  const { results } = yield* triples.query({
+    find: ["?personName", "?companyName"],
+    where: [
+      ["?person", ":person/name", "?personName"],
+      ["?person", ":person/employer", "?company"],
+      ["?company", ":company/name", "?companyName"],
+    ],
+  });
+
+  return results.map((row) => ({
+    person: row["?personName"],
+    company: row["?companyName"],
+  }));
+});
+
+const relationships = await Effect.runPromise(program.pipe(Effect.provide(KvTriples.layer)));
+
+console.log(JSON.stringify({ relationships }, null, 2));
diff --git a/docs/snippets/tsconfig.json b/docs/snippets/tsconfig.json
index 60b1148..61d45f5 100644
--- a/docs/snippets/tsconfig.json
+++ b/docs/snippets/tsconfig.json
@@ -6,8 +6,9 @@
     "noEmit": true,
     "paths": {
       "@triplex-build/triplex": ["packages/core/src/index.ts"],
-      "@triplex-build/triplex/config": ["packages/core/src/config/index.ts"]
+      "@triplex-build/triplex/config": ["packages/core/src/config/index.ts"],
+      "@triplex-build/triplex-sqlite": ["packages/sqlite/src/index.ts"]
     }
   },
-  "include": ["home/**/*.ts"]
+  "include": ["**/*.ts"]
 }
diff --git a/docs/tools.md b/docs/tools.md
new file mode 100644
index 0000000..0295b99
--- /dev/null
+++ b/docs/tools.md
@@ -0,0 +1,181 @@
+# CLI and dashboard
+
+Triplex includes two operator tools in the repository: a JSON-first CLI for repeatable commands and
+a browser dashboard for interactive exploration. Both are pre-1.0. The CLI package is not yet
+available under the new npm scope, and the dashboard is a private workspace package rather than a
+published application.
+
+## Build from the source checkout
+
+After following [Getting started](/getting-started), build the CLI and its workspace dependencies,
+then define a short shell function for the built binary:
+
+```sh
+pnpm turbo run build --filter=@triplex-build/triplex-cli...
+triplex() { node --disable-warning=ExperimentalWarning packages/cli/dist/cli.js "$@"; }
+```
+
+The examples below use the repository command so they work before registry publication:
+
+```sh
+triplex --sqlite ./app.db describe
+triplex --sqlite ./app.db status
+```
+
+`describe` returns the machine-readable command manifest. Successful CLI commands emit one
+`{ "ok": true, "command": "…", "data": … }` JSON value to stdout. Decode/runtime failures emit an
+error envelope to stderr and exit nonzero. Add `--pretty` before the subcommand when reading output
+by hand.
+
+Opening the SQLite convenience layer can apply pending Triplex migrations. Hosts that require
+migration separation should run migrations in their deployment process before granting CLI access.
+
+## Write and inspect a fact
+
+`transaction apply` accepts the public `TransactRequest` wire shape. Mutation input must include an
+actor and a unique command ID:
+
+```sh
+triplex --sqlite ./app.db transaction apply --input - <<'JSON'
+{
+  "operations": [
+    {
+      "op": "assert",
+      "entityId": "worker:maria",
+      "entityType": "Worker",
+      "attribute": ":worker/name",
+      "value": { "type": "string", "value": "Maria" }
+    }
+  ],
+  "meta": {
+    "actor": "user:docs",
+    "commandId": "docs/create-maria/v1"
+  }
+}
+JSON
+
+triplex --sqlite ./app.db entity types
+triplex --sqlite ./app.db entity get worker:maria
+triplex --sqlite ./app.db entity facts worker:maria
+triplex --sqlite ./app.db journal receipt docs/create-maria/v1
+```
+
+Do not retry that payload with a new command ID merely because the client lost the response. Look
+up the original receipt first. A duplicate committed command ID produces
+`CommandAlreadyCommittedError`; it does not silently execute or return success again.
+
+## Run and page a query
+
+Create `query.json`:
+
+```json
+{
+  "find": ["?worker", "?name"],
+  "where": [["?worker", ":worker/name", "?name"]],
+  "orderBy": [{ "variable": "?name", "direction": "asc" }]
+}
+```
+
+Run or explain it:
+
+```sh
+triplex --sqlite ./app.db query run --input query.json --limit 50 --debug
+triplex --sqlite ./app.db query explain --input query.json
+```
+
+`query run` returns one bounded page. If `data.nextCursor` is present, pass that exact opaque value
+back with `--cursor`; keep the query, page size, database, and temporal basis unchanged. The cursor
+pins the recorded snapshot so concurrent writes do not reshuffle an in-progress scan.
+
+Use epoch milliseconds to inspect a historical basis:
+
+```sh
+triplex --sqlite ./app.db entity get worker:maria \
+  --recorded-at 1788998400000 --valid-at 1788998400000
+```
+
+The same `--recorded-at` and `--valid-at` flags are available for fact and query reads. See [Core
+concepts](/concepts#recorded-time-and-valid-time) before interpreting a one-axis historical query.
+
+## Inspect configuration
+
+Configuration authoring remains application-owned. Once an application has committed releases,
+operators can inspect and move their refs:
+
+```sh
+triplex --sqlite ./app.db config refs
+triplex --sqlite ./app.db config releases
+triplex --sqlite ./app.db config release --ref live
+triplex --sqlite ./app.db config objects --kind entity-schema
+triplex --sqlite ./app.db config object entity-schema Course
+triplex --sqlite ./app.db config impact attribute :course/status
+```
+
+`config releases` returns the real snapshot IDs. To promote or roll back, copy the intended returned
+ID and pass it unchanged:
+
+```sh
+SNAPSHOT_ID='copy an actual snapshotId returned above'
+triplex --sqlite ./app.db config set-ref live "$SNAPSHOT_ID"
+```
+
+The assignment is an operator template, not a command to paste unchanged. Inspect the target
+release before moving the ref. Moving it does not change operational data; see [Configuration
+releases and rollback](/configuration-versioning#understand-rollback).
+
+## Manage local databases
+
+The CLI can manage isolated SQLite files in `./data` (or `--data-dir`):
+
+```sh
+triplex db create app --description "Application database"
+triplex db list
+triplex --database-id app status
+```
+
+`db clear` and `db delete` are destructive and require `--yes`. PostgreSQL can be selected with
+`TRIPLEX_POSTGRES_URL`; prefer the environment over a URL flag so credentials do not enter shell
+history. A host must resolve database IDs from authenticated server-owned state, not unchecked
+request input.
+
+## Explore in the dashboard
+
+Start the browser-local demo:
+
+```sh
+pnpm dashboard
+```
+
+Open `http://localhost:4173`. The demo loads classroom fixtures into a fresh in-memory database.
+Edits are real Triplex writes but disappear when the app runtime restarts.
+
+To inspect a persistent database, build and run the local HTTP host:
+
+```sh
+pnpm dashboard:serve -- --sqlite /absolute/path/to/triplex.db
+```
+
+The dashboard includes entity tables and timelines, raw Datalog and query plans, the transaction
+journal, derivation candidates, form previews, and full configuration release/ref/revision history.
+Its footer selects recorded and valid time independently; configuration and journal views remain
+current so the surrounding context stays visible.
+
+The server binds to `127.0.0.1` and has mutation capabilities. It is an operator tool, not an
+authenticated public server. Do not expose it as your application's authorization boundary.
+
+## Runnable demos
+
+- [`examples/demo`](https://github.com/bjacobso/triplex/tree/main/examples/demo) — linked facts and
+  Datalog
+- [`examples/compliance-host`](https://github.com/bjacobso/triplex/tree/main/examples/compliance-host)
+  — configuration, journal catch-up, derivation reconciliation, overlays, and temporal wakeups
+- [`examples/http-api`](https://github.com/bjacobso/triplex/tree/main/examples/http-api) — generated
+  HTTP routes and OpenAPI
+- [`examples/config-explorer`](https://github.com/bjacobso/triplex/tree/main/examples/config-explorer)
+  — configuration graphs, diffs, evaluation, and proof tamper detection
+- [`examples/tenant-host-cloudflare`](https://github.com/bjacobso/triplex/tree/main/examples/tenant-host-cloudflare)
+  — experimental multi-tenant reference host
+
+For the exhaustive CLI command contract, see the [package
+README](https://github.com/bjacobso/triplex/tree/main/packages/cli). For common failures, continue to
+[Troubleshooting and FAQ](/troubleshooting).
diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md
new file mode 100644
index 0000000..9f995b4
--- /dev/null
+++ b/docs/troubleshooting.md
@@ -0,0 +1,126 @@
+# Troubleshooting and FAQ
+
+## Why does npm return 404 for `@triplex-build/*`?
+
+The package namespace has moved to `@triplex-build`, but the new package family has not yet been
+published. As of September 10, 2026, registry lookups for core, SQLite, and the CLI return `404`.
+Use the [source-checkout quickstart](/getting-started) until the release gates are complete. Do not
+switch new examples back to the superseded `@bjacobso` namespace.
+
+After publication, keep every Triplex package on one coordinated release and use the exact Effect
+peer version declared by that release. The current source tree targets Node.js 22+ and
+`effect@4.0.0-rc.112`; Effect 3 is incompatible. Multiple Effect copies or an RC mismatch can make
+service tags and runtime types disagree even when imports look correct.
+
+## Why is `Triples` (or another service) missing?
+
+An Effect program describes requirements until a layer provides them. Supply a backend layer at
+the application boundary:
+
+```ts
+await Effect.runPromise(program.pipe(Effect.provide(KvTriples.layer)));
+```
+
+`ConfigStore.layer` itself requires `Triples`, so compose it over the same database:
+
+```ts
+const AppLayer = ConfigStore.layer.pipe(Layer.provideMerge(KvTriples.layer));
+```
+
+Construct that layer once per intended database lifetime. Reconstructing an in-memory layer creates
+a new empty database; constructing per-request SQLite/PostgreSQL layers also defeats connection and
+runtime sharing.
+
+## Why is a query empty?
+
+Check these in order:
+
+1. **Identity and value type:** direct entity/reference APIs require branded `EntityId`/`TripleId`
+   values; raw Datalog terms are decoded by the query schema.
+2. **Temporal basis:** omitted `validAt` means now. A future-effective or expired fact will be
+   absent even if it exists in history.
+3. **Retraction:** `entity` and `match` show visible facts; `history(entityId)` also shows retracted
+   assertions.
+4. **Join variables:** a spelling difference such as `?site` versus `?siteId` prevents clauses from
+   joining.
+5. **Negation safety:** variables in `not` must already be bound outside it; invalid programs fail
+   preflight instead of producing a partial answer.
+
+Use `triples.explain(query)` or CLI `query explain`, then run with debug output to inspect the
+compiled plan without changing the query.
+
+## Why are only 100 query rows returned?
+
+`Triples.query` and `queryPage` are bounded and default to 100 rows. This is not evidence that only
+100 matches exist. Follow `nextCursor` using the same canonical query, page size, temporal basis,
+and database scope. Cursors are opaque, versioned, and snapshot-stable; do not decode or edit them.
+
+Use `queryAll` only for trusted internal/batch work that deliberately needs an unbounded complete
+result. Pagination bounds result transfer, not necessarily all database work, especially for joins,
+aggregation, or counts.
+
+Entity timelines use a different newest-first contract: preserve the first page's
+`snapshotPosition` and pass its `nextBeforePosition` as `beforePosition` on the next request.
+
+## Which historical clock should I set?
+
+`recordedAt` asks what the database knew; `validAt` asks what was true in the domain. Setting only
+`recordedAt` still uses the current valid time, and setting only `validAt` still uses the latest
+recorded knowledge. For “what did we believe then about what was true then?”, set both explicitly.
+
+Both are non-negative epoch milliseconds. Valid intervals are `[validFrom, validTo)`, so a fact is
+not visible exactly at its `validTo`. For exact transaction order, use journal positions; multiple
+commits can share one millisecond. Read [the dated example](/concepts#recorded-time-and-valid-time).
+
+## What should happen on a duplicate command ID?
+
+Command IDs are atomically unique within one Triplex database. Reusing a committed ID raises
+`CommandAlreadyCommittedError` with the original transaction ID; Triplex does not apply the write
+again. Treat the original transaction as the durable idempotency receipt and retrieve it with
+`transactionByCommand(commandId)` or CLI `journal receipt`.
+
+Do not generate a replacement ID until you know you are issuing a genuinely new domain command.
+Command IDs must contain 1–1024 characters.
+
+## Why did invalid data commit?
+
+Configuration metadata and enforcement are separate. `meta.configSnapshot` records which release
+governed a write, but constraints are enforced only when the command also passes
+`meta.enforce.constraints`. The built-in atomic rules cover requiredness, cardinality, uniqueness,
+and reference-target kinds.
+
+Always derive or collect rules from the exact immutable snapshot you pin. Existing violations can
+remain during unrelated writes or repairs; enforcement rejects a new or worsened violation. Direct
+adapter writes, commands without `enforce`, authorization, and general Datalog invariants are
+outside this guarantee. Use validation observations when auditing or migrating existing data.
+
+## Why is a projection stale or empty?
+
+Entity validation and derivation materialization are projections over already committed source
+facts. A projection failure cannot roll back the source transaction. Their read APIs expose
+freshness explicitly:
+
+- `current` means the stored run matches the relevant current source position and basis;
+- `stale` returns last-known results, which must not be presented as current truth; and
+- `unmaterialized`/`unvalidated` means no run exists, so an empty result is not proof that no work or
+  violation exists.
+
+Run the materializer/validator after relevant journal changes, persist consumer checkpoints only
+after downstream effects complete, and schedule the next derivation run at
+`nextTemporalBoundary`. In-process change signals are wake-up hints; journal catch-up is the durable
+source.
+
+## Does moving a config ref roll back data?
+
+No. `setRef` only points a name such as `live` at another existing immutable configuration
+snapshot. Operational facts, command receipts, configuration pins on old transactions, migrations,
+and external side effects remain unchanged. See the [worked rollback
+example](/configuration-versioning#understand-rollback).
+
+## Where should authentication, authorization, and delivery live?
+
+In the host application. Authenticate and authorize before selecting a trusted database mapping or
+providing `Triples`. The host also owns HTTP contracts, task lifecycle, inbox/outbox delivery,
+timers, retries, monitoring, retention, backup, recovery, and higher-order business invariants.
+Triplex supplies database primitives, not those operational guarantees. Continue with [Host
+integration](/host-integration).
diff --git a/e2e/docs-home.spec.ts b/e2e/docs-home.spec.ts
index f220d23..55f4972 100644
--- a/e2e/docs-home.spec.ts
+++ b/e2e/docs-home.spec.ts
@@ -13,6 +13,15 @@ for (const colorScheme of ["light", "dark"] as const) {
       await expect(root).not.toHaveClass(/dark/);
     }
     await expect(page.getByRole("heading", { level: 1, name: "Triplex" })).toBeVisible();
+    const content = page.locator("#VPContent");
+    await expect(content.getByRole("link", { name: /Get started/ })).toHaveAttribute(
+      "href",
+      "/getting-started",
+    );
+    await expect(content.getByRole("link", { name: "Try the playground" })).toHaveAttribute(
+      "href",
+      "/playground",
+    );
     const examples = page.locator('.triplex-home__snippet div[class*="language-"]');
     await expect(examples).toHaveCount(3);
     for (const example of await examples.all()) {
diff --git a/e2e/docs-home.spec.ts-snapshots/home-dark.png b/e2e/docs-home.spec.ts-snapshots/home-dark.png
index b7c9ecb..87584ca 100644
Binary files a/e2e/docs-home.spec.ts-snapshots/home-dark.png and b/e2e/docs-home.spec.ts-snapshots/home-dark.png differ
diff --git a/e2e/docs-home.spec.ts-snapshots/home-light.png b/e2e/docs-home.spec.ts-snapshots/home-light.png
index 1bc39d5..910c764 100644
Binary files a/e2e/docs-home.spec.ts-snapshots/home-light.png and b/e2e/docs-home.spec.ts-snapshots/home-light.png differ
diff --git a/e2e/docs-playground.spec.ts b/e2e/docs-playground.spec.ts
new file mode 100644
index 0000000..813d520
--- /dev/null
+++ b/e2e/docs-playground.spec.ts
@@ -0,0 +1,101 @@
+import { expect, test } from "@playwright/test";
+
+test("guided changes update query results and retractions preserve the journal", async ({
+  page,
+}) => {
+  await page.goto("/playground");
+  const result = page.getByLabel("Query results");
+  await expect(result).toContainText("Mina Patel");
+  await expect(page.getByText("5 visible facts")).toBeVisible();
+
+  await page.getByLabel("Quiz score").fill("87");
+  await page.getByRole("button", { name: "Grade Mina’s quiz" }).click();
+  await expect(page.getByText("6 visible facts")).toBeVisible();
+  await expect(result).toContainText("No submissions need grading");
+  await expect(page.getByRole("row").filter({ hasText: ":submission/score" })).toContainText("87");
+  await expect(page.getByRole("status").filter({ hasText: "Commit #2" })).toContainText(
+    "1 fact added, 0 retracted.",
+  );
+
+  await page.getByRole("button", { name: "Retract this change" }).click();
+  await expect(result).toContainText("Mina Patel");
+  await expect(page.getByText("5 visible facts")).toBeVisible();
+  await expect(page.getByText("3 commits")).toBeVisible();
+  await expect(page.getByRole("row").filter({ hasText: ":submission/score" })).toHaveCount(0);
+
+  // Repeating the guided action uses a fresh command ID without resetting the store.
+  await page.getByRole("button", { name: "Grade Mina’s quiz" }).click();
+  await expect(result).toContainText("No submissions need grading");
+  await expect(page.getByText("4 commits")).toBeVisible();
+  await page.getByRole("button", { name: "Reset database" }).click();
+  await expect(result).toContainText("Mina Patel");
+  await expect(page.getByText("1 commit", { exact: true })).toBeVisible();
+});
+
+test("domains offer working guided examples, including a blank database", async ({ page }) => {
+  await page.goto("/playground");
+  await expect(page.getByText("5 visible facts")).toBeVisible();
+  const result = page.getByLabel("Query results");
+  await page.getByLabel("Domain").selectOption("compliance");
+  await expect(page.getByText("4 visible facts")).toBeVisible();
+  await expect(result).toContainText("worker:maria");
+  await expect(result).toContainText("site:harbor");
+  await page.getByRole("button", { name: "Record Maria’s training" }).click();
+  await expect(result).toContainText("No placements are missing training");
+  await expect(page.getByText("6 visible facts")).toBeVisible();
+  await page.getByRole("button", { name: "Retract this change" }).click();
+  await expect(result).toContainText("Maria");
+  await expect(page.getByText("4 visible facts")).toBeVisible();
+
+  await page.getByLabel("Domain").selectOption("blank");
+  await expect(page.getByText("0 visible facts")).toBeVisible();
+  await expect(page.getByText("No transactions yet.")).toBeVisible();
+  await page.getByLabel("Example name").fill("Hello Triplex");
+  await page.getByRole("button", { name: "Add your first fact" }).click();
+  await expect(result).toContainText("Hello Triplex");
+  await page.getByRole("button", { name: "Retract this change" }).click();
+  await expect(result).toContainText("No example names yet");
+});
+
+test("advanced editors support custom queries and recover from errors", async ({ page }) => {
+  await page.goto("/playground");
+  await expect(page.getByText("5 visible facts")).toBeVisible();
+  await page
+    .locator("summary")
+    .filter({ hasText: "Go further: edit queries and transactions" })
+    .click();
+  const query = page.getByLabel("Datalog query JSON");
+  await query.fill("invalid JSON");
+  await page.getByRole("button", { name: "Run query", exact: true }).click();
+  await expect(page.getByRole("alert")).toBeVisible();
+  await expect(page.getByLabel("Query results")).toContainText("Query failed");
+  await query.fill(
+    JSON.stringify({ find: ["?name"], where: [["?student", ":person/name", "?name"]] }),
+  );
+  await page.getByRole("button", { name: "Run query", exact: true }).click();
+  await expect(page.getByRole("alert")).toHaveCount(0);
+  await expect(page.getByRole("heading", { name: "Your query results" })).toBeVisible();
+  await expect(page.getByLabel("Query results")).toContainText("Mina Patel");
+  await page.getByRole("button", { name: "Apply transaction" }).click();
+  await expect(page.getByText("6 visible facts")).toBeVisible();
+  await page.getByRole("button", { name: "Apply transaction" }).click();
+  await expect(page.getByRole("alert")).toBeVisible();
+  await expect(page.getByText("2 commits")).toBeVisible();
+  await page.getByRole("button", { name: "Restore sample query" }).click();
+  await expect(page.getByLabel("Query results")).toContainText("No submissions need grading");
+});
+
+test("playground fits mobile with guided changes and editors open", async ({ page }) => {
+  await page.setViewportSize({ width: 390, height: 844 });
+  await page.goto("/playground");
+  await expect(page.getByText("5 visible facts")).toBeVisible();
+  expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBeLessThanOrEqual(390);
+  await page.getByRole("button", { name: "Grade Mina’s quiz" }).click();
+  await expect(page.getByText("6 visible facts")).toBeVisible();
+  await page
+    .locator("summary")
+    .filter({ hasText: "Go further: edit queries and transactions" })
+    .click();
+  expect(await page.evaluate(() => document.documentElement.scrollWidth)).toBeLessThanOrEqual(390);
+  await expect(page.getByLabel("Datalog query JSON")).toBeVisible();
+});
diff --git a/examples/demo/README.md b/examples/demo/README.md
index a42d121..479ce2d 100644
--- a/examples/demo/README.md
+++ b/examples/demo/README.md
@@ -6,7 +6,7 @@ raw triples, filter with Datalog, and traverse a relationship with a Datalog joi
 From the repository root:
 
 ```sh
-pnpm example:demo
+pnpm exec tsx --tsconfig docs/snippets/tsconfig.json examples/demo/demo.ts
 ```
 
 The same program can use SQLite or a candidate/experimental backend by replacing
diff --git a/packages/cli/README.md b/packages/cli/README.md
index f3c9ae0..4cf460f 100644
--- a/packages/cli/README.md
+++ b/packages/cli/README.md
@@ -5,25 +5,16 @@ Effect v4 `Command`, `Flag`, and `Argument` modules and emits stable JSON envelo
 terminal-oriented tables.
 
 ```sh
-pnpm --silent triplex --sqlite ./app.db describe
-pnpm --silent triplex --sqlite ./app.db status
-pnpm --silent triplex --sqlite ./app.db entity types
-```
-
-The same commands are available through the `triplex` binary installed by the current canary:
-
-```sh
-pnpm add @triplex-build/triplex-cli@next
-```
-
-Or run it without installing:
-
-```sh
-npx @triplex-build/triplex-cli@next db create app
+pnpm turbo run build --filter=@triplex-build/triplex-cli...
+triplex() { node --disable-warning=ExperimentalWarning packages/cli/dist/cli.js "$@"; }
+triplex --sqlite ./app.db describe
+triplex --sqlite ./app.db status
+triplex --sqlite ./app.db entity types
 ```
 
-The unscoped `triplex` name on npm belongs to an unrelated project, so the package spec must remain
-scoped when using `npx`. Once installed, the binary itself is simply `triplex`.
+The new `@triplex-build/triplex-cli` package is not yet published. Use the repository command above
+from a source checkout. After publication, the installed binary will be `triplex`; the unscoped
+`triplex` package name on npm belongs to an unrelated project.
 
 ## Agent contract
 
@@ -145,8 +136,7 @@ triplex --sqlite ./app.db transaction apply --input - <<'JSON'
   "meta": {
     "actor": "agent:curriculum",
     "commandId": "curriculum/create-mina/v1",
-    "correlationId": "course:data-systems-201",
-    "configSnapshot": "sha256-..."
+    "correlationId": "course:data-systems-201"
   }
 }
 JSON
@@ -159,7 +149,7 @@ silently applying the write twice. Inspect the durable receipt with:
 triplex --sqlite ./app.db journal receipt curriculum/create-mina/v1
 ```
 
-## Splunk configuration
+## Inspect configuration
 
 ```sh
 triplex --sqlite ./app.db config refs
@@ -168,7 +158,8 @@ triplex --sqlite ./app.db config release --ref live
 triplex --sqlite ./app.db config objects --kind form
 triplex --sqlite ./app.db config object form quiz/bitemporal-facts
 triplex --sqlite ./app.db config impact attribute :submission/status
-triplex --sqlite ./app.db config set-ref live sha256-...
+SNAPSHOT_ID='copy an actual snapshotId returned by config releases'
+triplex --sqlite ./app.db config set-ref live "$SNAPSHOT_ID"
 ```
 
 Object inspection returns every immutable revision with its canonical body, parent revision,
diff --git a/packages/cloudflare/README.md b/packages/cloudflare/README.md
index 661eb09..6bc049c 100644
--- a/packages/cloudflare/README.md
+++ b/packages/cloudflare/README.md
@@ -2,9 +2,8 @@
 
 Cloudflare Durable Object SQLite storage support for Triplex.
 
-```bash
-npm install effect @triplex-build/triplex @triplex-build/triplex-cloudflare
-```
+This is a private experimental workspace package and is not available from npm. Evaluate it only
+from a source checkout with the repository's locked dependencies.
 
 Compose the complete service once in a Durable Object constructor and retain the resulting Effect
 runtime for the object's activation:
diff --git a/packages/core/README.md b/packages/core/README.md
index 26bcb6f..2e123c9 100644
--- a/packages/core/README.md
+++ b/packages/core/README.md
@@ -6,15 +6,12 @@ The platform-neutral core includes temporal triples, an in-memory ordered-KV hex
 Datalog querying, subscriptions, entity snapshots, configuration releases,
 and Effect services.
 
-## Install
+## Availability
 
-```bash
-npm install effect@4.0.0-rc.112 @triplex-build/triplex@next
-```
-
-Pre-1.0 canaries are published under the `next` tag. Use an exact canary version in lockstep
-deployments; the unqualified install currently resolves the bootstrap snapshot until reviewed
-stable `0.1.0` replaces it.
+The `@triplex-build` package family is not yet published. Evaluate this package from the repository
+workspace with Node.js 22+, pnpm 10.11.0, and the locked `effect@4.0.0-rc.112` dependency. See the
+[source-checkout quickstart](../../docs/getting-started.md). Do not use the superseded
+`@bjacobso` canaries for new work.
 
 ## In-memory store
 
diff --git a/packages/foundationdb/README.md b/packages/foundationdb/README.md
index 988e3f3..3a2e1ce 100644
--- a/packages/foundationdb/README.md
+++ b/packages/foundationdb/README.md
@@ -2,9 +2,8 @@
 
 An ordered-KV and subscription backend for Triplex using FoundationDB.
 
-```bash
-npm install effect @triplex-build/triplex @triplex-build/triplex-foundationdb
-```
+This is a private experimental workspace package and is not available from npm. Evaluate it only
+from a source checkout with the repository's locked dependencies.
 
 Requires Node.js 22 or newer and compatible FoundationDB client libraries.
 
diff --git a/packages/http/README.md b/packages/http/README.md
index eb61cd9..80da87e 100644
--- a/packages/http/README.md
+++ b/packages/http/README.md
@@ -1,7 +1,7 @@
 # @triplex-build/triplex-http
 
-> **Pre-1.0:** install this package from the `next` tag together with the matching Triplex packages
-> and `effect@4.0.0-rc.112`. Effect 3 is not compatible.
+> **Pre-1.0:** the `@triplex-build` packages are not yet published. Evaluate this workspace package
+> from a source checkout with `effect@4.0.0-rc.112`; Effect 3 is not compatible.
 
 Configuration-derived REST and OpenAPI contracts for Triplex. The package is backend-neutral and
 uses Effect services: hosts provide `Triples`, `ConfigStore`, and an authorization policy, then
diff --git a/packages/postgres/README.md b/packages/postgres/README.md
index 92f7f28..d988684 100644
--- a/packages/postgres/README.md
+++ b/packages/postgres/README.md
@@ -2,11 +2,8 @@
 
 The PostgreSQL backend for Triplex, built on `@effect/sql-pg`.
 
-```bash
-npm install effect@4.0.0-rc.112 @triplex-build/triplex@next @triplex-build/triplex-postgres@next
-```
-
-Requires Node.js 22 or newer and a PostgreSQL connection URL.
+The `@triplex-build` packages are not yet published. Evaluate this workspace package from a source
+checkout. It requires Node.js 22 or newer and a PostgreSQL connection URL.
 
 ```ts
 import { PgTriples } from "@triplex-build/triplex-postgres";
@@ -68,7 +65,6 @@ Ordered migration definitions and `runMigrations` are exported by `@triplex-buil
 host deployment tooling. Triplex uses its own `triplex_schema_migrations` table.
 
 PostgreSQL passes the shared conformance and multi-connection isolation integration suite in CI.
-Treat this package as a production candidate rather than a supported default. Pre-1.0 canaries are
-published under the `next` tag.
+Treat this package as a production candidate rather than a supported default.
 
 MIT © 2026 Ben Jacobson.
diff --git a/packages/sql/README.md b/packages/sql/README.md
index 6cd31e2..01a239d 100644
--- a/packages/sql/README.md
+++ b/packages/sql/README.md
@@ -3,15 +3,12 @@
 Shared SQL migrations, database management, and Datalog execution for Triplex. Most applications
 install this transitively through a concrete backend package.
 
-```bash
-npm install effect@4.0.0-rc.112 @triplex-build/triplex@next @triplex-build/triplex-sql@next
-```
+The `@triplex-build` packages are not yet published. Evaluate this workspace package from a source
+checkout with the repository's locked Node.js, pnpm, and Effect versions.
 
 The public surface includes the ordered greenfield `migrations`, explicit `runMigrations`, the
 `SqlQueryExecutorLive` implementation of Triplex's internal query SPI, and SQL-backed
 `DatabaseManager`/registry layers. It is infrastructure rather than a standalone database; use
 `@triplex-build/triplex-sqlite` or `@triplex-build/triplex-postgres` for a concrete client and adapter.
 
-Pre-1.0 canaries are published under the `next` tag.
-
 MIT © 2026 Ben Jacobson.
diff --git a/packages/sqlite/README.md b/packages/sqlite/README.md
index adf5b0f..99a2565 100644
--- a/packages/sqlite/README.md
+++ b/packages/sqlite/README.md
@@ -2,11 +2,9 @@
 
 The Node.js SQLite backend for Triplex, built on `@effect/sql-sqlite-node`.
 
-```bash
-npm install effect@4.0.0-rc.112 @triplex-build/triplex@next @triplex-build/triplex-sqlite@next
-```
-
-Requires Node.js 22 or newer.
+The `@triplex-build` packages are not yet published. Evaluate this workspace package from a source
+checkout with Node.js 22+ and the repository's locked dependencies. See the
+[quickstart](../../docs/getting-started.md#use-durable-sqlite).
 
 ```ts
 import { SqliteTriples } from "@triplex-build/triplex-sqlite";
@@ -19,7 +17,6 @@ The convenience layer applies Triplex's single v1 migration. Production hosts th
 compose `makeSqliteLayerUnmigrated` and `makeSqliteAdapter({ autoMigrate: false })` with the shared
 `migrations`/`runMigrations` exports from `@triplex-build/triplex-sql`.
 
-SQLite is part of the default shared conformance suite. Pre-1.0 canaries are published under the
-`next` tag.
+SQLite is part of the default shared conformance suite.
 
 MIT © 2026 Ben Jacobson.
diff --git a/packages/testkit/README.md b/packages/testkit/README.md
index 080c00c..723447f 100644
--- a/packages/testkit/README.md
+++ b/packages/testkit/README.md
@@ -2,9 +2,8 @@
 
 Reusable backend fixture and capability helpers for testing Triplex adapters.
 
-```bash
-npm install --save-dev effect@4.0.0-rc.112 @triplex-build/triplex-testkit@next
-```
+The `@triplex-build` packages are not yet published. Evaluate this workspace package from a source
+checkout with the repository's locked Node.js, pnpm, and Effect versions.
 
 `triplesConformanceCases` and `makeTriplesConformanceSuite` define the behavioral contract used by
 the in-memory KV, SQLite, and opt-in PostgreSQL suites. The corpus covers atomic writes, typed
@@ -12,6 +11,4 @@ values, temporal reads, Datalog semantics, stable pagination, the transaction jo
 receipts, checkpoints, derivations, and graph constraints. New backends should pass it before being
 described as supported.
 
-Pre-1.0 canaries are published under the `next` tag.
-
 MIT © 2026 Ben Jacobson.