create-geonosis 1.0.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,74 @@
+# create-geonosis
+
+**A repo that passes its own gates on day one.**
+
+```bash
+npm create geonosis@latest pinecone -- \
+  --runtime pnpm --backend medusa --ui atoms-only --brand Pinecone
+```
+
+There is **no default** for `--runtime`, `--backend` or `--ui`. Each decides the shape of the tree,
+and a default borrowed from another repo would be that repo's stack hardcoded into this one.
+
+| Flag | Choices |
+|---|---|
+| `--runtime` | `pnpm` · `bun` |
+| `--backend` | `medusa` · `sagaflow-cf` · `none` |
+| `--ui` | `tiered-shadcn` · `atoms-only` · `none` |
+| `--brand <name>` | turns on `no-brand-names` for that word |
+| `--themekit <name>` | consumes a themekit **by version**, never by copying it |
+| `--marketplace <path>` | install the plugin from a local marketplace instead of GitHub |
+| `--kit <path>` | read the kit from a workspace instead of the registry — a proof aid |
+| `--no-install` | write the files and stop |
+
+## What it writes
+
+- **One catalog of shared versions** — `pnpm-workspace.yaml` on pnpm, `workspaces.catalog` on bun.
+  A repo whose workspaces each pin their own typescript is a repo where one of them typechecks
+  against a compiler the others do not run.
+- **An `exports` map and no barrel** in every workspace.
+- **`typecheck` + `lint` + `test` in EVERY workspace** — Midday has several without, and turbo
+  silently skips those. Each `test` asks vitest for its own JSON report, because a runner's exit
+  code is not a verdict.
+- **`docs/architecture.md`, and the edges table is the one place the graph is written.**
+  `geonosis-ledger sync` generates turbo's `boundaries.tags` AND the linter's `layer-walls` layers
+  from it, so a tag added there reaches both gates and neither can drift from the other. The
+  scaffold runs both splices for you.
+- **`CLAUDE.md` under 60 lines**, plus a `docs/pipelines/` page template.
+- **The five config files**: `geonosis.json` (verify tiers, ledger, walk, testbed, doctor),
+  `.oxlintrc.json` with the presets the answers imply, `geonosis.ratchet.json`, `gate-baseline.json`,
+  `.oxfmtrc.json`.
+- **`lefthook.yml`** (staged oxfmt + oxlint), **`.github/workflows/ci.yml`** with nothing switched
+  off in it, **`skills-lock.json`** empty, **`.claude/settings.json`** installing the kit's plugin.
+- **`lint-corpus/`** — see below.
+
+## The baseline, and the one number that is not zero
+
+Every counter starts at **0**: a new repo has earned no debt. `lawLineCount` starts at the measured
+length of the `CLAUDE.md` that was just written, because it counts something that already exists and
+a 0 there would fail the first `ratchet` run over a clean tree.
+
+## `lint-corpus/` — the reach corpus a shipped one cannot be
+
+`geonosis-doctor` asks whether every enabled rule can fire at all, against the corpus the **plugin**
+ships. That answers for most rules and cannot answer for three: `layer-walls` fires on a repo's own
+layer names, `no-brand-names` on its own brand, `plugin-route-namespaced` on its own package root —
+and the plugin's corpus says `acme` and `layers/core`. So the scaffold writes a small corpus in
+**this** repo's vocabulary, with a `manifest.json` naming exactly the rules it is evidence about.
+
+It is deliberately broken code, so it is excluded from the repo's own lint, format and typecheck —
+the same treatment the plugin gives its own fixtures. The corpus run copies it to a temp root and
+lints with `--no-ignore`, so nothing is hidden from the check it exists for.
+
+## `--kit <path>`
+
+A proof aid. It symlinks the kit's packages into `node_modules` **after** the install and rewrites
+the manifest to declare them as `link:` — which is a declaration `geonosis-doctor` accepts and can
+verify. It is done by hand because neither package manager can do it: pnpm resolves `link:` happily,
+and bun refuses both `link:` and `file:` here, because it follows into the target and tries to
+resolve the `workspace:*` specifiers the kit's own packages use.
+
+## Proven, not claimed
+
+A repo scaffolded on **both** runtimes passes its own `geonosis-verify full` in a temp directory —
+see `proofs/022-W10-scaffold/`.

package/bin/create-geonosis.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+// Committed, so `pnpm install` can link the bin on a fresh clone — before `pnpm build` has
+// produced dist/. A bin that only exists after a build is a bin that is missing when you need it.
+import '../dist/create-geonosis-cli.js'

package/dist/chunk-UWL7ARNA.js

