modelith-dbt 0.3.2__tar.gz → 0.4.0__tar.gz

modelith_dbt-0.4.0/.devcontainer/devcontainer-lock.json

@@ -0,0 +1,9 @@
+{
+  "features": {
+    "ghcr.io/devcontainers/features/node:1": {
+      "version": "1.7.1",
+      "resolved": "ghcr.io/devcontainers/features/node@sha256:8c0de46939b61958041700ee89e3493f3b2e4131a06dc46b4d9423427d06e5f6",
+      "integrity": "sha256:8c0de46939b61958041700ee89e3493f3b2e4131a06dc46b4d9423427d06e5f6"
+    }
+  }
+}

modelith_dbt-0.4.0/.devcontainer/devcontainer.json

@@ -0,0 +1,58 @@
+{
+  // Modelith onboarding devcontainer — visually test the ER canvas end to end.
+  //
+  // One file, both worlds: "Dev Containers: Reopen in Container" in VS Code
+  // Desktop, or launch it as a GitHub Codespace. It installs the `mdl` CLI the
+  // blessed way and the Modelith extension, with zero manual `modelith.mdlPath`
+  // config. It does NOT scaffold anything into your workspace — run
+  // `mdl init --demo` yourself from the terminal (writes to ~/modelith-demo), or
+  // `mdl reverse` your own dbt project. See setup-demo.sh's banner.
+  //
+  // The extension host and `mdl serve` both run INSIDE the container
+  // (extensionKind: workspace), and the canvas URL is resolved through
+  // vscode.env.asExternalUri, so port 4800 tunnels back to your machine
+  // automatically in Desktop and Codespaces alike.
+  "name": "Modelith onboarding (canvas)",
+  "image": "mcr.microsoft.com/devcontainers/python:3.12",
+
+  "features": {
+    // The extension's build/runtime toolchain wants Node 18+; pin 20.
+    "ghcr.io/devcontainers/features/node:1": { "version": "20" }
+  },
+
+  // Blessed-path install of the CLI. `uv tool install` puts `mdl` on PATH for
+  // every terminal AND for the extension's zero-config detection (PATH +
+  // ~/.local/bin probing). Nothing sets modelith.mdlPath — that is the point.
+  "onCreateCommand": "python3 -m pip install --user uv && ~/.local/bin/uv tool install modelith-dbt",
+
+  // Confirms the CLI is detected; does not scaffold (see setup-demo.sh).
+  "postCreateCommand": "bash .devcontainer/setup-demo.sh",
+
+  "customizations": {
+    "vscode": {
+      // Dev Containers installs these automatically on create, from the registry
+      // each host queries (MS Marketplace in Desktop, Open VSX in Codespaces).
+      // BosonResearch.modelith-vscode is published to both, so a fresh clone or
+      // Codespace brings the extension up with zero scripts and zero manual steps.
+      "extensions": ["BosonResearch.modelith-vscode", "redhat.vscode-yaml"],
+      "settings": {
+        // modelDir/dbtProjectDir are left to auto-discovery: nothing is scaffolded
+        // into the workspace, so hard-coding "model" would point at a missing dir.
+        // The extension finds a model when you create/reverse one, or you can point
+        // it at ~/modelith-demo/model after `mdl init --demo`.
+        //
+        // Canvas opens INSIDE VS Code as a webview tab (not an external browser).
+        // Set "external" to open it via a forwarded port in your system browser.
+        "modelith.canvas.display": "tab"
+      }
+    }
+  },
+
+  // The canvas server binds 4800 inside the container; forward it so the browser
+  // tab the extension opens reaches it. onAutoForward: silent — the extension
+  // opens the URL itself; no need for a popup.
+  "forwardPorts": [4800],
+  "portsAttributes": {
+    "4800": { "label": "Modelith ER canvas", "onAutoForward": "silent" }
+  }
+}

modelith_dbt-0.4.0/.devcontainer/setup-demo.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# postCreate for the Modelith onboarding devcontainer.
+#
+# Deliberately does NOT scaffold anything into the workspace. This container is
+# meant to be opened on YOUR repo, and a setup script that ran `mdl init --demo`
+# into the workspace would litter your working tree with model/ and transform/.
+# So this only confirms the CLI is installed; you run the demo yourself, when you
+# want it, from the integrated terminal (see the banner below).
+#
+# The Modelith extension is installed automatically by Dev Containers from the
+# customizations.vscode.extensions list in devcontainer.json (marketplace id).
+set -euo pipefail
+
+export PATH="$HOME/.local/bin:$PATH"
+
+echo "==> mdl on PATH?"
+command -v mdl >/dev/null 2>&1 && mdl --help >/dev/null 2>&1 \
+  && echo "    yes: $(command -v mdl)" \
+  || { echo "    NO — CLI not detected; the extension's zero-config path would also fail"; exit 1; }
+
+cat <<'EOF'
+
+============================================================
+CLI ready, extension installed. Nothing was scaffolded into your workspace.
+
+To try the demo (writes to ~/modelith-demo, never your repo):
+
+    mdl init --demo                     # 7-entity model + DuckDB dbt project
+    mdl serve -m ~/modelith-demo/model  # populated ER canvas on :4800
+
+Or point the extension at it: set modelith.modelDir to
+~/modelith-demo/model, then run "Modelith: Open Canvas".
+
+To model YOUR project instead, reverse an existing dbt warehouse:
+
+    mdl reverse --project path/to/target/manifest.json -o model
+
+Zero-config check: nothing set modelith.mdlPath — the extension found `mdl`
+on PATH by itself.
+============================================================
+EOF

