@opengroundplan/core 0.1.1

package/templates/architectures/bff/files/src/downstream/profile-client.ts

@@ -0,0 +1,18 @@
+import { downstreamConfig } from './config.js';
+import { getJson } from './http-client.js';
+
+/** The upstream service's shape. No BFF re-exports this — each maps it into its own DTO. */
+export interface ProfileRecord {
+  readonly id: string;
+  readonly displayName: string;
+  readonly email: string;
+  readonly avatarUrl: string | null;
+  readonly locale: string;
+}
+
+export function fetchProfile(userId: string): Promise<ProfileRecord> {
+  return getJson<ProfileRecord>(
+    downstreamConfig.profileBaseUrl,
+    `/profiles/${encodeURIComponent(userId)}`,
+  );
+}

package/templates/architectures/clean/blueprint.yaml

@@ -0,0 +1,147 @@
+id: clean
+kind: architecture
+name: Clean Architecture
+description: >-
+  Four concentric rings — Domain, Application, Infrastructure, Web — with source dependencies
+  pointing inwards only and use cases as an explicit layer. Contributes the folder skeleton per
+  stack plus a boundary check that fails a build, because a boundary that lives only in prose
+  gets violated.
+
+tags:
+  - clean-architecture
+  - dependency-rule
+  - use-cases
+  - layering
+  - boundaries
+  - fitness-function
+
+# Nothing: the overlay contributes structure and one check, and composes onto any base whose
+# supportsArchitectures lists `clean`.
+requires: []
+
+# A rival application-layout overlay (onion, hexagonal) declares the conflict from its own
+# side — naming an id that does not exist yet makes the whole catalog fail to load, and the
+# resolver accepts one architecture per run regardless.
+conflicts: []
+
+# Capability names, so a CI or agent-kit layer can key off "this repo has a boundary gate"
+# instead of naming this blueprint.
+provides:
+  - architecture-layout
+  - boundary-check
+
+supportsArchitectures: []
+
+variables:
+  # Same name and default as the .NET bases and testing-unit, so a dotnet interview asks once.
+  - name: dotnetTargetFramework
+    prompt: Target framework for the ring projects and the architecture test
+    type: string
+    default: net10.0
+    required: false
+    when: "stack == 'dotnet'"
+
+  # Same name and choices as testing-unit, for the same reason.
+  - name: pythonPackageManager
+    prompt: Python package manager (used to install import-linter)
+    type: select
+    default: uv
+    required: false
+    when: "stack == 'python'"
+    choices:
+      - { value: uv, label: uv }
+      - { value: pip, label: pip }
+      - { value: poetry, label: poetry }
+
+files:
+  # ── every stack ─────────────────────────────────────────────────────────────
+  # Not docs/ARCHITECTURE.md: the agent-kit owns that path and writes it after this overlay,
+  # so sharing it would be a plan-time conflict rather than an append.
+  - from: files/docs/architecture/clean.md
+    to: .
+
+  # ── dotnet ──────────────────────────────────────────────────────────────────
+  # A ring is a project here, which is why the fitness test can assert on assembly references.
+  - from: files/src/__solutionName.dot__.*/*.csproj
+    to: .
+    when: "stack == 'dotnet'"
+  - from: files/src/__solutionName.dot__.*/*.cs
+    to: .
+    when: "stack == 'dotnet'"
+  - from: files/src/__solutionName.dot__.*/*/.gitkeep
+    to: .
+    when: "stack == 'dotnet'"
+  - from: files/tests/__solutionName.dot__.ArchitectureTests/*
+    to: .
+    when: "stack == 'dotnet'"
+
+  # ── python ──────────────────────────────────────────────────────────────────
+  # `__init__` has no matching variable, so plan warns that it was left literal. That is the
+  # engine reporting a real Python filename, not a defect — see tokens.renderPath.
+  - from: files/src/__solutionName.snake__/**/__init__.py
+    to: .
+    when: "stack == 'python'"
+  - from: files/.importlinter
+    to: .
+    when: "stack == 'python'"
+
+  # ── go ──────────────────────────────────────────────────────────────────────
+  - from: files/internal/**/*.go
+    to: .
+    when: "stack == 'go'"
+
+  # ── node / typescript / polyglot ────────────────────────────────────────────
+  # The checker walks from the repo root and reads rings off folder names, so it needs no
+  # configuration and works unchanged in a monorepo with several packages.
+  - from: files/scripts/check-architecture.mjs
+    to: .
+    when: "stack == 'node' || stack == 'typescript' || stack == 'polyglot'"
+  - from: files/eslint.config.architecture.mjs
+    to: .
+    when: "stack == 'node' || stack == 'typescript' || stack == 'polyglot'"
+  # No skeleton for polyglot: package layout is the monorepo's own decision, and a src/ tree
+  # at the repo root would be wrong in every workspace.
+  - from: files/src/domain/README.md
+    to: .
+    when: "stack == 'node' || stack == 'typescript'"
+  - from: files/src/application/*/README.md
+    to: .
+    when: "stack == 'node' || stack == 'typescript'"
+  - from: files/src/infrastructure/README.md
+    to: .
+    when: "stack == 'node' || stack == 'typescript'"
+
+  # Declared, not installed by a post-apply step: a package added after generation is
+  # missing from the first install (ADR 0005, spec 003).
+  - from: files/pyproject.toml
+    to: .
+    onConflict: merge
+    when: "stack == 'python'"
+
+  # The solution is completed declaratively rather than by `dotnet sln add`, which runs
+  # after the first build and is skippable — a solution missing projects that exist on
+  # disk builds green while covering less than the repo contains (ADR 0005, spec 003).
+  - from: files/__solutionName.dot__.slnx
+    to: .
+    onConflict: merge
+    when: "stack == 'dotnet'"
+
+  # Central package management: versions live in Directory.Packages.props and projects
+  # reference without one. A bare Version= on a PackageReference fails restore (NU1008).
+  - from: files/Directory.Packages.props
+    to: .
+    onConflict: merge
+    when: "stack == 'dotnet'"
+
+postApply:
+  # Globs are expanded by the shell, so these are no-ops on a shell without globbing.
+  # docs/architecture/clean.md carries the same commands for a manual run.
+  # The Web ring calls use cases, so it references Application — and only Application.
+  - run: dotnet add src/*.Api/*.csproj reference src/*.Application/*.csproj
+    when: "stack == 'dotnet'"
+    optional: true
+
+
+  - run: npm pkg set "scripts.check:arch"="node scripts/check-architecture.mjs"
+    when: "stack == 'node' || stack == 'typescript' || stack == 'polyglot'"
+    optional: true

package/templates/architectures/clean/files/.importlinter

@@ -0,0 +1,35 @@
+# Boundary enforcement for the Clean Architecture rings. Run with `lint-imports`;
+# a violated contract exits non-zero, so wire it into CI next to the linter.
+[importlinter]
+root_package = {{ solutionName | snake }}
+# Required by the forbidden contract below — external packages are otherwise not in the graph.
+include_external_packages = True
+
+[importlinter:contract:dependency-rule]
+name = Dependency Rule — source dependencies point inwards only
+type = layers
+# Highest first. Parentheses mark a layer as optional — the base owns `api`, not this overlay.
+# Anything not listed (main, config, settings) is the composition root and is deliberately
+# unconstrained; it is the one place allowed to wire concretions to ports.
+layers =
+    (api)
+    infrastructure
+    application
+    domain
+containers =
+    {{ solutionName | snake }}
+
+[importlinter:contract:core-is-framework-free]
+name = Domain and Application import no delivery or persistence framework
+type = forbidden
+source_modules =
+    {{ solutionName | snake }}.domain
+    {{ solutionName | snake }}.application
+forbidden_modules =
+    fastapi
+    starlette
+    uvicorn
+    sqlalchemy
+    httpx
+# A port is the answer when one of these is genuinely needed: declare it in
+# application.ports and implement it in infrastructure.

package/templates/architectures/clean/files/Directory.Packages.props

@@ -0,0 +1,7 @@
+<Project>
+  <ItemGroup>
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.8.1" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
+    <PackageVersion Include="xunit.v3" Version="3.2.2" />
+  </ItemGroup>
+</Project>

package/templates/architectures/clean/files/__solutionName.dot__.slnx

@@ -0,0 +1,10 @@
+<Solution>
+  <Folder Name="/src/">
+    <Project Path="src/{{ solutionName | dot }}.Application/{{ solutionName | dot }}.Application.csproj" />
+    <Project Path="src/{{ solutionName | dot }}.Domain/{{ solutionName | dot }}.Domain.csproj" />
+    <Project Path="src/{{ solutionName | dot }}.Infrastructure/{{ solutionName | dot }}.Infrastructure.csproj" />
+  </Folder>
+  <Folder Name="/tests/">
+    <Project Path="tests/{{ solutionName | dot }}.ArchitectureTests/{{ solutionName | dot }}.ArchitectureTests.csproj" />
+  </Folder>
+</Solution>

package/templates/architectures/clean/files/docs/architecture/clean.md

@@ -0,0 +1,87 @@
+# Clean Architecture — {{ solutionName | title }}
+
+Four concentric rings. **Domain** at the centre, then **Application**, then **Infrastructure**,
+then **Web** at the rim. Stack: `{{ stack }}`.
+
+| Ring | Holds | May depend on |
+|---|---|---|
+| **Domain** | Entities, value objects, domain events, domain exceptions | nothing |
+| **Application** | Use cases, and the port interfaces a use case needs | Domain |
+| **Infrastructure** | Adapters implementing those ports — persistence, HTTP clients, clocks, queues | Application, Domain |
+| **Web** | Delivery: routes, controllers, serialization, DI wiring | Application, Domain |
+
+## The one rule
+
+> Source code dependencies can only point inwards. Nothing in an inner circle can know
+> anything at all about something in an outer circle.
+>
+> — Robert C. Martin, [*The Clean Architecture*](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html)
+
+Every other line in this file is a consequence of that sentence. When you are unsure where a
+file belongs, do not ask what it does — ask which ring it is not allowed to know about.
+
+### The one exception
+
+The Web ring is also the **composition root**. It is the only place permitted to name a
+concrete Infrastructure type, and only in order to register that type against an Application
+port. Microsoft's Clean Architecture guidance calls this exception out by name. A concrete
+Infrastructure type referenced anywhere else in the Web ring is a violation, not a shortcut.
+
+## Use cases are a ring, not a folder convention
+
+The Application ring exists so that "what the system does" has somewhere to live that is not a
+controller and not an entity. A use case is a single class or function with one entry point,
+its inputs and outputs are its own types, and every external capability it needs arrives as a
+port it defines itself. If a use case imports a database driver, the port is missing.
+
+Ports are declared **in** Application and implemented **in** Infrastructure. That inversion is
+the entire mechanism — it is what lets the core be unit-tested with no infrastructure present.
+
+## Adding a use case
+
+1. Add or extend the entity in **Domain**. No framework types, no persistence attributes.
+2. Add the use case in **Application**. Define any new port next to it as an interface.
+3. Implement the port in **Infrastructure**.
+4. Register the implementation against the port in the **Web** composition root.
+5. Call the use case from a route or controller. The route holds no business rules.
+
+Steps 1–3 are testable without a running process. If a step needs one, a ring is wrong.
+
+## The boundary check
+
+This layout is enforced mechanically, not by review. Prose boundaries get violated.
+
+| Stack | Command | Enforced by |
+|---|---|---|
+| .NET | `dotnet test` | `tests/*.ArchitectureTests` — reflection over assembly references |
+| Python | `lint-imports` | `.importlinter` — layers + forbidden contracts |
+| Go | `go test ./...` | `internal/architecture` — AST walk over the module's own imports |
+| Node / TypeScript | `npm run check:arch` | `scripts/check-architecture.mjs` — zero-dependency import scan |
+
+Wire this into CI next to lint. A check that only runs locally is a check that does not run.
+
+### Manual wiring, if the post-apply step was skipped
+
+The .NET projects need nothing here: they are listed in the `.slnx` and reference each other
+at generation time, so `dotnet build` and `dotnet test` find them on a fresh clone.
+
+```
+# Python
+uv add --dev import-linter        # or: pip install import-linter
+
+# Node
+npm pkg set "scripts.check:arch"="node scripts/check-architecture.mjs"
+```
+
+When you add a **new** .NET project later, put it in the solution yourself:
+
+```
+dotnet sln add src/YourSolution.NewRing/YourSolution.NewRing.csproj
+```
+
+## Sources
+
+- Robert C. Martin, *The Clean Architecture* — the Dependency Rule and the four circles.
+- Microsoft Learn, [*Common web application architectures*](https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/common-web-application-architectures) — ring contents, and the composition-root exception.
+- Jeffrey Palermo, *The Onion Architecture* — the coupling argument this style inherits.
+- Alistair Cockburn, *Hexagonal Architecture* — ports and adapters, the mechanism behind the inversion.

package/templates/architectures/clean/files/eslint.config.architecture.mjs

@@ -0,0 +1,27 @@
+// Editor-time half of the boundary check. Spread it into eslint.config.mjs:
+//
+//   import architecture from './eslint.config.architecture.mjs';
+//   export default [...architecture, /* the rest of your config */];
+//
+// `npm run check:arch` stays the authority: it needs no linter, covers the Infrastructure
+// ring too, and runs in CI whether or not this file was ever wired up.
+const inward = (rings, message) => ({
+  'no-restricted-imports': ['error', { patterns: [{ group: rings, message }] }],
+});
+
+export default [
+  {
+    files: ['**/domain/**/*.{js,mjs,cjs,ts,tsx}'],
+    rules: inward(
+      ['**/application/**', '**/infrastructure/**'],
+      'Domain is the innermost ring and may not know about Application or Infrastructure.',
+    ),
+  },
+  {
+    files: ['**/application/**/*.{js,mjs,cjs,ts,tsx}'],
+    rules: inward(
+      ['**/infrastructure/**'],
+      'Application declares the port; Infrastructure implements it. The dependency points inwards.',
+    ),
+  },
+];