@@ -0,0 +1,847 @@
+// src/answers.ts
+import { basename, resolve } from "path";
+var RUNTIMES = ["bun", "pnpm"];
+var BACKENDS = ["medusa", "none", "sagaflow-cf"];
+var UIS = ["atoms-only", "none", "tiered-shadcn"];
+var VALUED = /* @__PURE__ */ new Set([
+  "--backend",
+  "--brand",
+  "--kit",
+  "--marketplace",
+  "--runtime",
+  "--themekit",
+  "--ui"
+]);
+var read = (argv) => {
+  const flags = {};
+  let dir;
+  for (let at = 0; at < argv.length; at += 1) {
+    const token = argv[at] ?? "";
+    if (!token.startsWith("--")) {
+      if (dir === void 0) dir = token;
+      continue;
+    }
+    const equals = token.indexOf("=");
+    if (equals !== -1) {
+      flags[token.slice(0, equals)] = token.slice(equals + 1);
+      continue;
+    }
+    if (!VALUED.has(token)) {
+      flags[token] = "true";
+      continue;
+    }
+    const value = argv[at + 1];
+    if (value === void 0) throw new Error(`${token} needs a value`);
+    flags[token] = value;
+    at += 1;
+  }
+  return { ...dir === void 0 ? {} : { dir }, flags };
+};
+var choose = (flag, given, allowed) => {
+  if (given === void 0) {
+    throw new Error(`${flag} is required \u2014 it is one of ${allowed.join(", ")}, and never a default`);
+  }
+  if (!allowed.includes(given)) {
+    throw new Error(`${flag} "${given}" is not one of ${allowed.join(", ")}`);
+  }
+  return given;
+};
+var scopeOf = (name) => `@${name.toLowerCase().replaceAll(/[^a-z0-9-]/g, "-")}`;
+var parseAnswers = (argv, cwd) => {
+  const { dir, flags } = read(argv);
+  if (dir === void 0) {
+    throw new Error("create-geonosis needs a directory to write the repo into");
+  }
+  const name = basename(resolve(cwd, dir));
+  return {
+    backend: choose("--backend", flags["--backend"], BACKENDS),
+    ...flags["--brand"] === void 0 ? {} : { brand: flags["--brand"] },
+    dir: resolve(cwd, dir),
+    ...flags["--kit"] === void 0 ? {} : { kit: resolve(cwd, flags["--kit"]) },
+    ...flags["--marketplace"] === void 0 ? {} : { marketplace: flags["--marketplace"] },
+    name,
+    runtime: choose("--runtime", flags["--runtime"], RUNTIMES),
+    scope: scopeOf(name),
+    ...flags["--themekit"] === void 0 ? {} : { themekit: flags["--themekit"] },
+    ui: choose("--ui", flags["--ui"], UIS)
+  };
+};
+var wantsInstall = (argv) => !argv.includes("--no-install");
+
+// src/corpus.ts
+var CORPUS_DIR = "lint-corpus";
+var PREFIX = "biological-architecture";
+var corpusFor = (answers, workspaces) => {
+  const files = {};
+  const rules = [];
+  const walled = workspaces.find((one) => one.mayDependOn.length === 0);
+  const forbidden = workspaces.find((one) => one.tag === "app");
+  if (walled !== void 0 && forbidden !== void 0) {
+    rules.push(`${PREFIX}/layer-walls`);
+    files[`${CORPUS_DIR}/${walled.dir}/src/bad-reaches-up.ts`] = `// BREACH: the ${walled.tag} layer may import nothing, and this reaches ${forbidden.tag}.
+import { boot } from '${forbidden.name}/boot'
+
+export const reachesUp = () => boot
+`;
+  }
+  if (answers.brand !== void 0) {
+    rules.push(`${PREFIX}/no-brand-names`);
+    files[`${CORPUS_DIR}/brand/bad-brand.ts`] = `// BREACH: the brand name spelled into source, which is what the rule is configured to find.
+export const FOOTER_NOTE = 'Powered by ${answers.brand}'
+`;
+  }
+  if (answers.backend === "medusa") {
+    rules.push(`${PREFIX}/plugin-route-namespaced`);
+    files[`${CORPUS_DIR}/packages/medusa-plugins/example/src/api/store/route.ts`] = `// BREACH: a store route with no namespace under it, in a plugin package.
+export async function GET(req: unknown, res: { json: (body: unknown) => void }) {
+  res.json({ ok: true, req })
+}
+`;
+  }
+  if (answers.backend === "sagaflow-cf") {
+    rules.push(`${PREFIX}/step-opens-its-own-cell`);
+    files[`${CORPUS_DIR}/packages/backend/src/workflows/bad-engine-step.ts`] = `// BREACH: a saga inside the configured \`within\` reaching the engine's own step.
+import { step } from 'sagaflow-js'
+
+export const issue = step('issue', async () => ({ ok: true }))
+`;
+  }
+  files[`${CORPUS_DIR}/manifest.json`] = `${JSON.stringify({ plugin: PREFIX, rules }, void 0, 2)}
+`;
+  return files;
+};
+
+// src/layout.ts
+var CORE = `export type Money = { amount: number; currency: string }
+
+export const totalOf = (lines: readonly Money[], currency: string): Money => ({
+  amount: lines.filter((one) => one.currency === currency).reduce((sum, one) => sum + one.amount, 0),
+  currency,
+})
+`;
+var CORE_TEST = (scope) => `import { describe, expect, it } from 'vitest'
+
+import { totalOf } from './money'
+
+describe('totalOf', () => {
+  it('adds the lines that share the currency', () => {
+    expect(totalOf([{ amount: 2, currency: 'EUR' }, { amount: 3, currency: 'EUR' }], 'EUR')).toEqual(
+      { amount: 5, currency: 'EUR' },
+    )
+  })
+
+  it('ignores the ones that do not \u2014 ${scope}/core never guesses a rate', () => {
+    expect(totalOf([{ amount: 2, currency: 'EUR' }, { amount: 9, currency: 'USD' }], 'EUR').amount)
+      .toBe(2)
+  })
+})
+`;
+var BUTTON = `import type { ComponentProps } from 'react'
+
+export function Button(props: ComponentProps<'button'>) {
+  return <button type="button" {...props} />
+}
+`;
+var FIELD = (scope) => `import { Button } from '${scope}/ui/atoms/button'
+
+export function Field({ label, onSubmit }: { label: string; onSubmit: () => void }) {
+  return (
+    <label>
+      {label}
+      <Button onClick={onSubmit}>Go</Button>
+    </label>
+  )
+}
+`;
+var UI_TEST = `import { describe, expect, it } from 'vitest'
+
+import { Button } from './atoms/button'
+
+describe('Button', () => {
+  it('is a component, so a tier above can compose it', () => {
+    expect(typeof Button).toBe('function')
+  })
+})
+`;
+var MEDUSA_SUBSCRIBER = `export const config = {
+  context: { subscriberId: 'order-placed' },
+  event: 'order.placed',
+}
+
+export default async function orderPlaced({ data }: { data: { id: string } }): Promise<string> {
+  return data.id
+}
+`;
+var SAGAFLOW_STEP = `export const step = <Input, Output>(
+  name: string,
+  body: (input: Input) => Promise<Output>,
+  undo: (output: Output) => Promise<void>,
+) => ({ body, name, undo })
+`;
+var SAGAFLOW_FLOW = `import { step } from './step'
+
+export const reserve = step(
+  'reserve',
+  async (input: { id: string }) => ({ held: input.id }),
+  async () => undefined,
+)
+`;
+var BACKEND_TEST = `import { describe, expect, it } from 'vitest'
+
+import { handler } from './handler'
+
+describe('the backend seam', () => {
+  it('answers with what it was asked about', async () => {
+    expect(await handler({ id: 'ord_1' })).toBe('ord_1')
+  })
+})
+`;
+var HANDLER = `export const handler = async ({ id }: { id: string }): Promise<string> => id
+`;
+var APP = (scope, ui) => ui ? `import { totalOf } from '${scope}/core/money'
+import { Button } from '${scope}/ui/atoms/button'
+
+export const boot = () => ({ button: Button, total: totalOf([], 'EUR') })
+` : `import { totalOf } from '${scope}/core/money'
+
+export const boot = () => ({ total: totalOf([], 'EUR') })
+`;
+var APP_TEST = `import { describe, expect, it } from 'vitest'
+
+import { boot } from './boot'
+
+describe('boot', () => {
+  it('starts with an empty total rather than a guess', () => {
+    expect(boot().total.amount).toBe(0)
+  })
+})
+`;
+var workspacesOf = (answers) => {
+  const { scope, ui } = answers;
+  const list = [
+    {
+      dir: "packages/core",
+      mayDependOn: [],
+      name: `${scope}/core`,
+      sources: { "src/money.ts": CORE, "src/money.test.ts": CORE_TEST(scope) },
+      tag: "core"
+    }
+  ];
+  if (ui !== "none") {
+    list.push({
+      dir: "packages/ui",
+      mayDependOn: ["core"],
+      name: `${scope}/ui`,
+      sources: {
+        "src/atoms/button.tsx": BUTTON,
+        "src/button.test.ts": UI_TEST,
+        ...ui === "tiered-shadcn" ? { "src/molecules/field.tsx": FIELD(scope) } : {}
+      },
+      tag: "ui"
+    });
+  }
+  if (answers.backend !== "none") {
+    list.push({
+      dir: "packages/backend",
+      mayDependOn: ["core"],
+      name: `${scope}/backend`,
+      sources: {
+        "src/handler.ts": HANDLER,
+        "src/handler.test.ts": BACKEND_TEST,
+        ...answers.backend === "medusa" ? { "src/subscribers/order-placed.ts": MEDUSA_SUBSCRIBER } : { "src/workflows/step.ts": SAGAFLOW_STEP, "src/workflows/reserve.ts": SAGAFLOW_FLOW }
+      },
+      tag: "backend"
+    });
+  }
+  list.push({
+    dir: "apps/web",
+    mayDependOn: list.map((one) => one.tag),
+    name: `${scope}/web`,
+    sources: { "src/boot.ts": APP(scope, ui !== "none"), "src/boot.test.ts": APP_TEST },
+    tag: "app"
+  });
+  return list;
+};
+
+// src/files.ts
+import { countersFor, rulesFor } from "@geonosis/cli";
+var VERSION = "1.0.0";
+var SCHEMA = "https://raw.githubusercontent.com/oxc-project/oxc/main/npm/oxlint/configuration_schema.json";
+var CATALOG = {
+  "@types/node": "^24.3.0",
+  oxfmt: "^0.62.0",
+  oxlint: "^1.80.0",
+  typescript: "^5.9.2",
+  vitest: "^3.2.4"
+};
+var REACT = { "@types/react": "^19.0.0", react: "^19.0.0" };
+var json = (value) => `${JSON.stringify(value, void 0, 2)}
+`;
+var exec = (runtime) => runtime === "bun" ? "bunx" : "npx";
+var everyWorkspace = (runtime, script) => runtime === "bun" ? `bun run --filter '*' ${script}` : `pnpm -r ${script}`;
+var presetsFor = (answers) => [
+  "tooling",
+  ...answers.ui === "none" ? [] : ["frontend"],
+  ...answers.backend === "none" ? [] : ["tenant-scoping"],
+  ...answers.backend === "medusa" ? ["backend-medusa"] : [],
+  ...answers.backend === "sagaflow-cf" ? ["backend-sagaflow-cf"] : [],
+  ...answers.themekit === void 0 ? [] : ["themekit"]
+];
+var tokenPrefix = (name) => `--${name.toLowerCase().replaceAll(/[^a-z]/g, "").slice(0, 3)}-`;
+var answersForRules = (answers) => ({
+  "layer-walls": ["error", { layers: [] }],
+  // The scope is allowed on purpose: a repo whose brand is also its package scope would otherwise
+  // have every one of its own import paths reported as a brand leak, and the first thing anybody
+  // would do about that is turn the rule off.
+  ...answers.brand === void 0 ? {} : {
+    "no-brand-names": [
+      "error",
+      { allowedSubstrings: [`${answers.scope}/`], brands: [answers.brand] }
+    ]
+  },
+  ...answers.ui === "none" ? {} : {
+    "no-raw-html-atoms": [
+      "error",
+      [{ atom: "Button", element: "button", importPath: `${answers.scope}/ui/atoms/button` }]
+    ]
+  },
+  ...answers.backend === "medusa" ? {
+    "plugin-route-namespaced": [
+      "error",
+      {
+        packages: [
+          {
+            name: `${answers.scope}/{dir}`,
+            namespaced: true,
+            under: "packages/medusa-plugins"
+          }
+        ]
+      }
+    ]
+  } : {},
+  ...answers.backend === "sagaflow-cf" ? {
+    "step-opens-its-own-cell": [
+      "error",
+      {
+        engine: "sagaflow-js",
+        within: "packages/backend/src/workflows/",
+        wrapper: "packages/backend/src/workflows/step\\.ts$"
+      }
+    ]
+  } : {},
+  ...answers.themekit === void 0 ? {} : {
+    "font-roles-only": ["error", { roles: ["body", "display"] }],
+    "tokens-only-colors": ["error", { tokenPrefix: [tokenPrefix(answers.name)] }]
+  }
+});
+var exportsOf = (workspace) => Object.fromEntries(
+  Object.keys(workspace.sources).filter((file) => !file.includes(".test.")).toSorted().map((file) => [`./${file.replace(/^src\//, "").replace(/\.tsx?$/, "")}`, `./${file}`])
+);
+var workspaceManifest = (workspace, answers, workspaces) => {
+  const react = workspace.dir === "packages/ui";
+  return json({
+    name: workspace.name,
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    exports: exportsOf(workspace),
+    scripts: {
+      lint: "oxlint --config ../../.oxlintrc.json .",
+      // The runner is asked for its own report, never trusted for a status code.
+      test: "vitest run --reporter=default --reporter=json --outputFile=.geonosis/vitest.json",
+      typecheck: "tsc --noEmit"
+    },
+    devDependencies: {
+      "@types/node": "catalog:",
+      ...react ? { "@types/react": "catalog:", react: "catalog:" } : {},
+      oxlint: "catalog:",
+      typescript: "catalog:",
+      vitest: "catalog:"
+    },
+    dependencies: Object.fromEntries(
+      workspace.mayDependOn.flatMap((tag) => {
+        const found = workspaces.find((one) => one.tag === tag);
+        return found === void 0 || found.name === workspace.name ? [] : [[found.name, "workspace:*"]];
+      })
+    )
+  });
+};
+var kitDependencies = (answers) => ({
+  "@geonosis/cli": `^${VERSION}`,
+  "@geonosis/doctor": `^${VERSION}`,
+  "@geonosis/ledger": `^${VERSION}`,
+  "@geonosis/oxlint-plugin-biological-architecture": `^${VERSION}`,
+  "@geonosis/ratchet": `^${VERSION}`,
+  "@geonosis/verify": `^${VERSION}`,
+  ...answers.themekit === void 0 ? {} : { "@geonosis/themekit": `^${VERSION}` }
+});
+var rootManifest = (answers) => {
+  const { runtime } = answers;
+  const globs = ["apps/*", "packages/*"];
+  return json({
+    name: answers.name,
+    version: "0.0.0",
+    private: true,
+    type: "module",
+    ...runtime === "bun" ? {
+      workspaces: {
+        catalog: { ...CATALOG, ...answers.ui === "none" ? {} : REACT },
+        packages: globs
+      }
+    } : {},
+    scripts: {
+      doctor: "geonosis-doctor",
+      "format:check": "oxfmt --config .oxfmtrc.json --check .",
+      format: "oxfmt --config .oxfmtrc.json .",
+      lint: "oxlint --config .oxlintrc.json .",
+      ratchet: "geonosis-ratchet",
+      sync: "geonosis sync",
+      test: everyWorkspace(runtime, "test"),
+      typecheck: everyWorkspace(runtime, "typecheck"),
+      verify: "geonosis-verify"
+    },
+    devDependencies: {
+      // With --kit the kit is linked from a workspace AFTER the install, and the manifest is
+      // rewritten to say so. Declaring published versions here would make the install go looking
+      // for them first, which is the one thing --kit exists to avoid.
+      ...answers.kit === void 0 ? kitDependencies(answers) : {},
+      "@types/node": "catalog:",
+      ...answers.ui === "none" ? {} : { "@types/react": "catalog:", react: "catalog:" },
+      lefthook: "^2.1.0",
+      oxfmt: "catalog:",
+      oxlint: "catalog:",
+      turbo: "^2.10.0",
+      typescript: "catalog:",
+      vitest: "catalog:"
+    }
+  });
+};
+var workspaceYaml = (answers) => [
+  "packages:",
+  "  - apps/*",
+  "  - packages/*",
+  "",
+  "# One version of a shared dependency, named once. A repo whose workspaces each pin their own",
+  "# typescript is a repo where one of them typechecks against a compiler the others do not run.",
+  "catalog:",
+  ...Object.entries({ ...CATALOG, ...answers.ui === "none" ? {} : REACT }).toSorted(([a], [b]) => a.localeCompare(b)).map(([name, spec]) => `  '${name}': '${spec}'`),
+  "",
+  "# pnpm 11 runs no dependency's install script unless it is named here. esbuild fetches its",
+  "# platform binary in one, and without it vitest cannot start \u2014 a test suite that cannot run",
+  "# reports nothing, which is the shape of green this kit exists to refuse.",
+  "allowBuilds:",
+  "  esbuild: true",
+  "  lefthook: true",
+  ""
+].join("\n");
+var architecture = (answers, workspaces) => [
+  `# ${answers.name} \u2014 target architecture`,
+  "",
+  "The edges table is the ONE place this graph is written down. `geonosis sync --target turbo`",
+  "generates turbo's `boundaries.tags` from it, and `--target layer-walls` generates the linter's",
+  "layers from it, so a tag added here reaches both gates and neither can drift from the other.",
+  "",
+  "| tag | packages | may depend on |",
+  "| --- | --- | --- |",
+  ...workspaces.map(
+    (one) => `| ${one.tag} | ${one.name} | ${one.mayDependOn.join(", ") || "\u2014"} |`
+  ),
+  "",
+  ...answers.backend === "medusa" ? [
+    "Medusa plugins go under `packages/medusa-plugins/<name>`; the `plugin-route-namespaced`",
+    "rule is configured for that root, so a store route without a namespace is refused.",
+    ""
+  ] : []
+].join("\n");
+var pipeline = (answers) => [
+  "# Pipeline: order placed",
+  "",
+  "One page per pipeline, and this is the template. Say what enters, what each hop does to it, and",
+  "what leaves \u2014 then keep the diagram beside the code that implements it.",
+  "",
+  "```mermaid",
+  "graph LR",
+  `  IN[request] --> APP[${answers.scope}/web]`,
+  `  APP --> CORE[${answers.scope}/core]`,
+  ...answers.backend === "none" ? [] : [`  APP --> BACK[${answers.scope}/backend]`],
+  "  CORE --> OUT[response]",
+  "```",
+  "",
+  "| Hop | Owns | Fails how |",
+  "| --- | --- | --- |",
+  "| entry | shape of the request | refuses, never guesses |",
+  "| core | the calculation | pure, so it is tested without a server |",
+  "| exit | the response | one shape, named |",
+  ""
+].join("\n");
+var law = (answers) => [
+  `# ${answers.name} \u2014 repo doctrine`,
+  "",
+  `A ${answers.runtime} monorepo on the geonosis kit. \`docs/architecture.md\` is the graph;`,
+  "`docs/pipelines/` is one page per flow. Depth belongs in skills and in the rules, never here.",
+  "",
+  "## The laws",
+  "",
+  "**1. RED \u2192 GREEN.** Every new rule, constraint or invariant begins with a failing test. Write",
+  "it, watch it fail, then write the code that makes it pass. A test written afterwards validates",
+  "what was built, not what was intended.",
+  "",
+  "**2. Never downgrade a rule.** Setting one to `warn` or `off`, narrowing its globs, adding a",
+  "file to `ignorePatterns` or silencing it with a disable comment \u2014 all forbidden without asking.",
+  "A gate breaking because real code violates a real invariant is enforcement working.",
+  "",
+  "**3. No suppression.** No `@ts-ignore`, no `@ts-expect-error`. Fix the type, or ask.",
+  "",
+  "**4. oxfmt only.** `pnpm format` writes, `pnpm format:check` verifies. Never prettier: it is",
+  "not a dependency here, so it downloads itself and reformats with its own defaults.",
+  "",
+  "**5. Nothing is hardcoded to a repo.** Every list a rule needs is an option.",
+  "",
+  "**6. Test what the code does, not how.** Never assert on class names or DOM structure.",
+  "",
+  "## The gates",
+  "",
+  "```bash",
+  "geonosis verify full     # typecheck \u2192 lint \u2192 test \u2192 format \u2192 ratchet",
+  "geonosis doctor          # loaded, exercised, baseline, runner, drift",
+  "```",
+  "",
+  "`gate-baseline.json` holds one number per counter, and a number may only shrink. A counter that",
+  "grew fails; one that shrank rewrites the baseline down in the commit that earned it.",
+  "",
+  "## The method",
+  "",
+  "The `geonosis` Claude Code plugin carries the hooks, agents and skills:",
+  "",
+  "```bash",
+  `claude plugin marketplace add ${answers.marketplace ?? "microcompanies/geonosis"}`,
+  "claude plugin install geonosis@geonosis",
+  "```",
+  "",
+  "`AGENTS.md` and `.cursor/rules/` are GENERATED from this file by `geonosis sync` \u2014 edit this",
+  "one. `lint-corpus/` is fixture code that must stay broken: it is how the doctor proves the rules",
+  "configured for this repo can fire at all.",
+  ""
+].join("\n");
+var ci = (answers) => [
+  "name: verify",
+  "",
+  "on:",
+  "  push:",
+  "    branches: [main]",
+  "  pull_request:",
+  "",
+  "jobs:",
+  "  verify:",
+  "    runs-on: ubuntu-latest",
+  "    steps:",
+  "      - uses: actions/checkout@v4",
+  ...answers.runtime === "bun" ? ["      - uses: oven-sh/setup-bun@v2", "      - run: bun install --frozen-lockfile"] : [
+    "      - uses: pnpm/action-setup@v4",
+    "      - uses: actions/setup-node@v4",
+    "        with:",
+    "          node-version: '24'",
+    "          cache: 'pnpm'",
+    "      - run: pnpm install --frozen-lockfile"
+  ],
+  `      - run: ${exec(answers.runtime)} geonosis-verify full`,
+  `      - run: ${exec(answers.runtime)} geonosis-doctor`,
+  "",
+  "# When @geonosis/testbed is installed, add its matrix here: one job per adapter the repo",
+  "# declares in geonosis.json \u2192 testbed.adapters. A job switched off in a condition is a job",
+  "# that lies, so the disabledCiJobs counter counts them and the ratchet holds the number at 0.",
+  ""
+].join("\n");
+var settings = (answers) => json({
+  extraKnownMarketplaces: {
+    geonosis: answers.marketplace === void 0 ? { source: { repo: "microcompanies/geonosis", source: "github" } } : { source: { path: answers.marketplace, source: "directory" } }
+  },
+  enabledPlugins: { "geonosis@geonosis": true }
+});
+var tsconfigBase = (answers) => json({
+  compilerOptions: {
+    target: "ES2023",
+    lib: ["ES2023", ...answers.ui === "none" ? [] : ["DOM"]],
+    module: "ESNext",
+    moduleResolution: "bundler",
+    moduleDetection: "force",
+    ...answers.ui === "none" ? {} : { jsx: "react-jsx" },
+    types: ["node"],
+    strict: true,
+    noUncheckedIndexedAccess: true,
+    noImplicitOverride: true,
+    noFallthroughCasesInSwitch: true,
+    verbatimModuleSyntax: true,
+    isolatedModules: true,
+    skipLibCheck: true,
+    esModuleInterop: true,
+    resolveJsonModule: true,
+    noEmit: true
+  }
+});
+var filesFor = (answers) => {
+  const workspaces = workspacesOf(answers);
+  const counters = countersFor(answers.runtime);
+  const { rules } = rulesFor(presetsFor(answers), answersForRules(answers));
+  const files = {
+    "package.json": rootManifest(answers),
+    ...answers.runtime === "pnpm" ? { "pnpm-workspace.yaml": workspaceYaml(answers) } : {},
+    "CLAUDE.md": law(answers),
+    "docs/architecture.md": architecture(answers, workspaces),
+    "docs/pipelines/order-placed.md": pipeline(answers),
+    ".github/workflows/ci.yml": ci(answers),
+    ".claude/settings.json": settings(answers),
+    ".gitignore": ["node_modules/", "dist/", ".turbo/", ".geonosis/", "coverage/", ""].join("\n"),
+    ".oxfmtrc.json": json({
+      printWidth: 100,
+      singleQuote: true,
+      semi: false,
+      trailingComma: "all",
+      arrowParens: "always",
+      endOfLine: "lf",
+      tabWidth: 2,
+      quoteProps: "as-needed",
+      sortImports: true,
+      sortPackageJson: true,
+      ignorePatterns: [
+        "node_modules",
+        "dist",
+        ".turbo",
+        "coverage",
+        "**/*.md",
+        "**/*.json",
+        CORPUS_DIR
+      ]
+    }),
+    ".oxlintrc.json": json({
+      $schema: SCHEMA,
+      plugins: ["typescript", "unicorn"],
+      jsPlugins: ["@geonosis/oxlint-plugin-biological-architecture"],
+      categories: { correctness: "error", suspicious: "error" },
+      rules,
+      ignorePatterns: ["node_modules", "dist", "coverage", CORPUS_DIR]
+    }),
+    "geonosis.json": json({
+      verify: {
+        fast: ["pnpm typecheck", "pnpm lint", "pnpm test"].map(
+          (one) => answers.runtime === "bun" ? one.replace("pnpm ", "bun run ") : one
+        ),
+        full: [
+          "fast",
+          answers.runtime === "bun" ? "bun run format:check" : "pnpm format:check",
+          answers.runtime === "bun" ? "bun run ratchet" : "pnpm ratchet"
+        ]
+      },
+      doctor: { corpus: CORPUS_DIR },
+      ledger: {
+        architecture: "docs/architecture.md",
+        plans: "plans",
+        progress: "plans/PROGRESS.md",
+        proofs: "proofs"
+      },
+      walk: { probes: [], urls: [] },
+      testbed: {
+        adapters: answers.backend === "medusa" ? ["medusa-built"] : answers.backend === "sagaflow-cf" ? ["workerd"] : []
+      }
+    }),
+    "geonosis.ratchet.json": json({ baseline: "gate-baseline.json", counters }),
+    "gate-baseline.json": json(
+      Object.fromEntries(
+        counters.map((one) => [
+          typeof one.key === "string" ? one.key : String(one.counter),
+          // Zero is the floor for debt this repo has not earned. It is the wrong number for a
+          // counter that measures something already written: the law has its length the moment it
+          // lands, and a baseline of 0 would fail the first ratchet run over a clean tree.
+          one.counter === "lawLineCount" ? law(answers).split("\n").length - 1 : 0
+        ])
+      )
+    ),
+    "skills-lock.json": json({ skills: {}, version: 1 }),
+    "lefthook.yml": [
+      "# Staged scope only, so a commit never waits on a file it did not touch. When one fires, fix",
+      "# or delete the code \u2014 never downgrade the rule to get past it.",
+      "pre-commit:",
+      "  parallel: true",
+      "  commands:",
+      "    fmt:",
+      "      glob: '*.{ts,tsx,js,json}'",
+      `      run: ${exec(answers.runtime)} oxfmt --config .oxfmtrc.json --check {staged_files}`,
+      "    lint:",
+      "      glob: '*.{ts,tsx}'",
+      `      run: ${exec(answers.runtime)} oxlint --config .oxlintrc.json {staged_files}`,
+      ""
+    ].join("\n"),
+    "turbo.json": json({
+      $schema: "https://turborepo.dev/schema.json",
+      boundaries: { tags: {} },
+      tasks: {
+        build: { dependsOn: ["^build"] },
+        lint: {},
+        test: { dependsOn: ["^build"] },
+        typecheck: { dependsOn: ["^typecheck"] }
+      }
+    }),
+    "tsconfig.base.json": tsconfigBase(answers),
+    "tsconfig.json": json({
+      extends: "./tsconfig.base.json",
+      include: [
+        "apps/*/src/**/*.ts",
+        "apps/*/src/**/*.tsx",
+        "packages/*/src/**/*.ts",
+        "packages/*/src/**/*.tsx"
+      ],
+      exclude: ["**/dist/**", "**/node_modules/**", `${CORPUS_DIR}/**`]
+    }),
+    ...corpusFor(answers, workspaces)
+  };
+  for (const workspace of workspaces) {
+    files[`${workspace.dir}/package.json`] = workspaceManifest(workspace, answers, workspaces);
+    files[`${workspace.dir}/tsconfig.json`] = json({
+      extends: "../../tsconfig.base.json",
+      include: ["src"]
+    });
+    for (const [file, body] of Object.entries(workspace.sources)) {
+      files[`${workspace.dir}/${file}`] = body;
+    }
+  }
+  return files;
+};
+var presetsChosenBy = presetsFor;
+
+// src/scaffold.ts
+import { spawnSync } from "child_process";
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var KIT_PACKAGES = [
+  "cli",
+  "doctor",
+  "ledger",
+  "lint-parity",
+  "oxlint-plugin-biological-architecture",
+  "ratchet",
+  "themekit",
+  "verify"
+];
+var write = (dir, file, body) => {
+  const path = join(dir, file);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, body);
+};
+var writeScaffold = (answers) => {
+  if (existsSync(answers.dir) && readdirSync(answers.dir).length > 0) {
+    throw new Error(`${answers.dir} is not empty \u2014 nothing was written`);
+  }
+  const files = filesFor(answers);
+  mkdirSync(answers.dir, { recursive: true });
+  for (const [file, body] of Object.entries(files)) write(answers.dir, file, body);
+  return Object.keys(files).toSorted();
+};
+var run = (what, dir, command, args) => {
+  const done = spawnSync(command, args, { cwd: dir, encoding: "utf8", maxBuffer: 32 * 1024 * 1024 });
+  return {
+    code: done.error === void 0 ? done.status ?? 2 : 2,
+    output: `${done.stdout ?? ""}${done.stderr ?? ""}${done.error === void 0 ? "" : done.error.message}`,
+    what
+  };
+};
+var binsOf = (dir) => {
+  const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+  if (typeof manifest.bin === "string") return [[manifest.name ?? "", manifest.bin]];
+  return Object.entries(manifest.bin ?? {});
+};
+var linkKit = (answers, kit) => {
+  const modules = join(answers.dir, "node_modules");
+  const scope = join(modules, "@geonosis");
+  const bin = join(modules, ".bin");
+  mkdirSync(scope, { recursive: true });
+  mkdirSync(bin, { recursive: true });
+  const linked = [];
+  const manifestPath = join(answers.dir, "package.json");
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  for (const name of KIT_PACKAGES) {
+    const from = join(kit, "packages", name);
+    if (!existsSync(from)) continue;
+    const at = join(scope, name);
+    if (!existsSync(at)) {
+      spawnSync("ln", ["-s", from, at]);
+    }
+    for (const [called, relative] of binsOf(from)) {
+      const shim = join(bin, called);
+      writeFileSync(shim, `#!/bin/sh
+exec node "${join(from, relative)}" "$@"
+`);
+      chmodSync(shim, 493);
+    }
+    const declared = JSON.parse(readFileSync(join(from, "package.json"), "utf8"));
+    if (declared.name !== void 0) {
+      manifest.devDependencies = { ...manifest.devDependencies, [declared.name]: `link:${from}` };
+    }
+    linked.push(name);
+  }
+  writeFileSync(manifestPath, `${JSON.stringify(manifest, void 0, 2)}
+`);
+  return linked;
+};
+var installer = (answers) => answers.runtime === "bun" ? ["bun", ["install"]] : ["pnpm", ["install"]];
+var finish = ({ answers, install }) => {
+  const steps = [];
+  if (install) {
+    const [command, args] = installer(answers);
+    const offline = answers.runtime === "pnpm" ? [...args, "--offline"] : args;
+    const first = run(`${command} install (offline)`, answers.dir, command, offline);
+    steps.push(first);
+    if (first.code !== 0) {
+      steps.push(run(`${command} install (network)`, answers.dir, command, args));
+    }
+  }
+  if (answers.kit !== void 0) {
+    const linked = linkKit(answers, answers.kit);
+    steps.push({
+      code: 0,
+      output: `${linked.join(", ")}
+`,
+      what: `link the kit from ${answers.kit}`
+    });
+  }
+  const ledger = join(answers.dir, "node_modules/.bin/geonosis-ledger");
+  if (existsSync(ledger)) {
+    steps.push(
+      run("sync the edges table into turbo.json", answers.dir, ledger, [
+        "sync",
+        "--target",
+        "turbo",
+        "--write",
+        "turbo.json"
+      ]),
+      run("sync the edges table into .oxlintrc.json", answers.dir, ledger, [
+        "sync",
+        "--target",
+        "layer-walls",
+        "--write",
+        ".oxlintrc.json"
+      ])
+    );
+  }
+  const oxfmt = join(answers.dir, "node_modules/.bin/oxfmt");
+  if (existsSync(oxfmt)) {
+    steps.push(run("format", answers.dir, oxfmt, ["--config", ".oxfmtrc.json", "."]));
+  }
+  return steps;
+};
+
+export {
+  RUNTIMES,
+  BACKENDS,
+  UIS,
+  parseAnswers,
+  wantsInstall,
+  CORPUS_DIR,
+  corpusFor,
+  workspacesOf,
+  filesFor,
+  presetsChosenBy,
+  KIT_PACKAGES,
+  writeScaffold,
+  linkKit,
+  finish
+};

