create-holon 0.1.0

package/LICENSE.md

@@ -0,0 +1,36 @@
+# Nomos Pre-Release License (v1)
+
+Copyright © 2026 Captain App Ltd. All rights reserved.
+
+This is a pre-release of Nomos. This license gives you what you need to BUILD
+with it; we keep the rest for now.
+
+## You may
+
+- install and use these packages to author Nomos domains, compile them, and
+  deploy them to Nomos Cloud or any Nomos instance Captain App operates or
+  authorizes;
+- build, run, and ship applications on top of them — including commercial ones;
+- keep everything that's yours: code you write, and everything these tools
+  generate FOR you (scaffolds from `create-holon` / `holon generate`, generated
+  clients, compiled domain packages) carries NO restriction from us — it is
+  yours outright.
+
+## You may not
+
+- redistribute these packages or their source, in whole or in part, outside
+  your team;
+- modify them or build derivative tools, SDKs, or runtimes from their source;
+- offer the Nomos runtime, or anything materially similar, as a hosted service;
+- reverse-engineer the holon wasm runtime.
+
+## The rest
+
+Provided **as is**, with no warranty of any kind; to the maximum extent
+permitted by law, Captain App Ltd accepts no liability arising from your use.
+This license terminates automatically if you breach it.
+
+Want the kernel source, broader rights, or to do something this doesn't cover?
+**Ask: jack@captainapp.co.uk.** The plan is to open Nomos up gradually, with
+the people actually using it — telling us what you're building is how that
+happens faster.