package/templates/architectures/clean/files/internal/application/doc.go

@@ -0,0 +1,2 @@
+// Package application holds the use cases. It imports domain and nothing further out.
+package application

package/templates/architectures/clean/files/internal/application/ports/doc.go

@@ -0,0 +1,2 @@
+// Package ports declares the interfaces the use cases need. Infrastructure implements them.
+package ports

package/templates/architectures/clean/files/internal/architecture/architecture_test.go

@@ -0,0 +1,166 @@
+package architecture
+
+import (
+	"go/parser"
+	"go/token"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Ring order is this architecture's definition, not configuration: a package may import its
+// own ring and any ring further in, never one further out.
+var ringOrder = map[string]int{
+	"domain":         0,
+	"application":    1,
+	"infrastructure": 2,
+}
+
+// Everything outside a ring directory is the web ring: delivery, plus the composition root.
+const webRing = 3
+
+var skippedDirs = map[string]bool{
+	".git":         true,
+	"vendor":       true,
+	"node_modules": true,
+	"bin":          true,
+	"dist":         true,
+	"testdata":     true,
+}
+
+// Mechanisms. A core ring reaching for one of these has lost its independence from I/O.
+var mechanismsBannedInCore = []string{"net/http", "database/sql", "os/exec"}
+
+func TestDependenciesPointInward(t *testing.T) {
+	root := moduleRoot(t)
+	prefix := modulePath(t, root) + "/"
+
+	forEachImport(t, root, func(file, importPath string) {
+		if !strings.HasPrefix(importPath, prefix) {
+			return
+		}
+
+		from := ringOf(relativeTo(root, file))
+		to := ringOf(strings.TrimPrefix(importPath, prefix))
+		if from < to {
+			t.Errorf("%s (%s ring) imports %s (%s ring); dependencies point inwards only",
+				relativeTo(root, file), ringName(from), importPath, ringName(to))
+		}
+	})
+}
+
+func TestCoreRingsImportNoMechanism(t *testing.T) {
+	root := moduleRoot(t)
+
+	forEachImport(t, root, func(file, importPath string) {
+		if ringOf(relativeTo(root, file)) > ringOrder["application"] {
+			return
+		}
+		for _, banned := range mechanismsBannedInCore {
+			if importPath == banned || strings.HasPrefix(importPath, banned+"/") {
+				t.Errorf("%s is a core ring and may not import %q; declare a port instead",
+					relativeTo(root, file), importPath)
+			}
+		}
+	})
+}
+
+// ringOf reads the innermost ring directory out of a path. The folder name is the boundary —
+// nothing else decides which ring a package belongs to.
+func ringOf(path string) int {
+	ring := webRing
+	for _, segment := range strings.Split(filepath.ToSlash(path), "/") {
+		if rank, ok := ringOrder[segment]; ok {
+			ring = rank
+		}
+	}
+	return ring
+}
+
+func ringName(rank int) string {
+	for name, value := range ringOrder {
+		if value == rank {
+			return name
+		}
+	}
+	return "web"
+}
+
+func forEachImport(t *testing.T, root string, check func(file, importPath string)) {
+	t.Helper()
+	fset := token.NewFileSet()
+
+	err := filepath.WalkDir(root, func(path string, entry fs.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		if entry.IsDir() {
+			if path != root && (skippedDirs[entry.Name()] || strings.HasPrefix(entry.Name(), ".")) {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		if !strings.HasSuffix(entry.Name(), ".go") {
+			return nil
+		}
+
+		parsed, parseErr := parser.ParseFile(fset, path, nil, parser.ImportsOnly)
+		if parseErr != nil {
+			return parseErr
+		}
+		for _, spec := range parsed.Imports {
+			check(path, strings.Trim(spec.Path.Value, `"`))
+		}
+		return nil
+	})
+	if err != nil {
+		t.Fatalf("walking %s: %v", root, err)
+	}
+}
+
+// moduleRoot walks up from the test's working directory to the directory holding go.mod, so
+// no path is baked into the test.
+func moduleRoot(t *testing.T) string {
+	t.Helper()
+
+	dir, err := os.Getwd()
+	if err != nil {
+		t.Fatalf("working directory: %v", err)
+	}
+	for {
+		if _, statErr := os.Stat(filepath.Join(dir, "go.mod")); statErr == nil {
+			return dir
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			t.Fatalf("no go.mod above %s", dir)
+		}
+		dir = parent
+	}
+}
+
+func modulePath(t *testing.T, root string) string {
+	t.Helper()
+
+	contents, err := os.ReadFile(filepath.Join(root, "go.mod"))
+	if err != nil {
+		t.Fatalf("reading go.mod: %v", err)
+	}
+	for _, line := range strings.Split(string(contents), "\n") {
+		if path, found := strings.CutPrefix(strings.TrimSpace(line), "module "); found {
+			return strings.TrimSpace(path)
+		}
+	}
+
+	t.Fatalf("go.mod in %s declares no module path", root)
+	return ""
+}
+
+func relativeTo(root, path string) string {
+	if relative, err := filepath.Rel(root, path); err == nil {
+		return filepath.ToSlash(relative)
+	}
+	return filepath.ToSlash(path)
+}

package/templates/architectures/clean/files/internal/architecture/doc.go

@@ -0,0 +1,3 @@
+// Package architecture holds the fitness test that enforces the dependency rule.
+// It contains no production code.
+package architecture

package/templates/architectures/clean/files/internal/domain/doc.go

@@ -0,0 +1,2 @@
+// Package domain holds entities and value objects. It imports nothing from this module.
+package domain

package/templates/architectures/clean/files/internal/infrastructure/doc.go

@@ -0,0 +1,2 @@
+// Package infrastructure holds the adapters that satisfy the application ports.
+package infrastructure

package/templates/architectures/clean/files/pyproject.toml

@@ -0,0 +1,2 @@
+[dependency-groups]
+dev = ["import-linter==2.13"]

package/templates/architectures/clean/files/scripts/check-architecture.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+// Clean Architecture boundary check: fails when a source dependency points outward.
+// Zero dependencies on purpose — it runs before anything is installed, under any linter,
+// and in a monorepo with several packages.
+import { readdirSync, readFileSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+
+// Ring order is the architecture's definition, not configuration.
+const RING_ORDER = { domain: 0, application: 1, infrastructure: 2 };
+const WEB_RING = 3;
+const RING_NAMES = ['domain', 'application', 'infrastructure', 'web'];
+
+const SKIPPED = new Set(['node_modules', 'dist', 'build', 'out', 'coverage', '.git', '.next', '.turbo']);
+const SOURCE = /\.[cm]?[jt]sx?$/;
+// Covers `import x from 'a'`, `import 'a'`, `export … from 'a'`, `require('a')` and `import('a')`.
+// A commented-out import still counts; that is the conservative direction for a boundary check.
+const SPECIFIER = /\b(?:from|import|require)\s*\(?\s*(['"])([^'"]+)\1/g;
+
+const root = process.cwd();
+
+function* sourceFiles(directory) {
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (!SKIPPED.has(entry.name)) yield* sourceFiles(join(directory, entry.name));
+    } else if (SOURCE.test(entry.name)) {
+      yield join(directory, entry.name);
+    }
+  }
+}
+
+// The innermost ring directory in a path wins. The folder name is the boundary.
+function ringOf(path) {
+  let ring = WEB_RING;
+  for (const segment of path.split(/[\\/]/)) {
+    if (Object.hasOwn(RING_ORDER, segment)) ring = RING_ORDER[segment];
+  }
+  return ring;
+}
+
+// Relative specifiers have to be resolved: `./repository` carries no ring segment of its own.
+// Bare and aliased ones are read as written, and one with no ring segment is an external
+// package — unranked, and out of scope.
+function ringOfSpecifier(file, specifier) {
+  if (specifier.startsWith('.')) return ringOf(relative(root, resolve(dirname(file), specifier)));
+  return specifier.split('/').some((segment) => Object.hasOwn(RING_ORDER, segment)) ? ringOf(specifier) : null;
+}
+
+const violations = [];
+
+for (const file of sourceFiles(root)) {
+  const from = ringOf(relative(root, file));
+
+  for (const [, , specifier] of readFileSync(file, 'utf8').matchAll(SPECIFIER)) {
+    const to = ringOfSpecifier(file, specifier);
+    if (to !== null && from < to) {
+      violations.push(`${relative(root, file)} (${RING_NAMES[from]}) imports '${specifier}' (${RING_NAMES[to]})`);
+    }
+  }
+}
+
+if (violations.length > 0) {
+  console.error('Dependency Rule violated — source dependencies may only point inwards:\n');
+  for (const violation of violations) console.error(`  ${violation}`);
+  console.error(`\n${violations.length} violation(s). See docs/architecture/clean.md.`);
+  process.exit(1);
+}
+
+console.log('Dependency Rule holds: every source dependency points inwards.');

package/templates/architectures/clean/files/src/__solutionName.dot__.Application/Abstractions/.gitkeep

@@ -0,0 +1 @@
+# Ports: interfaces the use cases need. Declared here, implemented in Infrastructure.

package/templates/architectures/clean/files/src/__solutionName.dot__.Application/AssemblyMarker.cs

@@ -0,0 +1,10 @@
+using System.Reflection;
+
+namespace {{ solutionName | dot }}.Application;
+
+// Anchors this ring's assembly so the architecture fitness tests never depend on a
+// string assembly name that a rename would silently break.
+public static class AssemblyMarker
+{
+    public static Assembly Assembly => typeof(AssemblyMarker).Assembly;
+}

package/templates/architectures/clean/files/src/__solutionName.dot__.Application/UseCases/.gitkeep

@@ -0,0 +1 @@
+# One class per use case, one entry point each. This is what the system does.

package/templates/architectures/clean/files/src/__solutionName.dot__.Application/__solutionName.dot__.Application.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <RootNamespace>{{ solutionName | dot }}.Application</RootNamespace>
+    <AssemblyName>{{ solutionName | dot }}.Application</AssemblyName>
+  </PropertyGroup>
+
+  <!-- Domain only. A package needed to *implement* something belongs in Infrastructure;
+       Application declares the port and never learns what satisfies it. -->
+  <ItemGroup>
+    <ProjectReference Include="../{{ solutionName | dot }}.Domain/{{ solutionName | dot }}.Domain.csproj" />
+  </ItemGroup>
+
+</Project>

package/templates/architectures/clean/files/src/__solutionName.dot__.Domain/AssemblyMarker.cs

@@ -0,0 +1,10 @@
+using System.Reflection;
+
+namespace {{ solutionName | dot }}.Domain;
+
+// Anchors this ring's assembly so the architecture fitness tests never depend on a
+// string assembly name that a rename would silently break.
+public static class AssemblyMarker
+{
+    public static Assembly Assembly => typeof(AssemblyMarker).Assembly;
+}

package/templates/architectures/clean/files/src/__solutionName.dot__.Domain/Entities/.gitkeep

@@ -0,0 +1 @@
+# Entities and aggregates. Business rules only — no framework types, no persistence attributes.

package/templates/architectures/clean/files/src/__solutionName.dot__.Domain/Events/.gitkeep

@@ -0,0 +1 @@
+# Domain events. Raised by entities, named in the past tense, carrying no infrastructure types.

package/templates/architectures/clean/files/src/__solutionName.dot__.Domain/ValueObjects/.gitkeep

@@ -0,0 +1 @@
+# Value objects: immutable, compared by value, self-validating in the constructor.

package/templates/architectures/clean/files/src/__solutionName.dot__.Domain/__solutionName.dot__.Domain.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <RootNamespace>{{ solutionName | dot }}.Domain</RootNamespace>
+    <AssemblyName>{{ solutionName | dot }}.Domain</AssemblyName>
+  </PropertyGroup>
+
+  <!-- Deliberately no ProjectReference and no PackageReference: the innermost ring depends on
+       nothing. tests/*.ArchitectureTests fails the build if that ever changes. -->
+
+</Project>