package/dist/create-geonosis-cli.js

@@ -0,0 +1,66 @@
+import {
+  finish,
+  parseAnswers,
+  wantsInstall,
+  writeScaffold
+} from "./chunk-UWL7ARNA.js";
+
+// src/create-geonosis-cli.ts
+var USAGE = `create-geonosis <dir> --runtime pnpm|bun --backend medusa|sagaflow-cf|none --ui tiered-shadcn|atoms-only|none
+                [--brand <name>] [--themekit <name>] [--marketplace <path>] [--kit <path>] [--no-install]
+
+Writes a repo that passes its own gates on day one: a workspace with one catalog of shared versions,
+an exports map and no barrel in every package, typecheck + lint + test scripts in every workspace,
+an edges table that GENERATES turbo's boundaries and the linter's layers, a law under sixty lines,
+the four geonosis config files, a lefthook, a CI workflow with nothing switched off in it, an empty
+skills lock, and a reach corpus in this repo's own vocabulary so the doctor can prove its rules fire.
+
+There is no default for --runtime, --backend or --ui. Each one decides the shape of the tree, and a
+default borrowed from another repo would be that repo's stack hardcoded into this one.
+
+  --kit <path>   read the kit from a workspace instead of the registry. A proof aid: it symlinks the
+                 packages after the install and rewrites the manifest to say so.
+  --no-install   write the files and stop. The gates cannot run until the two "geonosis sync
+                 --target" commands below have been run, and they are printed for you.
+
+Exit: 0 written \xB7 1 refused (a directory with something in it, an answer that is not one) \xB7 2 a run
+that could not be made at all.`;
+var main = () => {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+    process.stdout.write(`${USAGE}
+`);
+    return argv.length === 0 ? 2 : 0;
+  }
+  const answers = parseAnswers(argv, process.cwd());
+  const written = writeScaffold(answers);
+  process.stdout.write(`create-geonosis \u2014 ${written.length} file(s) into ${answers.dir}
+`);
+  const install = wantsInstall(argv);
+  for (const step of finish({ answers, install })) {
+    process.stdout.write(`  ${step.code === 0 ? "ok  " : "FAIL"}  ${step.what}
+`);
+    if (step.code !== 0) process.stdout.write(`${step.output}
+`);
+  }
+  if (!install) {
+    process.stdout.write(
+      [
+        "",
+        "  Nothing was installed, so the edges table has not reached the gates yet. Run:",
+        `    cd ${answers.dir} && ${answers.runtime} install`,
+        "    geonosis sync --target turbo --into turbo.json",
+        "    geonosis sync --target layer-walls --into .oxlintrc.json",
+        ""
+      ].join("\n")
+    );
+  }
+  return 0;
+};
+try {
+  process.exit(main());
+} catch (error) {
+  process.stderr.write(`create-geonosis: ${error.message}
+`);
+  process.exit(1);
+}

