okengine 0.18.4 → 0.18.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okengine",
-  "version": "0.18.4",
+  "version": "0.18.5",
   "description": "One law. Eight elements. One contract. The backend model stays small; operational surfaces are derived from it instead of maintained separately.",
   "license": "MIT",
   "repository": {

package/site/content/docs/ai/index.mdx

@@ -5,20 +5,39 @@ icon: "Bot"
 source: "docs/spec/unified-theory.md"
 ---
 
-Resources for AI agents that read or operate an OKE app — not the `ai` element itself. In OKE, **MCP is a surface of the model, not the model itself**. Gate governs agents calling in; the AI element governs apps calling out.
+Resources for AI agents that inspect, understand, or operate an OKEngine application.
 
-## Pages
+<Callout title="Two directions, one model">
+  **MCP is a surface of the model, not the model itself.** Gate governs agents calling in; the AI
+  element governs applications calling out to models.
+</Callout>
+
+```text
+External Agents → MCP (:6535) → Gate Check → Flow (inbound)
+Flow → fx.ask / fx.stream → AI Runtime → Models & External Tools (outbound)
+```
+
+## AI & Agent Surfaces
 
 <Cards>
-  <Card title="MCP" description="Runtime MCP on :6535; docs MCP on :6536." href="/docs/ai/mcp" />
   <Card
-    title="Skills"
-    description="AGENTS.md contract and installable skills."
+    title="MCP"
+    description="Runtime MCP on :6535 for running apps; Docs MCP on :6536 for handbook search."
+    href="/docs/ai/mcp"
+  />
+  <Card
+    title="Agent Skills"
+    description="AGENTS.md contract and autonomous maintenance skills."
     href="/docs/ai/skills"
   />
   <Card
     title="llms.txt"
-    description="Index, JSON catalogue, full dump, per-page markdown."
+    description="Standardized machine-readable feeds: /llms.txt, /llms.json, /llms-full.txt, and markdown twins."
     href="/docs/ai/llms-txt"
   />
+  <Card
+    title="AI Element"
+    description="Calling out: models, prompts, agents, and RAG inside your application."
+    href="/docs/elements/ai"
+  />
 </Cards>

package/site/content/docs/elements/index.mdx

@@ -1,45 +1,76 @@
 ---
 title: "Elements"
-description: "The eight irreducible parts of an OKE backend — Flow through AI, one page each."
+description: "The eight closed semantic primitives of the OKEngine backend model."
 icon: "Boxes"
 source: "docs/spec/unified-theory.md"
 ---
 
-Every backend concern collapses to one of these eight. Pick the element you need.
+Forty backend concerns collapse into eight semantic primitives. An element earns its place only with **irreducible physics**.
 
-## Pages
+<Callout title="Closed primitive set">
+  There is no ninth element. New infrastructure creates a protocol driver or plugin, preserving a
+  small mental model.
+</Callout>
+
+```text
+Elements define the model.
+Plugins extend the model's capabilities.
+Drivers connect the model to infrastructure.
+Providers and Recipes choose where that infrastructure runs.
+```
+
+## The Eight Primitives
 
 <Cards>
-  <Card title="Flow" description="Behavior — on(Trigger) → Effects." href="/docs/elements/flow" />
+  <Card
+    title="Flow"
+    description="Behavior — on(Trigger) → Effects via fx."
+    href="/docs/elements/flow"
+  />
   <Card
     title="Signal"
-    description="Data in motion — queues, pub/sub, streams."
+    description="Data in motion — delivery physics as a property (once, broadcast, live)."
     href="/docs/elements/signal"
   />
   <Card
     title="Store"
-    description="Data at rest — sql, kv, files, index."
+    description="Data at rest — SQL, KV, files with image transforms, and search."
     href="/docs/elements/store"
   />
   <Card
     title="Clock"
-    description="Time — schedules, intervals, durable sleeps."
+    description="Time — schedules, intervals, durable sleeps, and time travel."
     href="/docs/elements/clock"
   />
   <Card
     title="Gate"
-    description="Permission to act — auth and rate limits."
+    description="Permission to act — auth, tenancy, ABAC, and rate limits at the trigger."
     href="/docs/elements/gate"
   />
   <Card
     title="Vault"
-    description="Protected knowledge — secrets and keys."
+    description="Protected knowledge — fail-loud secret contracts and redacted values."
     href="/docs/elements/vault"
   />
   <Card
     title="Channel"
-    description="Reaching humans — email, SMS, push."
+    description="Reaching humans — email, SMS, WhatsApp, and push with built-in consent."
     href="/docs/elements/channel"
   />
-  <Card title="AI" description="Reaching machine intelligence." href="/docs/elements/ai" />
+  <Card
+    title="AI"
+    description="Reaching machine intelligence — models, prompts, agents, and RAG."
+    href="/docs/elements/ai"
+  />
 </Cards>
+
+## See How They Compose
+
+The closed elements compose into full backend capabilities:
+
+| Composition Target | Formula                                         | How It Works                                              |
+| ------------------ | ----------------------------------------------- | --------------------------------------------------------- |
+| **Realtime**       | Store + Gate + Signal + Flow → Live Query       | CDC changes re-checked against Gate RLS, streamed as SSE  |
+| **Security**       | Gate + Store/RLS + Tenant + fx → Secure runtime | Tenant-isolated queries with least-privilege capability   |
+| **Agents**         | MCP + Gate + OAuth + Flow → Agent-ready backend | Declared Flows exposed on :6535 behind auth confirmation  |
+| **Operations**     | Manifest + Effects + Runs → Inspectable backend | Inferred effects feed Console (:6533) and wide-event logs |

package/site/content/docs/get-started/introduction.mdx

@@ -1,22 +1,13 @@
 ---
 title: Introduction
-description: Learn the one idea behind okengine — then the eight elements and core programming vocabulary you will use everywhere.
+description: The Law, the eight elements, the fx rule, and the compiled Manifest contract.
 source: docs/spec/unified-theory.md
 icon: BookOpen
 ---
 
-## The One Idea
+## The One Law
 
-A booking API, a nightly cleanup job, a receipt email, a row-change hook — in most stacks those are four frameworks. In OKE they are **one species** with one shape. Learn the shape once; only the trigger changes.
-
-> **The one rule**
-> Every backend behavior is a **Flow**: `on(Trigger) → Effects`. There are no separate species called endpoints, handlers, consumers, jobs, or workflows.
-
-## Quick Start
-
-### Write One Flow
-
-Four contracts plus a `do`. This is the standard starter's health check:
+Every backend behavior is a Flow: `on(Trigger) → Effects`.
 
 ```typescript
 import { on, flow, http } from "okengine/http";
@@ -24,11 +15,11 @@ import { on, flow, http } from "okengine/http";
 export const health = on(http.get().public(), flow({ do: () => ({ ok: true }) }));
 ```
 
-`main` omits the URL prefix, so this file is `GET /health` named `main.health`. See [Project structure](/docs/get-started/project-structure). Explicit `http.get("/health")` and `flow("main.health")` still win.
+An endpoint, a nightly cleanup cron, a queue consumer, a row-change CDC hook — these are not four frameworks. They are **one species** with one shape. Only the trigger changes.
 
-### Change Only the Trigger
+## Changing Only the Trigger
 
-Triggers define what starts the flow. Changing the trigger replaces the entire behavior while keeping the same structure:
+Triggers determine what starts the flow while preserving identical anatomy and effect tracking:
 
 | Trigger                            | Starts when        | Replaces           |
 | ---------------------------------- | ------------------ | ------------------ |
@@ -46,9 +37,9 @@ on(orderPlaced, sendReceipt);
 on(db.table(users).changed("email"), reverify);
 ```
 
-## Anatomy
+## Anatomy of a Flow
 
-One pipeline. Only the trigger changes between an endpoint, a job, a consumer, and a row hook.
+Every Flow consists of four clear sections:
 
 | Piece         | Role                                                           |
 | ------------- | -------------------------------------------------------------- |
@@ -57,35 +48,53 @@ One pipeline. Only the trigger changes between an endpoint, a job, a consumer, a
 | **`do`**      | The body — every read, write, emit, and call goes through `fx` |
 | **Effects**   | Inferred from those `fx` calls — not hand-annotated            |
 
-Consequence: One documentation path, one trace shape, one Flow model, one thing for an AI agent to learn.
+```typescript
+export const createOrder = on(
+  http.post("/orders"),
+  flow("orders.create", {
+    in: OrderInput,
+    out: OrderResult,
+    do: async (input, fx) => {
+      const order = await fx.store(db).insert(orders).values(input);
+      await fx.emit(orderPlaced, { orderId: order.id });
+      return order;
+    },
+  }),
+);
+```
 
 ## The `fx` Rule
 
-**All world access goes through `fx`.** A Flow that imports `node:fs`, calls `fetch` directly, or uses `Date.now()` is a defect.
+**All world access goes through `fx`.**
+
+<Callout title="Single door to the world">
+  Nothing in user flows imports `node:fs`, calls global `fetch`, or calls `Date.now()`. Every effect
+  is recorded on the effect ledger.
+</Callout>
 
-| Inferred From           | With `fx` |
-| ----------------------- | --------- |
-| Cache invalidation keys | Yes       |
-| Live queries            | Yes       |
-| Least-privilege tokens  | Yes       |
-| Deterministic tests     | Yes       |
-| Manifest Diff           | Yes       |
+| Inferred from `fx`      | What it powers                       |
+| ----------------------- | ------------------------------------ |
+| Cache invalidation keys | Invalidation follows the flow writes |
+| Live queries            | Realtime CDC subscriptions           |
+| Least-privilege tokens  | Compiler-derived capability matrix   |
+| Deterministic tests     | Injected time, clock, and stores     |
+| Manifest Diff           | Blast-radius checks on every save    |
 
-## What the Manifest Derives
+## The Compiled Manifest
 
-At build time OKE extracts a **Manifest** — a machine-readable description of your system. You do not maintain a second source of truth.
+The source of truth is the backend model expressed in code. The **Manifest** is the compiled, versioned contract representing that model.
 
-| Surface                           | Port / Place       | You Maintain?                 |
+| Surface                           | Port               | You Maintain?                 |
 | --------------------------------- | ------------------ | ----------------------------- |
-| Typed client (`okengine/client`)  | your app code      | No separate codegen           |
-| Console panels, traces, explorers | `:6533`            | No                            |
-| MCP for agents                    | `:6535`            | No                            |
+| Typed client (`okengine/client`)  | your app code      | No — derived from Manifest    |
+| Console panels, traces, explorers | `:6533`            | No — reads the Manifest       |
+| MCP for agents                    | `:6535`            | No — reads the Manifest       |
 | Architecture diagram              | Console            | No — it _is_ the effect graph |
-| Capability matrix + cache keys    | compiler / runtime | No — from `fx`                |
+| Capability matrix + cache keys    | compiler / runtime | No — inferred from `fx`       |
 
 ## The Eight Elements
 
-An element earns its place only if it has **irreducible physics**. New infrastructure becomes a new **driver** — never a ninth element.
+An element earns its place only if it has **irreducible physics**.
 
 | Element     | Essence                       | Replaces the Zoo                                          |
 | ----------- | ----------------------------- | --------------------------------------------------------- |
@@ -98,35 +107,38 @@ An element earns its place only if it has **irreducible physics**. New infrastru
 | **Channel** | Reaching humans               | email · SMS · WhatsApp · push                             |
 | **AI**      | Reaching machine intelligence | model calls · prompts · embeddings · agents · RAG         |
 
+New infrastructure becomes a **driver** for an existing element, never a ninth.
+
 ## Core Programming Vocabulary
 
-The core programming vocabulary fits in one import. Everything else in the docs is derived from these names:
+The core programming vocabulary is ten exported names:
 
-```ts
+```typescript
 import { on, flow, signal, store, clock, gate, vault, channel, ai, plugin } from "okengine";
 ```
 
-For HTTP-only apps, prefer the slim entry so the cold graph stays on the edge:
+For HTTP runtime essentials, use the slim entry `okengine/http`:
 
-```ts
+```typescript
 import { on, flow, http, gate, oke, createBunRuntime } from "okengine/http";
 ```
 
-Heavy surfaces (runs, journal factories, compiler extract, the legacy mega-barrel) live on `okengine/runs`, `okengine/journal`, `okengine/compiler`, and `okengine/full`.
-
-## Learn More
-
-| Topic   | Page                                                                            |
-| ------- | ------------------------------------------------------------------------------- |
-| Why OKE | [Why OKE](/docs/get-started/why)                                                |
-| Folders | [Project structure](/docs/get-started/project-structure)                        |
-| Flow    | [Flow](/docs/elements/flow)                                                     |
-| `fx`    | [fx](/docs/reference/fx)                                                        |
-| Agents  | [MCP](/docs/ai/mcp) · [Skills](/docs/ai/skills) · [llms.txt](/docs/ai/llms-txt) |
-
 ## Next Steps
 
-- [Why OKE](/docs/get-started/why)
-- [Installation](/docs/get-started/installation)
-- [Basic Usage](/docs/get-started/basic-usage)
-- [Project Structure](/docs/get-started/project-structure)
+<Cards>
+  <Card
+    title="Why OKE"
+    description="Explore the problem of seams and the smaller model."
+    href="/docs/get-started/why"
+  />
+  <Card
+    title="Installation"
+    description="Scaffold a new OKEngine project with create-oke."
+    href="/docs/get-started/installation"
+  />
+  <Card
+    title="Basic Usage"
+    description="Write your first flow and verify it with bun test."
+    href="/docs/get-started/basic-usage"
+  />
+</Cards>

package/site/content/docs/get-started/why.mdx

@@ -1,162 +1,114 @@
 ---
 title: Why OKE
-description: From forty tools to one species — the Manifest, the `fx` rule, and the eight closed elements.
+description: The problem of seams across independent backend tools, the insight, and the smaller model.
 source: docs/spec/unified-theory.md
 icon: Compass
 ---
 
-## From forty tools to one species
+## The Problem: The Seams You Own
 
-A booking API, a nightly cleanup job, a receipt email, a row-change hook — in most stacks these are **four frameworks**. In OKE they are **one species** with one shape. Learn the shape once; only the trigger changes.
-
-> **The one rule**
-> Every backend behavior is a **Flow**: `on(Trigger) → Effects`. There are no separate species called endpoints, handlers, consumers, jobs, or workflows.
+Modern backends accumulate many independently adopted systems: router, queue, cron, websockets, cache, secrets, mailer, AI wrappers, and observability.
 
 <Callout title="A note on the count">
   'Forty' is a representative illustration of the number of backend concerns developers commonly
-  assemble across modern stacks, not a literal count of backend technologies.
+  assemble across modern stacks, not a literal census.
 </Callout>
 
-## The pain we solve
-
-Every TypeScript backend works on day one. The bill arrives later. None of these are router problems — they are **gaps** between what your code knows and what your tooling knows.
-
-### Cache that lies
-
-You add a column to `orders` and update three writers. The cache key in `checkout` is not one of them. A customer finds it a week later.
-
-OKE derives: reads and writes are recorded through `fx`, so cache invalidation follows the Flow — there is no separate key to remember.
+```text
+many systems → many seams → many contracts → many mental models
+```
 
-### Secret that fails at 2am
+Every TypeScript backend works on day one. The bill arrives later in the seams:
 
-`STRIPE_KEY` lives in your laptop's `.env`, a README, and a teammate's shell history. The deploy boots fine — the first charge request dies at 2am.
+- **Cache that lies:** You update a writer, but forget the cache key in checkout.
+- **Secret that fails at 2am:** Deploy boots fine; the first charge fails because the env var was missed.
+- **Permission checks in the wrong place:** Auth logic scattered across handlers instead of verified at the trigger.
+- **The dashboard that doesn't know you:** Observability tools learn routes from traffic samples instead of the compiled model.
 
-OKE derives: [Vault](/docs/elements/vault) contracts declare the need in code; boot resolves every contract and **fails loud** with every gap listed — never halfway.
+## The Insight: One Programming Model
 
-### The glue you rewrite
+These concerns do not need to become separate programming concepts. They collapse into one closed set:
 
-CORS rules, security headers, CSRF tokens, compression — copied from the last repo, tweaked, and already drifting from whatever that repo does today.
+```text
+Many backend concerns → One programming model
+```
 
-OKE derives: the official `okengine/plugins` set ships this glue once — shared lifecycle, optional live DB config, nothing to re-copy.
+> **One law. Eight elements. One contract.**
 
-### The dashboard that doesn't know you
+## Wrong vs. Right Mental Model
 
-Your observability stack learned your routes from sampled traffic. The Flow you deployed an hour ago is invisible until someone wires it by hand.
+Understanding OKE begins by rejecting the conventional feature-pile model:
 
-OKE derives: its operator interface reads the Manifest — flows, effects, traces, architecture — current on every save, in dev and prod (`:6533`).
+| ❌ Wrong Mental Model (Feature Bundle) | ✅ OKEngine Model (Unified Primitives) |
+| -------------------------------------- | -------------------------------------- |
+| Router + Queue + Cron + Auth + ORM     | `on(Trigger) → Flow` (One species)     |
+| Separate mental model per tool         | Eight closed semantic elements         |
+| Ad-hoc side effects everywhere         | Single door to the world: `fx`         |
+| Hand-maintained glue & OpenAPI         | Compiled Manifest contract             |
+| Unchecked runtime drift                | Derived, inspectable surfaces          |
 
-### Permission check in the wrong place
+The difference is not how many features OKE has. It is how few concepts you need to understand.
 
-`if (!user.isAdmin)` sits in handler forty-one of sixty. Which Flows touch `payments`? grep answers slowly; review answers never.
+## The Law and the `fx` Rule
 
-OKE derives: declared effects produce a **least-privilege matrix** — widening access appears in Manifest Diff, not in a diff nobody reads.
+Every backend behavior is a Flow:
 
-### Local works, prod doesn't
+```typescript
+import { on, flow, http } from "okengine/http";
 
-Local runs one vendor client, CI another, prod a third — three glue stories for the same database.
+export const health = on(http.get().public(), flow({ do: () => ({ ok: true }) }));
+```
 
-OKE derives: drivers are named after protocols (`postgres`, `redis`, `s3`), the vendor lives in `images`, and `oke dev` runs the real stack locally.
+**All world access goes through `fx`.** A Flow that calls `fetch` directly, imports `node:fs`, or uses `Date.now()` is a defect.
 
----
+```text
+Flow → fx → observable Effects → Compiler → Manifest → Surfaces
+```
 
-Every gap above is the same shape: knowledge the code already has, duplicated somewhere the compiler cannot check. **The tax is drift.** One change costs fifteen seams to update by hand; in OKE it always costs one.
+Because all effects pass through `fx`, the compiler infers cache keys, capability matrices, and trace trees without manual annotations.
 
-## One Manifest feeds every surface
+## One Contract, Many Surfaces
 
-At build time OKE extracts a **Manifest** — the compiled, versioned contract between your backend model and everything derived from it. The source of truth is your model expressed in code (`on(Trigger) → Flow → fx → Effects`); the Manifest freezes that model into a machine-readable, diffable contract. You do not write or hand-maintain the Manifest:
+The source of truth is the backend model expressed in code. The **Manifest** is the compiled, versioned contract representing that model.
 
-| Surface                           | Port               | You maintain?                 |
+| Surface                           | Port               | You Maintain?                 |
 | --------------------------------- | ------------------ | ----------------------------- |
-| Typed client (`okengine/client`)  | your app code      | No — derived from `Manifest`  |
+| Typed client (`okengine/client`)  | your app code      | No — derived from Manifest    |
 | Console panels, traces, explorers | `:6533`            | No — reads the Manifest       |
 | MCP for agents                    | `:6535`            | No — reads the Manifest       |
 | Architecture diagram              | Console            | No — it _is_ the effect graph |
 | Capability matrix + cache keys    | compiler / runtime | No — inferred from `fx`       |
 
-Because every surface reads the same Manifest contract, they **cannot disagree** — there is only one source of truth.
-
-## The `fx` rule — one door to the world
+Operational surfaces are derived, not separately maintained.
 
-**All world access goes through `fx`.** A Flow that imports `node:fs`, calls `fetch` directly, or uses `Date.now()` is a defect. Effects are **inferred from what a Flow touches through `fx`**, and that inference powers the Manifest, the Console, caching, and durability.
-
-<Callout title="What `fx` records">
-  Every read, write, emit, send, ask, secret, and call is captured — so the Manifest knows exactly
-  which flows touch `orders` or send PII to a model, without you declaring it.
-</Callout>
+## See the Model Compose
 
-| Inferred from `fx`      | What it gives you                    |
-| ----------------------- | ------------------------------------ |
-| Cache invalidation keys | Automatic — follows the Flow         |
-| Live queries            | Built-in subscription model          |
-| Least-privilege tokens  | Capability matrix from effects       |
-| Deterministic tests     | Time, clock, and randomness injected |
-| Manifest Diff           | Exact change surface on every save   |
+OKE does not add new subsystems when new architectural requirements emerge. The eight closed primitives compose naturally:
 
-## Eight elements — a closed set
+- **Realtime:** `Store + Gate + Signal + Flow → Live Query` (Global CDC + RLS re-check + SSE).
+- **Security:** `Gate + Store/RLS + Tenant + fx → Secure execution` (Unified user, operator, and agent boundaries).
+- **Agents:** `MCP + Gate + OAuth + Flow → Agent-accessible backend` (Exposing Flows as MCP tools).
+- **Operations:** `Manifest + Effects + Runs → Inspectable backend` (Wide-event telemetry and live graphs).
 
-Forty infrastructure concerns collapse into eight elements — each kept only because it has **irreducible physics**. New infrastructure becomes a **driver** for an existing element, never a ninth.
+> **None of these required a ninth primitive.**
 
-| Element     | Essence                       | Replaces the zoo                                          |
-| ----------- | ----------------------------- | --------------------------------------------------------- |
-| **Flow**    | Behavior                      | endpoint · handler · consumer · job · workflow · webhook  |
-| **Signal**  | Data in motion                | queue · pub/sub · stream · websocket · SSE · event bus    |
-| **Store**   | Data at rest                  | database · cache · KV · file storage · search index       |
-| **Clock**   | Time                          | cron · delay · timeout · durable sleep · TTL              |
-| **Gate**    | Permission to act             | auth · session · ABAC · rate limit · quota · feature flag |
-| **Vault**   | Protected knowledge           | secrets · config · environment                            |
-| **Channel** | Reaching humans               | email · SMS · WhatsApp · push                             |
-| **AI**      | Reaching machine intelligence | model calls · prompts · embeddings · agents · RAG         |
+## Core Philosophy
 
-Drivers are named after **protocols** (`postgres`, `redis`, `s3`) — never vendors. The vendor lives in `images`, and `oke dev` runs the real stack locally.
+> **Keep the model small. Let the backend grow without growing the mental model.**
 
-## The shape of a Flow
+Your backend is not just executable. It is inspectable.
 
-One pipeline. Only the trigger changes between an endpoint, a job, a consumer, and a row hook:
-
-```ts
-import { on, flow, http } from "okengine/http";
-
-export const health = on(http.get().public(), flow({ do: () => ({ ok: true }) }));
-```
-
-| Piece         | Role                                                           |
-| ------------- | -------------------------------------------------------------- |
-| **Trigger**   | How work starts — `http`, a signal, `every`, a row change      |
-| **Contracts** | `in`, `out`, typed `errors` — validated before and after `do`  |
-| **`do`**      | The body — every read, write, emit, and call goes through `fx` |
-| **Effects**   | Inferred from those `fx` calls — not hand-annotated            |
-
-Consequence: **one documentation path, one trace shape, one Flow model, one thing for an AI agent to learn.**
-
-## Ambition, stated plainly
-
-> **Ambition**: The default, most capable TypeScript backend — Bun-first, Web-Standards portable, contract-first  
-> **Grounded in**: Eight elements, effect inference through `fx`, Gate and Vault, the official plugin set  
-> **Maturity**: **pre-1.0** — published and usable; not independently battle-tested at scale yet
-
-## Learn more
-
-- [Introduction](/docs/get-started/introduction) — the one law, eight elements, one contract
-- [Flow](/docs/elements/flow) — how effects are recorded and inferred
-- [Vault](/docs/elements/vault) — fail-loud secret contracts
-- [Plugins](/docs/reference/plugins) — the official HTTP glue set
-
-## Next
+## Next Steps
 
 <Cards>
-  <Card
-    title="Installation"
-    description="Scaffold with create-oke and open the Console."
-    href="/docs/get-started/installation"
-  />
-  <Card
-    title="Basic Usage"
-    description="Health Flow, typed client, and bun:test."
-    href="/docs/get-started/basic-usage"
-  />
   <Card
     title="Introduction"
-    description="The one law, eight elements, one contract."
+    description="The Law, Flow anatomy, and the eight elements."
     href="/docs/get-started/introduction"
   />
+  <Card
+    title="Installation"
+    description="Scaffold your first project with create-oke."
+    href="/docs/get-started/installation"
+  />
 </Cards>