site: getting-started now shows the generators are yours to own (#2)

* site: getting-started now shows the generators are yours to own

The scaffold tree and the metaobjects.config.ts example both described an
older, smaller `meta init` scaffold, and between them they silently
contradicted the codegen doctrine (FR-040): generated code is a starting
point adopters copy and own, not something the package hands down.

Scaffold tree: add `codegen/generators/` with its four owned copies
(entity, queries, routes, barrel) and the `src/db.ts` throwing stub, plus
a short paragraph making the ownership point explicit — `meta gen` runs
the local copies, not the package's.

Config example: show the real local import lines, which is the only thing
that tells a reader those four functions come from editable files in
their own repo, and keep enough of the scaffolded comment to carry that.
Adds the extStyle/dbImport/apiPrefix/docs keys the scaffold actually
writes, and drops the commented-out `formFile()` line — it is not part of
the scaffolded set. `meta eject` gets one mention in its place, since
that is the real way to take ownership of a generator init skips.

Also seeds AGENTS.md: llms.txt/llms-full.txt are generated and must not
be hand-edited here, these blocks mirror the CLI's init and drift
silently, and the hand-written gs-code spans need a render check.

The video transcript already stated the doctrine correctly and is
unchanged.

* docs(agents): state the llms.txt situation accurately

The note I added claimed deploy.yml already copies llms.txt/llms-full.txt
in from the monorepo's docs/llms/. It does not — deploy.yml generates
www/reference/ and nothing else. The copy is planned, not landed.

Say so plainly: they are still committed files today, but treat them as
read-only here, because hand-edits will be silently overwritten once the
copy lands. Also records www/reference/ as the one thing that IS
generated at deploy time today.

An agent-memory file that asserts things about its own repo that aren't
true is worse than no note at all.

Author: dmealing

AGENTS.md

@@ -0,0 +1,35 @@
+# Project agent memory
+
+This file is the project's committed home for project-intrinsic agent knowledge: build, test, release, architecture, and sharp-edge notes that should travel with the code.
+
+## Generated files — do not hand-edit
+
+- `www/reference/` is generated at deploy time (`.github/workflows/deploy.yml` clones the
+  public reference implementation and runs `meta docs`). Anything committed there is
+  replaced on every deploy.
+- `www/llms.txt` and `www/llms-full.txt` are **becoming** generated output, copied in from
+  the MetaObjects monorepo's `docs/llms/`. As of this writing `deploy.yml` does not copy them
+  yet — they are still committed files — but treat them as read-only here: once the copy
+  lands, hand-edits made in this repo are silently overwritten. Fix them upstream instead.
+
+## Content that mirrors the CLI
+
+Several code blocks on `www/getting-started.html` reproduce what `meta init` actually writes
+— the scaffold tree, and the `metaobjects.config.ts` example. Nothing checks that they still
+match, so they drift silently when the CLI's scaffold changes. The authoritative source is
+the monorepo's `server/typescript/packages/cli/src/commands/init.ts` (the
+`SCAFFOLDED_GENERATOR_NAMES`, `OWNED_GENERATORS_DIR`, `buildMetaobjectsConfigBody`, and
+`DB_STUB_*` constants). Read it before changing those blocks; don't work from memory.
+
+The page also carries a doctrinal claim worth keeping intact: the generators under
+`codegen/generators/` are copied into the adopter's repo for them to **own and edit**, and
+`meta gen` runs those local copies rather than the packaged ones. `www/video/getting-started.vtt`
+states the same thing — if a page edit contradicts it, the page is the thing that is wrong.
+
+## Editing the `pre.gs-code` blocks
+
+`www/getting-started.html` hand-writes its syntax highlighting with `<span class="c">`
+(comment), `s` (string), `k` (keyword), `n` (the `NEW` marker). An unclosed span or a
+misaligned comment column does not show up in a diff review — render the page and look at
+the block before calling an edit done. In the scaffold tree, the `#` comments all sit at
+visible column 33.

CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

www/getting-started.html

@@ -77,11 +77,18 @@ <h3>Set up the project and the agent context</h3>
           <p>Add the TypeScript CLI and scaffold the workspace. <code>meta init</code> also teaches your coding agent how to use MetaObjects:</p>
           <pre class="gs-code">npm i <span class="s">@metaobjectsdev/cli</span>
 npx meta init</pre>
-          <p>That writes a small, legible tree — <strong>your models go in <code>metaobjects/</code></strong>:</p>
+          <p>That writes a small, legible tree — <strong>your models go in <code>metaobjects/</code></strong>,
+            and the code generators land in your repo too:</p>
           <pre class="gs-code"><span class="c">your-project/</span>
 ├── metaobjects/                 <span class="c"># ← your models live here (.yaml or .json)</span>
 │   └── meta.common.json         <span class="c">#   starter file (shared abstracts)</span>