package/index.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+// `npm create holon <dir>` — scaffold a Nomos domain package (the starter
+// guestbook domain + compile config + live e2e) into <dir> and init it as a
+// git repo. The holon itself is MINTED LOCALLY after compile (`holon ledger
+// init holon` — genesis + your law under YOUR identity, verified by the same
+// wasm gate the cloud runs), so it is yours from the first byte. Plain node,
+// zero dependencies; the heavy lifting (compile, codegen, the engine) lives in
+// @githolon/dsl and @githolon/cli and arrives with the scaffold's `npm install`.
+//
+// Everything scaffolded here belongs to the user — see LICENSE.md ("You may /
+// keep everything that's yours").
+import { spawnSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const TEMPLATE = path.join(path.dirname(fileURLToPath(import.meta.url)), "template");
+
+const args = process.argv.slice(2);
+if (args.includes("-h") || args.includes("--help")) {
+  process.stdout.write(
+    "create-holon — scaffold a Nomos domain package\n\n" +
+      "Usage:\n  npm create holon <dir>        (or: npx create-holon <dir>)\n\n" +
+      "Scaffolds the starter domain + compile config + live e2e into <dir>\n" +
+      "(default: my-holon-app) and inits a git repo. After `holon compile`,\n" +
+      "`holon ledger init holon` mints YOUR holon locally — verified by the\n" +
+      "same wasm gate the cloud runs, ready to birth by git push.\n\n" +
+      "Flags:\n  --no-git    skip git init\n",
+  );
+  process.exit(0);
+}
+const noGit = args.includes("--no-git");
+const dirArg = args.find((a) => !a.startsWith("-"));
+
+const targetDir = path.resolve(process.cwd(), dirArg ?? "my-holon-app");
+const appName = path
+  .basename(targetDir)
+  .toLowerCase()
+  .replace(/[^a-z0-9-_.]+/g, "-")
+  .replace(/^[-_.]+|[-_.]+$/g, "");
+if (!appName) {
+  console.error(`create-holon: '${path.basename(targetDir)}' does not reduce to a valid package name`);
+  process.exit(1);
+}
+
+if (existsSync(targetDir) && readdirSync(targetDir).length > 0) {
+  console.error(`create-holon: refusing to scaffold into non-empty directory: ${targetDir}`);
+  process.exit(1);
+}
+
+mkdirSync(targetDir, { recursive: true });
+cpSync(TEMPLATE, targetDir, { recursive: true });
+
+// npm strips dotfiles from published packages — the template ships `gitignore`
+// and the scaffold restores the dot.
+renameSync(path.join(targetDir, "gitignore"), path.join(targetDir, ".gitignore"));
+
+for (const f of ["package.json", "README.md"]) {
+  const p = path.join(targetDir, f);
+  writeFileSync(p, readFileSync(p, "utf8").replaceAll("__APP_NAME__", appName), "utf8");
+}
+
+const git = (cmd) => spawnSync("git", cmd, { cwd: targetDir, stdio: "ignore" }).status === 0;
+
+// git init. Degrades gracefully: no git leaves a perfectly usable scaffold.
+let gitInited = false;
+if (!noGit) {
+  gitInited = git(["init", "-b", "main"]) || git(["init"]);
+  if (gitInited) {
+    git(["add", "-A"]);
+    // Identity fallback keeps the initial commit working on unconfigured machines.
+    git(["commit", "-m", "scaffold: create-holon starter"]) ||
+      git(["-c", "user.name=create-holon", "-c", "user.email=create-holon@nomos", "commit", "-m", "scaffold: create-holon starter"]);
+  }
+}
+
+const rel = path.relative(process.cwd(), targetDir) || ".";
+process.stdout.write(
+  `\nScaffolded ${appName} into ${rel}/${gitInited ? " (git repo)" : ""}\n` +
+    `\nNext:\n` +
+    `  cd ${rel}\n` +
+    `  npm install\n` +
+    `  npx holon compile        # → build/: deployable package + manifests + typed client\n` +
+    `  npx holon login --agent  # a verified identity, no browser\n\n` +
+    `Then pick a path (README.md walks both):\n` +
+    `  A) npx holon ws create <ws> && npx holon deploy <ws>\n` +
+    `  B) npx holon ledger init holon   # YOUR holon, minted + verified LOCALLY\n` +
+    `     cd holon && npx holon git remote <ws> && git push nomos main\n`,
+);

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "create-holon",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Scaffold a Nomos domain package: the starter domain + compile config + live e2e. `npm create holon my-app`.",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Captain-App/nomos2.git",
+    "directory": "create-holon"
+  },
+  "bin": {
+    "create-holon": "./index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "template"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/template/README.md

@@ -0,0 +1,67 @@
+# __APP_NAME__ — a Nomos domain package
+
+Scaffolded by `npm create holon`. One domain file, one config, one command —
+then an offline-first typed client against Nomos Cloud. Two ways to get a live
+workspace; both end in the same place.
+
+```bash
+npm install
+npx holon compile          # → build/: deployable package + manifests + typed client
+npx holon login --agent    # self-onboard a verified identity (no browser; linkable to a full account later)
+```
+
+## Path A — deploy your law
+
+```bash
+npx holon ws create <ws>   # births a fresh workspace on your identity; SAVES its one-time secret to ~/.holon
+npx holon deploy <ws>      # POSTs build/guestbook.deploy.json with the stored secret
+npm run e2e                # the full loop, live: offline write → sync → admission → cloud query
+```
+
+## Path B — mint a holon LOCALLY, push it, the cloud agrees
+
+This is the point of holons: predefined law you can assert to be true on your
+own machine, then have independently validated in the cloud. `ledger init`
+builds a brand-new GitHolon ledger locally — genesis (the nomos controller),
+then YOUR compiled law, every intent stamped `installedBy: <your identity>` —
+and verifies the chain with the SAME byte-identical wasm gate the cloud runs.
+Pushing it to an unborn workspace makes the cloud replay-verify the whole chain
+from genesis and re-derive your exact verdict (same head, same plans re-run)
+before serving anything. Authority lives in the git; no holon outranks another.
+
+```bash
+npx holon ledger init holon    # mint + assert locally: chain VALID, head <h>, under YOUR uid
+npx holon ledger verify holon  # re-assert any time
+cd holon
+npx holon git remote <ws>      # wires the remote + credential helper; mints + stores the owner secret
+git push nomos main            # the upload birth — the cloud re-derives the verdict, byte-identical adoption
+npx holon deploy <ws>          # idempotent (alreadyInstalled) + stages the read manifests so queries route
+cd ..
+```
+
+After birth, `holon/` tracks YOUR workspace: new writes admitted on main arrive
+with `git pull`. (`holon git setup` installed a git credential helper, so plain
+git just works against the cloud.)
+
+## What's here
+
+- `domains/guestbook.ts` — the starter domain (the law): one aggregate, two
+  directives, a declared query, a derived field, a count. Rename it, reshape
+  it, or add domains with `npx holon generate domain <name>`.
+- `nomos.package.mjs` — the compile config (module list per domain key; reads
+  are auto-discovered from exports).
+- `build/guestbook.client.ts` — GENERATED typed TS client (payload types from
+  the engine's zod, read models from the field kinds, the law hash baked in).
+- `test/e2e.mts` — proves compile → deploy → typed offline write/query →
+  edge admission → cloud declared query, against the live cloud.
+- `holon/` (after `ledger init`) — YOUR ledger, a normal git repo. Inspect it:
+  every commit is an intent envelope; `git log` IS the audit trail.
+
+## Authoring rules (the engine enforces these)
+
+- A directive's plan is a PURE function of `(payload, ports)` — timestamps ride
+  in the payload as ISO strings; no `Date.now()` / `Math.random()`.
+- `create(Agg)` mints ids — `.creates` payloads never carry one.
+- Merge drivers are the law: `Lww`, `AddWins`, `MapOf(Lww)`.
+
+Everything you write here, and everything the tools generate for you, is yours.

package/template/domains/guestbook.ts

@@ -0,0 +1,130 @@
+/**
+ * guestbook — the smallest complete Nomos tenant domain, written the only way a
+ * domain is ever written: aggregates + directives on `@githolon/dsl`. No apply/fold/
+ * merge code — the kernel owns folding; the directive plans ops, the sealed engine
+ * replays them deterministically on every peer.
+ *
+ * What it shows:
+ *   * an aggregate with Lww scalars, an AddWins set, and a MapOf(Lww) map;
+ *   * a `.creates` directive (Nomos mints the aggregate id — never the caller);
+ *   * a `.mutates` directive bound to an existing instance;
+ *   * a declared, indexed read query (auto-discovered by `nomos-compile`);
+ *   * a DERIVED read field (engine-projected, PURE fn of the folded fields);
+ *   * a COUNT (a maintained tally, grouped by a field).
+ */
+import { z } from "zod";
+import {
+  aggregate,
+  t,
+  Lww,
+  AddWins,
+  MapOf,
+  directive,
+  create,
+  instance,
+  set,
+  setEntry,
+  query,
+  derived,
+  count,
+  type DerivedDecl,
+  type CountDecl,
+} from "@githolon/dsl";
+
+// --- vocabulary ---------------------------------------------------------------
+
+export const ENTRY_MOODS = ["delighted", "happy", "neutral", "grumpy"] as const;
+
+// --- aggregate ----------------------------------------------------------------
+
+/** One guestbook entry. The wire type `GuestbookEntry` is what readers key on. */
+export const GuestbookEntry = aggregate("GuestbookEntry", {
+  author: t.string().merge(Lww),
+  message: t.string().merge(Lww),
+  mood: t.enum(ENTRY_MOODS).merge(Lww),
+  signedAt: t.string().merge(Lww), // ISO-8601, caller-stamped
+  updatedAt: t.string().merge(Lww), // ISO-8601
+  /** Free-form additive tags — concurrent adds commute (AddWins). */
+  tags: t.set(t.string()).merge(AddWins),
+  /** Reactions keyed by reactor — per-key Lww, concurrent reactors commute. */
+  reactions: t.map(t.string()).merge(MapOf(Lww)),
+});
+
+// --- directives ---------------------------------------------------------------
+
+/** Sign the guestbook: creates an entry (Nomos mints the id). */
+export const signGuestbook = directive("signGuestbook")
+  .creates(GuestbookEntry)
+  .payload(
+    z.object({
+      author: z.string().min(1),
+      message: z.string().min(1),
+      mood: z.enum(ENTRY_MOODS),
+      signedAt: z.string(), // ISO-8601
+      tags: z.array(z.string()).optional(),
+    }),
+  )
+  .plan((p) => {
+    const entry = create(GuestbookEntry);
+    entry
+      .set("author", p.author)
+      .set("message", p.message)
+      .set("mood", p.mood)
+      .set("signedAt", p.signedAt)
+      .set("updatedAt", p.signedAt);
+    for (const tag of p.tags ?? []) entry.add("tags", tag);
+    return [];
+  });
+
+/** React to an entry: a map-PUT at the reactor's key (concurrent reactors commute). */
+export const reactToEntry = directive("reactToEntry")
+  .mutates(GuestbookEntry)
+  .payload(
+    z.object({
+      entryId: z.string(),
+      reactor: z.string().min(1),
+      reaction: z.string().min(1),
+      reactedAt: z.string(), // ISO-8601
+    }),
+  )
+  .plan((p) => {
+    const entry = instance(GuestbookEntry, p.entryId);
+    return [
+      setEntry(entry, "reactions", p.reactor, p.reaction),
+      set(entry, "updatedAt", p.reactedAt),
+    ];
+  });
+
+// --- declared read queries (auto-discovered by nomos-compile) -------------------
+
+/** All entries by one author — an indexed probe, not a scan. */
+export const entriesByAuthor = query("entriesByAuthor").key("author").returns(GuestbookEntry);
+
+// --- derived read fields (engine-projected, PURE; NEVER stamped into the ledger) ---
+
+/** The mood → emoji rendering table — verbatim the {@link ENTRY_MOODS} vocabulary. */
+export const MOOD_EMOJI: Record<(typeof ENTRY_MOODS)[number], string> = {
+  delighted: "🤩",
+  happy: "😊",
+  neutral: "🙂",
+  grumpy: "😠",
+};
+
+/**
+ * `GuestbookEntry.moodEmoji` — an ENGINE-PROJECTED DERIVED read field: a PURE fn of the
+ * entry's folded `mood` (the {@link MOOD_EMOJI} table lookup; `"❔"` while `mood` is
+ * still unfolded — partial folds are normal). Computed BY THE ENGINE during the
+ * read-model projection and stored ONLY in the read model — never stamped into a kernel
+ * op/event, so the ledger stays pure user-intents and the value is always re-derivable.
+ * Exported INDIVIDUALLY at top level: both the engine bundle and `nomos-compile`
+ * auto-discover it from the module exports by shape ({id, of, returns, fn}).
+ */
+export const moodEmoji: DerivedDecl = derived("moodEmoji")
+  .of(GuestbookEntry)
+  .returns(z.string())
+  .as((a) => MOOD_EMOJI[a.mood as (typeof ENTRY_MOODS)[number]] ?? "❔");
+
+// --- counts (maintained tallies — O(1) reads, never a scan) ----------------------
+
+/** How many entries per mood — one maintained counter per distinct `mood` value. */
+export const entriesPerMood: CountDecl = count("entriesPerMood").of(GuestbookEntry).by("mood");

package/template/gitignore

@@ -0,0 +1,3 @@
+node_modules/
+build/
+/holon/

package/template/nomos.package.mjs

@@ -0,0 +1,12 @@
+// The nomos-compile config: one package, one domain, one module file.
+// Read-side declarations (queries/counts/...) are auto-discovered from the
+// module's exports by shape — nothing to wire here.
+export default {
+  name: "guestbook",
+  domains: [{ key: "guestbook", modules: ["./domains/guestbook.ts"] }],
+  // Typed Dart frontend (the Flutter sibling of build/guestbook.client.ts):
+  // build/dart/guestbook.dart + the vendored nomos_dsl support files. A Flutter
+  // app vendors the build/dart/ directory as-is. `dart: { out: "some/dir" }`
+  // overrides the destination.
+  dart: true,
+};

package/template/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "__APP_NAME__",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "description": "A Nomos domain package — authored in @githolon/dsl, compiled with `holon compile`, deployed to Nomos Cloud with one POST.",
+  "scripts": {
+    "compile": "holon compile",
+    "e2e": "tsx test/e2e.mts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@githolon/dsl": "^0.1.0",
+    "@githolon/client": "^0.1.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@githolon/cli": "^0.1.0",
+    "@types/node": "^25.9.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3"
+  }
+}

package/template/test/e2e.mts

@@ -0,0 +1,109 @@
+// E2E: the FULL friend loop against a LIVE Nomos Cloud, driven through the
+// GENERATED TYPED CLIENT (`build/guestbook.client.ts` — emitted by nomos-compile):
+//
+//   compile → create workspace → deploy (package + manifest overlay, ONE POST) →
+//   web client connects → TYPED dispatch signGuestbook LOCALLY (offline write) →
+//   TYPED declared query routes LOCALLY → sync + edge admission → the CLOUD's
+//   declared query returns the entry.
+//
+// Run from this directory AFTER `npx nomos-compile`:  npx tsx test/e2e.mts
+import { readFileSync } from "node:fs";
+// @ts-expect-error — plain-JS package (no type declarations); structurally satisfies NomosHolon
+import { connect } from "@githolon/client";
+import { guestbookClient, GUESTBOOK_DOMAIN_HASH } from "../build/guestbook.client.ts";
+
+const CLOUD = (process.env.NOMOS_CLOUD || "https://nomos.captainapp.co.uk").replace(/\/+$/, "");
+const WS = process.env.NOMOS_WS || "gb-e2e-" + Math.random().toString(36).slice(2, 8);
+
+const fail = (m: string): never => { console.error("✗ " + m); process.exit(1); };
+const ok = (m: string) => console.log("✓ " + m);
+
+const deploy = JSON.parse(readFileSync(new URL("../build/guestbook.deploy.json", import.meta.url), "utf8"));
+
+// 1. create the workspace (capture the ONE-TIME secret) + deploy WITH the secret
+let r = await fetch(`${CLOUD}/v1/workspaces/${WS}`, { method: "POST", headers: { "x-nomos-principal": "nomos-e2e-suite" } });
+let d = await r.json();
+if (!d.ok) fail(`create workspace: ${JSON.stringify(d)}`);
+const SECRET: string = d.workspaceSecret;
+if (!SECRET?.startsWith("nws_v1_")) fail(`no workspaceSecret returned: ${JSON.stringify(d)}`);
+ok(`workspace ${WS} created — controller ${d.controller.domainHash.slice(0, 12)}…, secret ${SECRET.slice(0, 10)}…`);
+
+// ownership: a deploy WITHOUT the secret must be refused
+r = await fetch(`${CLOUD}/v1/workspaces/${WS}/domains`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(deploy) });
+if (r.status !== 401) fail(`unauthenticated deploy was not refused (got ${r.status})`);
+ok("ownership — deploy without the workspace secret refused (401)");
+
+r = await fetch(`${CLOUD}/v1/workspaces/${WS}/domains`, { method: "POST", headers: { "content-type": "application/json", authorization: `Bearer ${SECRET}` }, body: JSON.stringify(deploy) });
+d = await r.json();
+if (!d.ok || d.installation?.[0]?.data?.["status.phase"] !== "Active") fail(`deploy: ${JSON.stringify(d)}`);
+// The generated client's baked hash IS the deployed law's content hash — same compile.
+if (d.domainHash !== GUESTBOOK_DOMAIN_HASH) fail(`deploy hash ${d.domainHash} != generated client's ${GUESTBOOK_DOMAIN_HASH}`);
+ok(`guestbook deployed Active — ${GUESTBOOK_DOMAIN_HASH.slice(0, 12)}… (baked into the typed client)`);
+
+// 2. connect + bind the TYPED client (zero-import generated file, structural holon)
+const holon = await connect({ cloud: CLOUD, workspace: WS, clientId: "guest-1" });
+const app = guestbookClient(holon);
+ok(`web client connected — typed client bound (replica ${holon.replica.slice(0, 6)}…)`);
+
+let rows = await holon.queryById(`domain-installation:${GUESTBOOK_DOMAIN_HASH}`);
+if (!(rows.length && rows[0].data["status.phase"] === "Active")) fail("local replay: guestbook not Active locally");
+ok("local replay — guestbook law Active in the local projection");
+
+// 3. LOCAL-FIRST write through the TYPED surface: payload shape + enum are compile-checked
+const signedAt = new Date().toISOString();
+await app.signGuestbook({ author: "ada", message: "hello from the edge of the network", mood: "delighted", signedAt, tags: ["first-entry"] });
+ok("typed dispatch signGuestbook — offline write under the pulled law");
+
+// 4. the TYPED declared query routes LOCALLY; rows come back as Row<GuestbookEntryData>[]
+const entries = await app.entriesByAuthor({ author: "ada" });
+if (!(entries.length === 1 && entries[0]!.data.message === "hello from the edge of the network")) {
+  fail(`local typed query: ${JSON.stringify(entries)}`);
+}
+const entryId = entries[0]!.id;
+ok(`typed declared query routes — entriesByAuthor → ${entryId} (mood: ${entries[0]!.data.mood})`);
+
+// 5. typed mutate + typed by-id read (SetEntry map-put folds locally)
+await app.reactToEntry({ entryId, reactor: "bob", reaction: "love", reactedAt: new Date().toISOString() });
+const after = await app.guestbookEntryById(entryId);
+if (after[0]!.data.reactions?.bob !== "love") fail(`typed mutate/read: ${JSON.stringify(after)}`);
+ok("typed mutate folds — reactions map shows bob → love locally");
+
+// 5b. DERIVED read field: the engine projects moodEmoji from the law's pure fn
+if (after[0]!.data.moodEmoji !== "🤩") fail(`derived moodEmoji not projected locally: ${JSON.stringify(after[0]!.data)}`);
+ok("derived field projects locally — moodEmoji 🤩 (engine-computed, never in the ledger)");
+
+// 5c. DECLARED COUNT: the maintained O(1) tally, typed accessor, local projection
+const localCount = await app.entriesPerMood("delighted");
+if (localCount !== 1) fail(`local declared count: ${localCount}`);
+ok("declared count maintained locally — entriesPerMood('delighted') = 1");
+
+// 6. sync: push the session branch + edge admission merges to main
+const s = await holon.sync({ admit: true });
+if (!s.admission?.ok) fail(`sync/admit: ${JSON.stringify(s)}`);
+const admitted = (s.admission.sessions || []).flatMap((x: { admitted?: unknown[] }) => x.admitted || []);
+if (admitted.length < 2) fail(`edge admitted ${admitted.length} intent(s), expected 2: ${JSON.stringify(s.admission)}`);
+ok(`synced — edge admission merged ${admitted.length} intents to main`);
+
+// 7. the CLOUD's declared query (read-manifest overlay, edge projection) returns the entry
+d = await (await fetch(`${CLOUD}/v1/workspaces/${WS}/query?queryId=entriesByAuthor&params=${encodeURIComponent(JSON.stringify({ author: "ada" }))}`)).json();
+if (!(d.ok && d.rows.length === 1 && d.rows[0].data.reactions?.bob === "love")) {
+  fail(`cloud declared query: ${JSON.stringify(d)}`);
+}
+ok("cloud declared query returns the admitted entry WITH the admitted reaction — full loop closed");
+
+// 8. the EDGE projects the derived field + maintains the count too (same wasm, same law)
+d = await (await fetch(`${CLOUD}/v1/workspaces/${WS}/aggregates/${encodeURIComponent(entryId)}`)).json();
+if (d.rows?.[0]?.data?.moodEmoji !== "🤩") fail(`edge derived projection: ${JSON.stringify(d.rows?.[0]?.data)}`);
+ok("derived field projects at the edge — moodEmoji 🤩");
+d = await (await fetch(`${CLOUD}/v1/workspaces/${WS}/counts/entriesPerMood?group=delighted`)).json();
+if (!(d.ok && d.count === 1)) fail(`cloud count: ${JSON.stringify(d)}`);
+ok("cloud count endpoint — entriesPerMood[delighted] = 1 (O(1) maintained read)");
+
+// 9. CONVERGENCE: the same instance adopts canonical main inside sync() — no reconnect
+const head = await holon.head();
+const refsAdv = await (await fetch(`${CLOUD}/v1/workspaces/${WS}/git/info/refs?service=git-upload-pack`)).text();
+const remoteMain = (refsAdv.match(/([0-9a-f]{40}) refs\/heads\/main/) || [])[1];
+if (head !== remoteMain) fail(`not converged in place: local ${head?.slice(0, 10)} vs main ${remoteMain?.slice(0, 10)}`);
+ok("converged in place — local head == canonical main, no reconnect");
+
+console.log(`\nALL GREEN — typed client: compile → deploy → connect → typed write/query/mutate/derive/count → admit → converge → cloud reads (${WS})`);

package/template/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "nodenext",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true
+  },
+  "include": [
+    "domains/**/*.ts",
+    "build/*.client.ts",
+    "test/**/*.mts"
+  ]
+}