{modelith_dbt-0.3.2/.claude/worktrees/wf_432922b6-b0e-4 → modelith_dbt-0.4.0}/.gitignore

@@ -32,3 +32,6 @@ demo/**/dbt_packages/
 
 # macOS
 .DS_Store
+
+# Container-generated YAML-schema settings (paths are machine-specific).
+.vscode/settings.json

modelith_dbt-0.3.2/.claude/worktrees/wf_432922b6-b0e-4/README.md → modelith_dbt-0.4.0/PKG-INFO

@@ -1,3 +1,29 @@
+Metadata-Version: 2.5
+Name: modelith-dbt
+Version: 0.4.0
+Summary: Ontology-anchored, git-native data modeling tool for dbt-core teams
+License: Apache-2.0
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: dbt-artifacts-parser>=0.5
+Requires-Dist: fastapi>=0.110
+Requires-Dist: httpx>=0.27
+Requires-Dist: jinja2>=3.1
+Requires-Dist: mcp<2,>=1.2
+Requires-Dist: pydantic>=2.6
+Requires-Dist: pygls>=2.0
+Requires-Dist: pyshacl>=0.25
+Requires-Dist: python-multipart>=0.0.18
+Requires-Dist: rdflib>=7.0
+Requires-Dist: ruamel-yaml>=0.18
+Requires-Dist: sqlglot>=25
+Requires-Dist: typer>=0.12
+Requires-Dist: uvicorn>=0.29
+Provides-Extra: audit
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20; extra == 'audit'
+Requires-Dist: opentelemetry-sdk>=1.20; extra == 'audit'
+Description-Content-Type: text/markdown
+
 # Modelith
 
 **Modelith is the modeling layer dbt-core is missing: design entities and relationships
@@ -99,8 +125,8 @@ Code, Cursor, Windsurf, and VSCodium: open the Extensions panel and search for
 **Modelith**, or install from the command line.
 
 ```bash
-code --install-extension modelith.modelith-vscode        # VS Code
-# cursor --install-extension modelith.modelith-vscode    # Cursor
+code --install-extension BosonResearch.modelith-vscode        # VS Code
+# cursor --install-extension BosonResearch.modelith-vscode    # Cursor
 ```
 
 ### From source
@@ -1000,6 +1026,40 @@ whether it was allowed — never the model's *contents* (those live in git for w
 repo access). Off entirely when neither variable is set. `GET /api/audit` tails the local
 file and is admin-gated under `MDL_AUTH_REQUIRE`.
 
