docs: re-measure the example CRM size (30 files, 1,844 lines, ~17.5k tokens) and state the commit it was measured at

content/blog/context-window-is-the-constraint.mdx

@@ -38,19 +38,25 @@ a dashboard, a lead-conversion flow, permission sets, an action, translations.
 
 | | |
 | :--- | :--- |
-| Files | 31 |
-| Lines | 1,929 |
-| Approximate tokens | ~18,500 |
+| Files | 30 |
+| Lines | 1,844 |
+| Approximate tokens | ~17,500 |
 
 That's the **whole example app**. Not a module of it — the data model, the
 UI, the automation, the access rules, all of it. It fits in about 9% of a
 200k-token context window.
 
-The Todo example is ~24.5k tokens. The kitchen-sink showcase app — which
-deliberately exercises every metadata type in the protocol, 91 files of it — is
-~174k. Even that one, the maximalist case, still fits in a 200k-token window —
+The Todo example is ~25k tokens. The kitchen-sink showcase app — which
+deliberately exercises every metadata type in the protocol, 90 files of it — is
+~175k. Even that one, the maximalist case, still fits in a 200k-token window —
 about 87% of it, leaving about 13% free for the actual work.
 
+These figures were measured at commit
+[`7a6ba0310`](https://github.com/objectstack-ai/objectstack/tree/7a6ba03109dbb7e91359eb0f7f3e64dd1263bca8/examples)
+over the non-test `.ts` files in each example's `src/`, with tokens estimated
+at four bytes each. The examples keep changing, so today's counts will differ a
+little.
+
 Measure your own:
 
 ```bash

content/blog/the-ontology-is-the-software.mdx

@@ -116,8 +116,9 @@ pages that is parsed into a UI tree and never executed as code.
 **The whole system becomes small enough to be held.** The bundled example CRM in
 this repository — accounts, contacts, leads, opportunities, activities, views, a
 dashboard, a lead-conversion flow, permission sets, actions, translations — is
-31 files and roughly 18,500 tokens. That is the whole application, not
-a module of it. An agent can load it end to end, answer *what breaks if I change
+30 files and roughly 17,500 tokens, measured at commit
+[`7a6ba0310`](https://github.com/objectstack-ai/objectstack/tree/7a6ba03109dbb7e91359eb0f7f3e64dd1263bca8/examples/app-crm).
+That is the whole application, not a module of it. An agent can load it end to end, answer *what breaks if I change
 this*, and refactor across data, API, UI, and permissions in a single change.
 We wrote about why that number is the one that matters in
 [The Constraint Isn't Typing Speed. It's the Context Window.](/blog/context-window-is-the-constraint)

content/docs/concepts/metadata-driven.mdx

@@ -228,12 +228,15 @@ actions, translations):
 
 | | |
 | :--- | :--- |
-| Files | 31 |
-| Lines | 1,929 |
-| Approximate tokens | ~18,500 |
+| Files | 30 |
+| Lines | 1,844 |
+| Approximate tokens | ~17,500 |
 
 That's the **whole example app** — about 9% of a 200k-token context window.
-Count it yourself:
+These figures were measured at commit
+[`7a6ba0310`](https://github.com/objectstack-ai/objectstack/tree/7a6ba03109dbb7e91359eb0f7f3e64dd1263bca8/examples/app-crm),
+with tokens estimated at four bytes each. The example keeps changing, so count
+it yourself for today's numbers:
 
 ```bash
 find examples/app-crm/src -name '*.ts' -not -name '*.test.ts' | xargs cat | wc -l

content/docs/getting-started/how-ai-development-works.mdx

@@ -34,8 +34,10 @@ build the thing I actually meant?*
 A typical enterprise app spreads CRUD, forms, queries, permissions, and API glue
 across dozens of files. ObjectStack keeps only the part that's yours: the bundled
 example CRM — six objects, views, a dashboard, a lead-conversion flow,
-permission sets, actions, translations — is **1,929 lines across 31 files, about
-18.5k tokens**. That's the whole example app, not a module of it.
+permission sets, actions, translations — is **1,844 lines across 30 files, about
+17.5k tokens** (measured at commit
+[`7a6ba0310`](https://github.com/objectstack-ai/objectstack/tree/7a6ba03109dbb7e91359eb0f7f3e64dd1263bca8/examples/app-crm)).
+That's the whole example app, not a module of it.
 
 The point isn't lines of code; it's **fit in an agent's context window.** When the
 entire business system is small, typed, and declarative, an agent can load it