package/dist/index.d.ts

@@ -0,0 +1,93 @@
+declare const RUNTIMES: readonly ["bun", "pnpm"];
+declare const BACKENDS: readonly ["medusa", "none", "sagaflow-cf"];
+declare const UIS: readonly ["atoms-only", "none", "tiered-shadcn"];
+type Runtime = (typeof RUNTIMES)[number];
+type Backend = (typeof BACKENDS)[number];
+type Ui = (typeof UIS)[number];
+type Answers = {
+    backend: Backend;
+    brand?: string;
+    dir: string;
+    /** The kit read from a workspace instead of the registry — a proof aid, never the default. */
+    kit?: string;
+    marketplace?: string;
+    name: string;
+    runtime: Runtime;
+    scope: string;
+    themekit?: string;
+    ui: Ui;
+};
+declare const parseAnswers: (argv: readonly string[], cwd: string) => Answers;
+declare const wantsInstall: (argv: readonly string[]) => boolean;
+
+type Workspace = {
+    dir: string;
+    /** The files under this workspace, keyed by path relative to the workspace. */
+    sources: Record<string, string>;
+    name: string;
+    tag: string;
+    mayDependOn: string[];
+};
+/**
+ * The workspaces the answers imply, and the edge each one is allowed. Two at minimum — a pure-logic
+ * package and the app that composes it — because a wall needs something on the other side of it: a
+ * repo with one tag has no edge to violate, and a `layer-walls` that cannot fire is the inert rule
+ * this kit exists to catch.
+ */
+declare const workspacesOf: (answers: Answers) => Workspace[];
+
+declare const CORPUS_DIR = "lint-corpus";
+/**
+ * A reach corpus a shipped one cannot be.
+ *
+ * `geonosis-doctor` asks whether every enabled rule can fire at all, and it asks the corpus the
+ * PLUGIN ships. That answers for most rules and cannot answer for three: `layer-walls` fires on a
+ * repo's own layer names, `no-brand-names` on its own brand, `plugin-route-namespaced` on its own
+ * package root. The plugin's corpus says "acme" and `layers/core`, so it is no evidence either way
+ * about a repo that says anything else — and today those rules read as firing nowhere.
+ *
+ * So the repo ships its own, in ITS vocabulary. The corpus is copied to a temp root and linted with
+ * `--no-ignore`, so the fixture paths mirror the repo's real ones and the layer patterns match.
+ */
+declare const corpusFor: (answers: Answers, workspaces: Workspace[]) => Record<string, string>;
+
+declare const filesFor: (answers: Answers) => Record<string, string>;
+declare const presetsChosenBy: (answers: Answers) => string[];
+
+/** The kit packages a scaffolded repo declares, and therefore the ones `--kit` has to link. */
+declare const KIT_PACKAGES: string[];
+/**
+ * Every file, and never over the top of anything. A scaffold that overwrote a tree is a scaffold
+ * nobody dares run in the wrong shell, and the tree it lands in is usually somebody's work.
+ */
+declare const writeScaffold: (answers: Answers) => string[];
+type Step = {
+    code: number;
+    output: string;
+    what: string;
+};
+/**
+ * The kit read from a workspace instead of the registry — a proof aid, and only that.
+ *
+ * It is done by hand, after the install, because neither package manager can do it: pnpm resolves
+ * `link:` happily, and bun refuses BOTH `link:` and `file:` here, because it follows into the target
+ * and tries to resolve the `workspace:*` specifiers the kit's own packages use. Symlinking the
+ * directories and writing the bin shims is the one form of the answer that is true on both.
+ *
+ * The manifest is then told what is on disk, because `geonosis-doctor` FAILS a config whose plugin
+ * no manifest declares — and it should. A link is a declaration it accepts and can verify.
+ */
+declare const linkKit: (answers: Answers, kit: string) => string[];
+/**
+ * What has to happen after the files exist, in the order it has to happen in.
+ *
+ * The two `sync` calls are why the scaffold does not compute a boundaries map or a layer list of
+ * its own: the edges table is the ONE place the graph is written, and the ledger is the one thing
+ * that reads it. A second generator here would be a second answer to the same question.
+ */
+declare const finish: ({ answers, install }: {
+    answers: Answers;
+    install: boolean;
+}) => Step[];
+
+export { type Answers, BACKENDS, type Backend, CORPUS_DIR, KIT_PACKAGES, RUNTIMES, type Runtime, type Step, UIS, type Ui, type Workspace, corpusFor, filesFor, finish, linkKit, parseAnswers, presetsChosenBy, wantsInstall, workspacesOf, writeScaffold };