+**Anonymous usage telemetry (distinct from the audit log).** To help prioritize the roadmap,
+Modelith can send *anonymous* product-usage events keyed on a locally generated, hashed
+install id shared by the CLI and the extension (both read `~/.modelith/telemetry.json`, so
+one anonymous id spans your CLI and editor usage). Each event carries only the
+coarse shape of usage — an event name (e.g. `model_validated`, `warehouse_reversed`,
+`canvas_opened`), whether it succeeded, the `mdl` version, and a coarse OS/timestamp. It
+**never** sends model contents, schema, file paths, project names, repo URLs, command
+arguments, or error messages.
+
+It is **opt-in and off by default**, with two ways to opt in:
+
+- **CLI on its own** — nothing is sent until you answer "yes" to a one-time prompt, which
+  only appears on an interactive terminal (never in CI, scripts, or background calls).
+- **Via the VS Code extension** — if your editor's telemetry setting
+  (`telemetry.telemetryLevel`) is enabled, the extension treats that as consent and records
+  it in `~/.modelith/telemetry.json`. Because that file is shared, **`mdl` runs then also
+  emit** (in the VS Code terminal and elsewhere) under the same anonymous id — so your editor
+  and CLI usage form one funnel. If VS Code telemetry is off, neither surface sends anything.
+  An explicit CLI opt-out you made in the prompt is never overridden by the editor setting.
+
+Either way it stays anonymous, and you can turn it off everywhere at any time:
+
+```bash
+export DO_NOT_TRACK=1                 # the community standard, honored (overrides all)
+export MODELITH_TELEMETRY_DISABLED=1  # Modelith-specific
+# or edit ~/.modelith/telemetry.json  ("enabled": false)
+# or turn off VS Code telemetry (telemetry.telemetryLevel: "off")
+```
+
+Data is sent to a PostHog project in the EU (Frankfurt). This is separate from the per-org
+**audit log** above: that is named, self-hosted governance data to *your* collector; this is
+anonymous product analytics. The emitter is open source — read exactly what is sent in
+`packages/cli/src/mdl_cli/telemetry.py` and `vscode/src/telemetry.ts`.
+
 **Distributing it.** The app is a client over the API, so it can be hosted anywhere:
 
 ```bash

modelith_dbt-0.3.2/PKG-INFO → modelith_dbt-0.4.0/README.md

@@ -1,28 +1,3 @@
-Metadata-Version: 2.5
-Name: modelith-dbt
-Version: 0.3.2
-Summary: Ontology-anchored, git-native data modeling tool for dbt-core teams
-License: Apache-2.0
-License-File: LICENSE
-Requires-Python: >=3.11
-Requires-Dist: dbt-artifacts-parser>=0.5
-Requires-Dist: fastapi>=0.110
-Requires-Dist: jinja2>=3.1
-Requires-Dist: mcp<2,>=1.2
-Requires-Dist: pydantic>=2.6
-Requires-Dist: pygls>=2.0
-Requires-Dist: pyshacl>=0.25
-Requires-Dist: python-multipart>=0.0.18
-Requires-Dist: rdflib>=7.0
-Requires-Dist: ruamel-yaml>=0.18
-Requires-Dist: sqlglot>=25
-Requires-Dist: typer>=0.12
-Requires-Dist: uvicorn>=0.29
-Provides-Extra: audit
-Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20; extra == 'audit'
-Requires-Dist: opentelemetry-sdk>=1.20; extra == 'audit'
-Description-Content-Type: text/markdown
-
 # Modelith
 
 **Modelith is the modeling layer dbt-core is missing: design entities and relationships
@@ -124,8 +99,8 @@ Code, Cursor, Windsurf, and VSCodium: open the Extensions panel and search for
 **Modelith**, or install from the command line.
 
 ```bash
-code --install-extension modelith.modelith-vscode        # VS Code
-# cursor --install-extension modelith.modelith-vscode    # Cursor
+code --install-extension BosonResearch.modelith-vscode        # VS Code
+# cursor --install-extension BosonResearch.modelith-vscode    # Cursor
 ```
 
 ### From source
@@ -1025,6 +1000,40 @@ whether it was allowed — never the model's *contents* (those live in git for w
 repo access). Off entirely when neither variable is set. `GET /api/audit` tails the local
 file and is admin-gated under `MDL_AUTH_REQUIRE`.
 
+**Anonymous usage telemetry (distinct from the audit log).** To help prioritize the roadmap,
+Modelith can send *anonymous* product-usage events keyed on a locally generated, hashed
+install id shared by the CLI and the extension (both read `~/.modelith/telemetry.json`, so
+one anonymous id spans your CLI and editor usage). Each event carries only the
+coarse shape of usage — an event name (e.g. `model_validated`, `warehouse_reversed`,
+`canvas_opened`), whether it succeeded, the `mdl` version, and a coarse OS/timestamp. It
+**never** sends model contents, schema, file paths, project names, repo URLs, command
+arguments, or error messages.
+
+It is **opt-in and off by default**, with two ways to opt in:
+
+- **CLI on its own** — nothing is sent until you answer "yes" to a one-time prompt, which
+  only appears on an interactive terminal (never in CI, scripts, or background calls).
+- **Via the VS Code extension** — if your editor's telemetry setting
+  (`telemetry.telemetryLevel`) is enabled, the extension treats that as consent and records
+  it in `~/.modelith/telemetry.json`. Because that file is shared, **`mdl` runs then also
+  emit** (in the VS Code terminal and elsewhere) under the same anonymous id — so your editor
+  and CLI usage form one funnel. If VS Code telemetry is off, neither surface sends anything.
+  An explicit CLI opt-out you made in the prompt is never overridden by the editor setting.
+
+Either way it stays anonymous, and you can turn it off everywhere at any time:
+
+```bash
+export DO_NOT_TRACK=1                 # the community standard, honored (overrides all)
+export MODELITH_TELEMETRY_DISABLED=1  # Modelith-specific
+# or edit ~/.modelith/telemetry.json  ("enabled": false)
+# or turn off VS Code telemetry (telemetry.telemetryLevel: "off")
+```
+
+Data is sent to a PostHog project in the EU (Frankfurt). This is separate from the per-org
+**audit log** above: that is named, self-hosted governance data to *your* collector; this is
+anonymous product analytics. The emitter is open source — read exactly what is sent in
+`packages/cli/src/mdl_cli/telemetry.py` and `vscode/src/telemetry.ts`.
+
 **Distributing it.** The app is a client over the API, so it can be hosted anywhere:
 
 ```bash

modelith_dbt-0.4.0/docs/product-strategy/.gitignore