+├── codegen/generators/          <span class="c"># ← the code generators — YOURS to edit</span>
+│   ├── entity.ts                <span class="c">#   Drizzle table + Zod schemas</span>
+│   ├── queries.ts               <span class="c">#   typed data-access</span>
+│   ├── routes.ts                <span class="c">#   REST endpoints (Fastify)</span>
+│   └── barrel.ts                <span class="c">#   the index.ts re-exports</span>
 ├── metaobjects.config.ts        <span class="c"># ← targets: dialect + what to generate</span>
+├── src/db.ts                    <span class="c"># throwing stub — swap in your DB connection</span>
 ├── CLAUDE.md                    <span class="c"># wired to auto-load the context below</span>
 ├── .metaobjects/                <span class="c"># tool state + agent docs (AGENTS.md, CLAUDE.md)</span>
 └── .claude/skills/              <span class="c"># six skills your agent now has:</span>
@@ -91,6 +98,10 @@ <h3>Set up the project and the agent context</h3>
     ├── metaobjects-prompts/     <span class="c">#   typed LLM prompts</span>
     ├── metaobjects-verify/      <span class="c">#   drift checks</span>
     └── metaobjects-audit/       <span class="c">#   check adoption depth</span></pre>
+          <p>Those four generators under <code>codegen/generators/</code> are the point: they're plain
+            TypeScript, copied into your project, and <strong>yours to edit</strong>. <code>meta gen</code>
+            runs those local copies — not the ones inside the package — so changing the shape of the
+            generated code is an ordinary edit to a file you own.</p>
         </div>
       </div>
     </section>
@@ -138,19 +149,37 @@ <h2 class="section-label">3 · Pick your language</h2>
         </tbody>
       </table>
       <p class="gs-note">For TypeScript, <code>metaobjects.config.ts</code> chooses <em>what</em> you generate — the SQL
-        <code>dialect</code> and which <code>generators</code> run:</p>
+        <code>dialect</code> and which <code>generators</code> run. Note where those generators come from:
+        <code>./codegen/generators/</code>, in your repo. Here's what <code>meta init</code> writes, with its
+        longer comments trimmed:</p>
       <pre class="gs-code"><span class="c">// metaobjects.config.ts</span>
+import { defineConfig } from <span class="s">"@metaobjectsdev/cli"</span>;
+<span class="c">// meta init copied these reference templates into ./codegen/generators/ —</span>
+<span class="c">// they are YOURS to edit, and meta gen runs from these local copies, not</span>
+<span class="c">// from the package.</span>
+import { entityFile } from <span class="s">"./codegen/generators/entity.js"</span>;
+import { queriesFile } from <span class="s">"./codegen/generators/queries.js"</span>;
+import { routesFile } from <span class="s">"./codegen/generators/routes.js"</span>;
+import { barrel } from <span class="s">"./codegen/generators/barrel.js"</span>;
+
 export default defineConfig({
-  outDir:  <span class="s">"src/generated"</span>,
-  dialect: <span class="s">"sqlite"</span>,        <span class="c">// sqlite | postgres | d1</span>
+  outDir:    <span class="s">"src/generated"</span>,
+  extStyle:  <span class="s">"js"</span>,        <span class="c">// ".js" import suffixes — right for Node ESM + tsc</span>
+  dialect:   <span class="s">"sqlite"</span>,    <span class="c">// sqlite | postgres | d1</span>
+  dbImport:  <span class="s">"../db"</span>,     <span class="c">// the src/db.ts stub — swap in your real DB</span>
+  apiPrefix: <span class="s">""</span>,          <span class="c">// set to "/api" to mount the routes under /api</span>
   generators: [
-    entityFile(),               <span class="c">// Drizzle table + Zod schemas + typed constants</span>
-    queriesFile(),              <span class="c">// typed data-access (findById, list, create…)</span>
-    routesFile(),               <span class="c">// REST endpoints (Fastify)</span>
-    <span class="c">// formFile(),              // opt-in: React form components</span>
-    barrel(),
+    entityFile(),           <span class="c">// Drizzle table + Zod schemas + typed constants</span>
+    queriesFile(),          <span class="c">// typed data-access (findById, list, create…)</span>
+    routesFile(),           <span class="c">// REST endpoints (Fastify)</span>
+    barrel(),               <span class="c">// src/generated/index.ts re-exports</span>
   ],
+  docs: { outDir: <span class="s">"./docs"</span>, surfaces: [<span class="s">"model"</span>, <span class="s">"api"</span>] },
 });</pre>
+      <p class="gs-note">Those four are what <code>meta init</code> wires up. There are more — React forms,
+        TanStack hooks and grids, Hono routes — and you take ownership of one the same way:
+        <code>meta eject --list</code> shows what's available, and <code>meta eject form</code> copies it
+        into <code>codegen/generators/</code> and prints the import line to wire up.</p>
     </section>
 
     <section>