package/dist/index.js

@@ -0,0 +1,32 @@
+import {
+  BACKENDS,
+  CORPUS_DIR,
+  KIT_PACKAGES,
+  RUNTIMES,
+  UIS,
+  corpusFor,
+  filesFor,
+  finish,
+  linkKit,
+  parseAnswers,
+  presetsChosenBy,
+  wantsInstall,
+  workspacesOf,
+  writeScaffold
+} from "./chunk-UWL7ARNA.js";
+export {
+  BACKENDS,
+  CORPUS_DIR,
+  KIT_PACKAGES,
+  RUNTIMES,
+  UIS,
+  corpusFor,
+  filesFor,
+  finish,
+  linkKit,
+  parseAnswers,
+  presetsChosenBy,
+  wantsInstall,
+  workspacesOf,
+  writeScaffold
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "create-geonosis",
+  "version": "1.0.0",
+  "description": "Scaffold a microcompany repo that passes its own geonosis gates on day one.",
+  "keywords": [
+    "scaffold",
+    "monorepo",
+    "create",
+    "geonosis",
+    "gates",
+    "turborepo"
+  ],
+  "homepage": "https://github.com/microcompanies/geonosis/tree/main/packages/create-geonosis",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/microcompanies/geonosis.git",
+    "directory": "packages/create-geonosis"
+  },
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "create-geonosis": "bin/create-geonosis.mjs"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "dependencies": {
+    "@geonosis/cli": "1.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}