@@ -0,0 +1,5 @@
+# Sensitive product/GTM strategy material — never committed.
+# Ignore everything in this directory...
+*
+# ...except this .gitignore itself, so the folder's intent travels with the repo.
+!.gitignore

modelith_dbt-0.4.0/docs/product-strategy/modelith-gtm-monetisation-spec.md

@@ -0,0 +1,261 @@
+# Modelith Go-to-Market and Monetisation Spec
+
+Status: draft v2
+Owner: dbose
+Scope: the 180-day plan to grow adoption and stand up a revenue line, without taxing the individual engineer who makes the tool spread.
+
+Changelog from v1: pricing anchored to real 2026 comparables (dbt, Grafana, Datafold, Tobiko). New licensing section built on the HashiCorp and Sentry precedents. Datafold reframed as a structural opening. ROI framing borrowed from Tobiko. Positioning of the open-core line validated against Grafana's model.
+
+---
+
+## 1. Thesis
+
+Modelith wins the same way dbt did. Bottom-up. An analytics engineer installs a CLI, gets value in one sitting, and tells the next engineer. The company only shows up to pay once the tool is already load-bearing in their pipeline.
+
+So the plan has one rule that overrides everything else: the individual local workflow stays free and un-crippled forever. Every dollar comes from the team plane, where the buyer is a platform lead or a data architect, not the engineer who first ran `mdl init`.
+
+The commercial wedge is not the ERD canvas. Diagramming is how a new user falls in love in the first 30 seconds, but nobody wires a purchase order to a picture. The thing an org pays to keep running is drift enforcement in CI: the gate that fails a pull request when the warehouse no longer matches the committed model. That converts Modelith from a nice local viewer into production infrastructure with a blast radius if it disappears. Everything below is built to march a user from the canvas to that gate.
+
+---
+
+## 2. What the comparable platforms actually do
+
+Five companies sell into roughly Modelith's world. Their models, with the lesson for you, from 2026 pricing pages.
+
+| Company | Free tier | Paid entry | Enterprise floor | Meters on | The lesson |
+|---|---|---|---|---|---|
+| dbt Labs | Developer, 1 seat, 3k models/mo, 1 project | Starter $100 / user / mo, 5 seats | Custom, SLA + PrivateLink + 30 projects | seats + models built + projects | a genuinely useful single-seat free product is the whole funnel |
+| Grafana | $0, 3 users, community support, 14-day retention | Pro $19 / mo + usage | $25k / year minimum | active users + usage (series, GB) | OSS stays fully functional; gate enterprise connectors, SSO, reporting, RBAC, support |
+| Datafold | none, no free trial | quote only, sales-gated | quote | data source connections + data volume | its lack of a free tier is your opening (see 2.1) |
+| Tobiko (SQLMesh) | SQLMesh + SQLGlot, full OSS | Tobiko Cloud, managed | quote | managed service + warehouse savings | sell the ROI in warehouse compute and incidents avoided, not features |
+| PostHog | generous usage-based free tier | transparent per-unit usage | volume-discounted | events, recordings, flags | publish self-serve pricing; do not hide it behind a demo |
+
+The pattern across the winners is consistent. Free is a real product, not a trailer. The first paid tier is self-serve with a published price. Enterprise carries a floor around $25k and is where security, deployment, and support live. Grafana is the closest structural match to Modelith and worth copying almost directly: the open-source Grafana is complete on its own, and the money sits in enterprise data-source plugins, SAML and LDAP auth, reporting, role-based access, and a support contract. Map that onto Modelith and the paid layer is the catalog adapters, the SSO header trust, the audit retention, RBAC, and the CI gate. You already built most of it.
+
+### 2.1 Datafold is the opening, not just the competitor
+
+Datafold owns the "diff and drift in CI" category that Modelith's gate competes in. But its pricing is quote-only, sales-gated, with no free tier and no self-serve trial, metered on data-source connections and volume. That is a top-down enterprise motion. It means a single analytics engineer cannot land Datafold on a Tuesday afternoon and show their team by Thursday.
+
+Modelith can. A free CLI with local `mdl drift` is a bottom-up motion Datafold structurally cannot run without cannibalising its own sales-led pricing. So the wedge is not "we diff better." It is "you can adopt us without a procurement cycle, and the gate you fell in love with locally is the same gate your platform team turns on in CI." Name that in the launch content. The incumbent's go-to-market is the gap.
+
+---
+
+## 3. The open-core boundary
+
+The core is Apache-2.0 and stays that way (see the licensing covenant in section 8, which is not optional). Do not gate features by crippling the local binary. Gate at the network boundary instead: the paid capabilities are the ones that naturally need a shared server, a shared identity, or a shared enforcement point, so they live in a hosted control plane rather than hidden inside the CLI. This is exactly Grafana's split, and it is why Grafana kept community goodwill through a decade of commercial growth while Elastic and Redis and HashiCorp burned theirs relicensing.
+
+The split, mapped to what already exists in the repo:
+
+| Capability | Where it lives today | Tier |
+|---|---|---|
+| `mdl` CLI: init, validate, generate, reverse, lint | local | Free |
+| Web canvas (`mdl serve` / `mdl studio`), ERD preview | local | Free |
+| VS Code extension: preview-to-side, YAML completion, diagnostics on save | local | Free |
+| Language server (`mdl lsp`) hover, code actions | local | Free |
+| Local `mdl drift` run against a compiled warehouse | local | Free |
+| Single-target dbt emit (pick one platform) | local | Free |
+| Ontology browse and local alignment | local | Free |
+| CI drift enforcement gate (blocking, hosted, with policy + reporting) | server / GitHub App | Team |
+| Centralized ontology sync across repos | server | Team |
+| Hosted glossary/Studio for SMEs with managed identity | server | Team |
+| Multi-target emitters (Snowflake + Redshift + Iceberg + Trino + ODCS + Pydantic + Neo4j in one project) | local, license-gated | Team |
+| Audit log retention and search (the OpenTelemetry sink you built) | server | Team |
+| CODEOWNERS-routed proposal review with PR state | server | Team |
+| Enterprise catalog sync (Collibra adapter, OpenLineage emission) | server + adapter | Enterprise |
+| SSO header trust, SAML/OIDC via proxy, `MDL_AUTH_REQUIRE` | server | Enterprise |
+| Conformance kit for a bespoke governance mapping | server + support | Enterprise |
+| VPC / on-prem deployment, RBAC, SLA, SOC 2 | deployment | Enterprise |
+
+Two features sit on the line and need a deliberate call. Local `mdl drift` run stays free, because an engineer checking drift on their laptop is exactly the taste that sells the gate. The blocking gate that runs in the org's CI, with a shared policy file and a report, is paid, because that is the thing with organisational value and a natural server home. Multi-target emit is the one local feature worth a license key: a solo user needs one warehouse, a platform team needs four, so the count is a clean proxy for "this is a team now."
+
+### Technical gating
+
+- Server-native features (CI gate, ontology sync, catalog sync, hosted Studio, audit retention) are gated by simply being a service you authenticate to. No key-cracking risk, because the code is not shipped.
+- The one local paid feature (multi-target emit) uses a signed license key checked offline. Over the free limit of one target, `mdl generate` prints an upgrade line and the target list it would have emitted. It never deletes work or holds a model hostage. Leaning toward dropping even this and making multi-target a server feature, to keep the OSS binary entirely key-free (see open decisions).
+- Ship `modelith-enterprise` as a separate closed package that depends on the Apache core. The core never imports it. This keeps the license story clean for anyone auditing the OSS.
+
+---
+
+## 4. Phase 1: Frictionless onboarding (Days 1 to 30)
+
+Goal: a first-time user reaches a rendered ERD beside their own dbt YAML, with a green `mdl validate`, in under a minute, on the first try, with no config. This is the dbt-Developer-tier lesson made literal: the free experience has to be a complete product.
+
+### 4.1 One-command setup
+
+- Keep `uv tool install modelith-dbt` and `pipx install modelith-dbt` as the two blessed paths. Pin them at the top of the README and the site.
+- VS Code, Cursor, Windsurf: the extension must resolve `mdl` with zero settings when the user did a standard tool install. The detection order already exists (explicit setting, project `.venv`, PATH, conda/virtualenv, per-user install dirs). Add one thing: when detection fails, the extension offers a one-click "install the CLI for me" that runs the `uv` command in an integrated terminal, rather than a docs link.
+- Remote environments and devcontainers: the extension already declares `extensionKind: ["workspace"]`, so the server runs next to dbt and the warehouse creds. Add a `.devcontainer` feature (`ghcr.io/dbose/features/modelith`) so a team adds Modelith to a codespace with one line. Verify the auto-bind on a cold Codespaces boot and a cold Gitpod boot before calling this done.
+
+Acceptance:
+- Fresh machine, no Python project, to `mdl --help` working: under 2 minutes.
+- Fresh VS Code with the extension and a dbt repo open, to canvas rendering: under 30 seconds, no manual path config.
+
+### 4.2 Instant value demonstration
+
+- Ship a sample project inside the package: `mdl init --demo` scaffolds a 6 to 10 entity model with keys, one enumerated domain, one relationship, and a matching set of generated dbt models, so the very first `mdl serve` shows a populated canvas rather than an empty grid. The repo already tracks demo projects as adoption assets; wire one to the init command.
+- The demo must run the full loop offline against DuckDB: `mdl init --demo`, `mdl serve`, edit an attribute on the canvas, `mdl validate`, `mdl generate -o warehouse`, `dbt build`. No warehouse account required to feel the whole thing.
+- Record a 90-second screen capture of exactly that loop and put it above the fold on the site and the README. The canvas moving beside YAML is the entire pitch; show it, do not describe it.
+
+Acceptance:
+- `mdl init --demo && mdl serve` renders a non-empty ERD with no further input.
+- A user with only DuckDB completes model to `dbt build` without creating any external account.
+
+### 4.3 What to instrument now
+
+Stand up privacy-respecting, opt-in telemetry before the launch traffic hits, or you will be blind during the one window when data matters most. Opt-in on first run, one prompt, off by default if declined, and never phone home model contents. Capture command name, success or failure, and a hashed install id. That is enough to compute activation and retention and nothing that reads a customer's schema.
+
+Activation metric for the whole phase: percentage of new installs that reach `mdl validate` passing within 24 hours of first `mdl init`. Target 40 percent by day 30.
+
+---
+
+## 5. Phase 2: Distribution and word-of-mouth (Days 31 to 90)
+
+Goal: turn a working tool into a known one, on the three channels where dbt practitioners actually gather.
+
+### 5.1 Targeted community launches
+
+Sequence them, do not fire all at once. Each launch feeds the next with proof.
+
+- Week 5, dbt Slack `#tools-and-tech`: soft launch to the highest-intent, most forgiving audience. Lead with the reverse-engineering demo, since every one of them has a legacy dbt project and no diagram of it. "Point `mdl reverse` at your manifest and get a logical model back" is the hook that gets a data engineer to run one command.
+- Week 7, r/dataengineering: a written teardown, not an ad. Title angle: reverse an existing warehouse into a model, align it to an ontology, and catch the drift, with real command output and the DuckDB demo anyone can reproduce. The recent drug-discovery demo (reverse a real warehouse plus live ontology alignment) is the strongest artifact you have; clean it up and make it the centrepiece.
+- Week 9, Hacker News: Show HN with the single sharpest differentiator, the git-native model where every surface is a client and none owns state. HN rewards an architectural idea with a working repo behind it. Have the maintainer free that whole day to answer every comment in the first three hours, because that thread is the launch. HN also punishes a rug-pull reputation, so lead with the Apache covenant (section 8) in the post itself.
+
+For each launch, prepare the same three proof points and pick the one that fits the audience: live ERD canvas beside YAML, ontology-anchored governance, and the CI drift gate that names which dbt models a change will break.
+
+### 5.2 High-intent content
+
+Write for the engineer typing a specific problem into a search bar, not for a newsletter. Each piece ends at a command they can run.
+
+Launch set, in priority order:
+1. "How to enforce dbt data contracts in VS Code before you open the PR." The flagship. Show diagnostics on save, then the gate.
+2. "Reverse engineer an undocumented dbt project into an ERD in one command." Highest reproducibility, widest audience.
+3. "Catch a breaking schema change before it ships: drift detection in GitHub Actions." This is the paid feature's own top-of-funnel; the article is free, the gate it demonstrates is the Team tier.
+4. "Let a business analyst edit the glossary without a GitHub account." The SME-to-PR story, which no competitor has.
+5. "Adopt drift-in-CI without a procurement cycle." The Datafold-shaped hole from section 2.1, written as a migration path, not a hit piece.
+
+Cadence: one deep piece every two weeks, each with copy-paste commands and the DuckDB demo so a reader reproduces it in five minutes. Cross-post to the personal blog, dev.to, and the relevant subreddit. One canonical URL, the rest with canonical tags.
+
+Metric for the phase: GitHub stars are vanity; track weekly active installs (telemetry) and `mdl reverse` runs, since reverse is the command a serious evaluator runs against their own code.
+
+---
+
+## 6. Phase 3: The enterprise bridge (Days 91 to 180)
+
+Goal: convert the teams already running Modelith locally into paying accounts, triggered by the product noticing they became a team.
+
+### 6.1 The freemium split goes live
+
+Ship the Team tier as a real thing a lead can buy with a card, self-serve, no sales call for the first band. This is the PostHog and Grafana Pro lesson: publish the price, let them swipe. Datafold's sales-gate is the thing you are beating, so do not import it. The gated capabilities are the ones from section 3: the blocking CI drift gate, centralized ontology sync, the hosted SME Studio with managed identity, multi-target emit, and audit retention. Local ERD preview, YAML completion, and local diagnostics stay free and get no downgrade, because the moment an individual engineer feels punished, the bottom-up engine stalls.
+
+### 6.2 Product-triggered inbound
+
+This is the mechanism that makes the whole plan self-driving. Modelith can see when a solo project became a team project, from signals it already has, and turn that into a prompt at the exact moment the pain is real.
+
+Detection signals, all local, all already present:
+- The model repo's `git shortlog` shows more than one committer in the last 30 days.
+- The proposal flow has resolved more than one distinct identity (the identity seam records `source` and author on every propose).
+- More than one target platform is configured, or a `set_kg_base_iri` exists, both markers of a shared model rather than a scratchpad.
+
+When two or more of those fire, `mdl` and the extension surface one quiet, dismissible prompt: this looks like a team model, turn on drift enforcement so a breaking change fails the PR instead of reaching the warehouse. One line, a link to enable, and it never nags again once dismissed. No dark patterns, no interrupting a build.
+
+The prompt routes to the Team tier signup, not to a "contact sales" form, for anything under the enterprise band. Sales only enters when the account needs catalog sync, SSO, or a VPC deploy.
+
+Acceptance:
+- The multi-dev detector fires correctly on a two-committer demo repo and stays silent on a solo one.
+- The prompt appears at most once per workspace until dismissed, and dismissal is durable.
+
+### 6.3 First enterprise motion
+
+By day 120, line up three design-partner conversations from the highest-signal inbound (accounts that hit the multi-dev prompt and also touch Collibra, OpenLineage, or an SSO proxy header). Offer the Enterprise tier at a design-partner rate in exchange for a reference and a case study. The conformance kit you already built is the artifact that lets a partner validate their own bespoke catalog mapping in CI, which is the thing that closes a governance buyer.
+
+---
+
+## 7. Pricing and packaging
+
+Meter on the unit that tracks value and does not tax adoption. Not per-engineer-seat, because that punishes the exact people who spread the tool. Meter on governed workspaces plus steward seats, the way Datafold meters connections and Grafana meters active users, and let viewers and proposers in for free.
+
+| Tier | Who buys | Unit | Indicative price | Anchored against |
+|---|---|---|---|---|
+| Community | individual engineer | free | $0 | dbt Developer, SQLMesh OSS |
+| Team | platform lead | per governed repo/workspace, includes 3 steward seats | $600 to $1,200 / workspace / month | dbt Starter ($100 x 5 seats = $500 floor), Grafana Pro |
+| Enterprise | data governance / platform org | annual contract | from $30k ACV | Grafana $25k floor, Datafold quote, dbt custom |
+
+The band is deliberately just above dbt Starter's effective floor. A platform team already paying dbt $500-plus a month for five seats will not blink at a comparable number for the tool that stops a bad model reaching the warehouse dbt then builds into. The enterprise floor sits at the category norm, since Grafana's published minimum is $25k and Datafold and dbt both quote north of that.
+
+Notes on the metering choice:
+- Viewers and SME proposers are always free. The whole SME-to-PR story dies if you charge the business analyst a seat; their edits are the reason a platform team buys.
+- Steward seats (the people who approve proposals and own the gate) are the paid seats above the workspace base. That is a small, senior population, which is who to charge.
+- A workspace equals one governed model repo. A company with 4 governed marts pays for 4, which scales with how much of their stack actually depends on Modelith.
+- Publish this. Do not put the Team price behind a demo form. The self-serve price is a competitive weapon against Datafold's quote-only wall.
+
+### 7.1 Sell the ROI, not the feature list
+
+Tobiko sells SQLMesh's cloud on warehouse compute saved, a number a buyer can put in a spreadsheet. Modelith's equivalent is incidents prevented. One breaking schema change that reaches production and silently corrupts a downstream mart costs an org a debugging fire drill, a backfill, and a trust hit with the business. The gate that catches it at PR time, naming the exact dbt models it would break, is cheap against that. Frame the Team tier in those terms on the pricing page: a workspace subscription is less than the cost of one prevented data incident a quarter.
+
+Give a 12-month free Team tier to any project under an OSI-approved open-source license. Cheap goodwill, and it seeds public examples of Modelith-governed repos that become their own top-of-funnel.
+
+---
+
+## 8. Licensing: the covenant and the enterprise license
+
+The single biggest reputational risk to an open-core project is the relicensing rug-pull, and the last three years are a graveyard of them. HashiCorp moved Terraform from MPL to the Business Source License in 2023, the community forked it into OpenTofu within months, and the Linux Foundation now hosts the fork. Redis relicensed and the community left for the Valkey fork. Elastic went to SSPL, took years of reputational damage, and later re-added an open license to stop the bleeding. The lesson is uniform: relicensing a project after a community has formed around its open license is read as a betrayal, and the fork that follows takes the mindshare with it.
+
+So the rule for Modelith is a public, dated covenant, stated in the README and the launch posts:
+
+> The `modelith` core (the CLI, canvas, LSP, and everything in the Apache-2.0 packages today) will remain Apache-2.0. New paid capabilities ship as separate components under their own license. The core license will not be revoked or narrowed.
+
+That promise is worth more than any feature, because it is the thing a platform team's architect worries about before they build a workflow on you. Make it loud.
+
+For the paid components, two options, and a recommendation.
+
+- Straight commercial license on `modelith-enterprise` and the hosted control plane. Simple, well understood, and the code is server-side anyway so almost nobody sees it. This is Grafana's enterprise model.
+- Functional Source License (FSL) on the server plane, the model Sentry created. FSL forbids a competitor from using the code to build a competing product for two years, then it automatically converts to Apache or MIT (the delayed-open-source mechanism). It buys protection against a hyperscaler wrapping your hosted Studio and reselling it, while still committing the code to real open source on a timer.
+
+Recommendation: commercial license for `modelith-enterprise` now, because the immediate risk is not a hyperscaler, it is shipping revenue. Hold FSL in reserve for the hosted Studio if and when a cloud provider starts circling. Either way, the Apache core covenant is non-negotiable and comes first.
+
+---
+
+## 9. Risk mitigation blueprint
+
+- Do not over-charge engineers. The metering unit in section 7 is the enforcement of this. The individual local tool never degrades, never expires, never nags beyond the single team-detection prompt. If an engineer ever feels the free tier is bait, the flywheel breaks, so treat the free experience as a paid feature in its own right. This is the dbt Developer tier discipline.
+- Make the CI gate genuinely better than a diagram. The gate must do what a static diagram cannot: classify a change as breaking, additive, or cosmetic, and name the exact dbt models a breaking change will take down, at PR time, in under 30 seconds on a 400-model project (the repo already claims this bar; hold it as a hard SLO). That sentence, printed on the PR, is the difference between a convenience and a safeguard nobody will remove.
+- Guard the OSS trust with the covenant in section 8. Every gated feature must have a clear "this needs a server or a team, that is why it costs money" story. The day a community user feels a purely local capability moved behind a paywall, the Hacker News goodwill inverts, and the HashiCorp precedent shows how fast a fork forms.
+- Do not out-run support. A solo maintainer cannot both ship enterprise features and answer a launch-week flood. Stage the launches (section 5.1) so the traffic arrives in waves you can actually respond to, and hold the enterprise motion until the Team tier is self-serve enough to not need you in every deal.
+- Single-maintainer bus factor. Before the enterprise motion, get CI green and badged, publish the contribution guide, and land at least two external contributors on small issues. An enterprise buyer diligences the project's survival, and a one-person repo with no CI is a procurement blocker regardless of how good the code is.
+
+---
+
+## 10. Milestones
+
+| Day | Milestone | Proof it worked |
+|---|---|---|
+| 15 | `mdl init --demo` ships; extension one-click CLI install; telemetry opt-in live; Apache covenant published | fresh-machine demo loop under 2 min, recorded |
+| 30 | Site with the 90-second canvas video; activation instrumented; Team price published | 40% of new installs reach passing `mdl validate` in 24h |
+| 45 | dbt Slack launch | first 100 non-author installs |
+| 60 | r/dataengineering teardown + reverse-engineering article | weekly active installs trending up 4 weeks straight |
+| 75 | Show HN | top-half HN placement, maintainer answered every first-3-hour comment |
+| 90 | Content set 1 to 5 published | `mdl reverse` runs from distinct installs across a target you set |
+| 120 | Team tier self-serve live; multi-dev prompt shipped | first paid workspace, prompt fires correctly on team repos |
+| 150 | 3 enterprise design-partner conversations open | one signed design-partner LOI |
+| 180 | First Enterprise contract or design-partner case study | ARR line exists; one public reference |
+
+---
+
+## 11. Open decisions
+
+- Hosted control plane build vs the GitHub App path for the CI gate. The App is the faster route to a gate that runs in the customer's CI without you hosting their data; decide before day 90. (Taking this one next.)
+- Whether multi-target emit is worth the license-key machinery, or whether it should just be a Team-server feature to avoid shipping any offline key check at all. Leaning toward the latter to keep the OSS binary key-free.
+- Team price point: validate the $600 to $1,200 band against 5 real platform leads before the pricing page ships. The anchor says it is right; five conversations will say whether it is.
+- FSL vs straight commercial for the hosted Studio. Default commercial now, revisit if a cloud provider starts circling.
+
+---
+
+## Sources
+
+- [dbt pricing 2026, Mammoth](https://mammoth.io/blog/dbt-pricing/) and [dbt Labs pricing](https://www.getdbt.com/pricing)
+- [Grafana pricing](https://grafana.com/pricing/)
+- [Datafold pricing 2026, Modern DataTools](https://www.modern-datatools.com/tools/datafold/pricing) and [Datafold pricing](https://www.datafold.com/pricing)
+- [Tobiko launches SQLMesh cloud into GA, The New Stack](https://thenewstack.io/tobiko-launches-its-sqlmesh-based-cloud-service-into-ga/)
+- [PostHog pricing 2026, StackScored](https://www.stackscored.com/pricing/product-analytics/posthog/)
+- [Terraform BSL license change, Spacelift](https://spacelift.io/blog/terraform-license-change) and [OpenTofu manifesto](https://opentofu.org/manifesto/)
+- [Fall 2024 software licensing roundup (FSL, Fair Source, DOSP), FOSSA](https://fossa.com/blog/fall-2024-software-licensing-roundup/) and [Sentry FSL, TechCrunch](https://techcrunch.com/2023/11/20/with-functional-source-license-sentry-wants-to-grant-developers-freedom-without-harmful-free-riding/)