@opengroundplan/core 0.1.1

package/templates/architectures/monolith/files/docs/architecture/monolith.python.md

@@ -0,0 +1,71 @@
+# Architecture — Monolith (single deployable)
+
+One process, one release train, partitioned into features over a deliberately small shared
+kernel. This is the start-here layout: cheap enough that a small team is not paying for
+boundaries it does not need yet, seamed so a feature can be lifted out later.
+
+## The one rule that matters
+
+> **A feature is entered through its front door, and the kernel never walks through it.**
+>
+> From outside `{{ solutionName | snake }}.features.<name>`, the only importable module is the
+> feature package itself. Nothing in `{{ solutionName | snake }}.shared` may import a feature at
+> all. `pytest tests/architecture` fails on either, and `lint-imports` fails on the second.
+
+Those two facts are exactly what makes extraction possible later. A feature nobody reached into
+can be moved whole; a kernel that names no feature travels with it instead of holding it back.
+
+**Calling another feature through its front door is allowed.** That is the difference between
+this style and vertical slices — you are paying for a single deployable, so take the cheap
+in-process call. Every one of those calls is a line you will have to make remote on the day you
+split, which is why they go through a surface you control rather than into someone's internals.
+
+## Layout
+
+```
+src/{{ solutionName | snake }}/
+  shared/                    # the kernel: depends on nothing above it
+    __init__.py              #   its published surface
+    errors.py                #   AppError — one failure shape for every feature
+  features/
+    __init__.py              # composition root: the only module that knows all features
+    {{ featureName | snake }}/
+      __init__.py            #   THE FRONT DOOR — Protocol + factory + re-exports
+      service.py             #   private; add modules beside it freely
+tests/architecture/
+  test_monolith_boundaries.py
+.importlinter
+```
+
+Add a feature by copying `features/{{ featureName | snake }}/` and adding a line to
+`build_features()`; the fitness test walks the tree, so there is nothing else to register.
+
+## Enforcement
+
+```
+pytest tests/architecture                       # both rules, no per-feature upkeep
+python tests/architecture/test_monolith_boundaries.py   # same rules without the test layer
+lint-imports                                    # the .importlinter contract: kernel below features
+```
+
+The test parses imports with `ast`, resolves relative imports, and treats
+`from <feature> import <submodule>` as the deep import it is. `ARCH_SOURCE_ROOT`,
+`ARCH_FEATURES_PACKAGE` and `ARCH_SHARED_PACKAGE` move the roots. A self-test case list proves
+the rule still fires, and finding no source root is a failure rather than a pass.
+
+## Kernel admission rule (not mechanically enforced)
+
+A thing moves into `shared/` when **a second feature needs it AND it names no feature**. The
+tooling enforces the second half only. Nothing can prove the first half for you, so it belongs
+in review: a kernel that grows by one module per feature has become a `common/` dumping ground,
+and that is the failure mode this style dies of.
+
+## When to stop using this
+
+Split a feature out when two teams block on the same pipeline, or when one feature measurably
+needs an order of magnitude more capacity than the rest — not before. Until then the deploy
+queue is not the constraint, and every distributed failure mode you have not bought is a win.
+
+Sources: [Fowler — MonolithFirst](https://martinfowler.com/bliki/MonolithFirst.html) ·
+[Fowler — MicroservicePremium](https://martinfowler.com/bliki/MicroservicePremium.html) ·
+[import-linter contracts](https://import-linter.readthedocs.io/en/stable/contract_types.html).

package/templates/architectures/monolith/files/internal/architecture/boundary_test.go

@@ -0,0 +1,141 @@
+// Package architecture holds the monolith's fitness test. Two rules: a feature is entered
+// through its front door package, and the shared kernel never imports a feature. Go's own
+// internal/ rule already fails `go build` on part of the first one; this test covers the rest
+// and reports both in CI terms.
+package architecture
+
+import (
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// Path segments that name the two boundaries. Overridable, but the defaults match the layout.
+var (
+	featuresSegment = envOr("ARCH_FEATURES_SEGMENT", "internal/features")
+	sharedSegment   = envOr("ARCH_SHARED_SEGMENT", "internal/shared")
+)
+
+func envOr(key, fallback string) string {
+	if value := os.Getenv(key); value != "" {
+		return value
+	}
+	return fallback
+}
+
+// locate returns the feature owning an import path and how deep past its front door the path
+// reaches. An empty name means the path is not inside a feature.
+func locate(importPath string) (feature string, depth int) {
+	marker := "/" + featuresSegment + "/"
+	index := strings.Index(importPath, marker)
+	if index < 0 {
+		return "", 0
+	}
+	segments := strings.Split(importPath[index+len(marker):], "/")
+	return segments[0], len(segments) - 1
+}
+
+func inShared(importPath string) bool {
+	marker := "/" + sharedSegment
+	return strings.Contains(importPath, marker+"/") || strings.HasSuffix(importPath, marker)
+}
+
+// violation is the pair of rules, isolated so the self-test proves they still fire.
+func violation(fromPkg, imported string) string {
+	target, depth := locate(imported)
+	if target == "" {
+		return ""
+	}
+	if inShared(fromPkg) {
+		return "the kernel must not name a feature: imports " + imported
+	}
+	if owner, _ := locate(fromPkg); owner == target {
+		return ""
+	}
+	if depth == 0 {
+		// Calling another feature through its front door is allowed on purpose.
+		return ""
+	}
+	return "reaches behind the front door of feature " + target + ": " + imported
+}
+
+func TestBoundaryRulesStillDetectAViolation(t *testing.T) {
+	cases := []struct {
+		from, imported string
+		want           bool
+	}{
+		{"x/internal/features/orders", "x/internal/features/catalog/store", true},
+		{"x/internal/features/orders", "x/internal/features/catalog", false},
+		{"x/internal/features/catalog", "x/internal/features/catalog/internal/store", false},
+		{"x/internal/features", "x/internal/features/catalog", false},
+		{"x/internal/shared/apperr", "x/internal/features/catalog", true},
+		{"x/cmd/app", "x/internal/features/catalog", false},
+	}
+	for _, c := range cases {
+		if (violation(c.from, c.imported) != "") != c.want {
+			t.Fatalf("violation(%q, %q): want fail=%v", c.from, c.imported, c.want)
+		}
+	}
+}
+
+func TestFeaturesAreEnteredThroughTheirFrontDoor(t *testing.T) {
+	root, modulePath := repoRoot(t)
+	fset := token.NewFileSet()
+
+	var failures []string
+	err := filepath.WalkDir(root, func(path string, entry os.DirEntry, err error) error {
+		if err != nil || entry.IsDir() || !strings.HasSuffix(path, ".go") {
+			return err
+		}
+		rel, _ := filepath.Rel(root, filepath.Dir(path))
+		fromPkg := modulePath + "/" + filepath.ToSlash(rel)
+
+		file, err := parser.ParseFile(fset, path, nil, parser.ImportsOnly)
+		if err != nil {
+			return err
+		}
+		for _, spec := range file.Imports {
+			imported := strings.Trim(spec.Path.Value, `"`)
+			if message := violation(fromPkg, imported); message != "" {
+				failures = append(failures, fromPkg+": "+message)
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(failures) > 0 {
+		t.Fatalf("monolith boundary violations:\n%s", strings.Join(failures, "\n"))
+	}
+}
+
+var moduleLine = regexp.MustCompile(`(?m)^module\s+(\S+)`)
+
+// repoRoot walks up from the test's working directory to the go.mod, and returns its module path.
+func repoRoot(t *testing.T) (string, string) {
+	t.Helper()
+	dir, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for {
+		candidate := filepath.Join(dir, "go.mod")
+		if content, err := os.ReadFile(candidate); err == nil {
+			match := moduleLine.FindSubmatch(content)
+			if match == nil {
+				t.Fatalf("no module line in %s", candidate)
+			}
+			return dir, string(match[1])
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			t.Fatal("go.mod not found above the test directory")
+		}
+		dir = parent
+	}
+}

package/templates/architectures/monolith/files/internal/features/__featureName.lower__/__featureName.lower__.go

@@ -0,0 +1,37 @@
+// Package {{ featureName | lower }} is the front door of the {{ featureName | lower }} feature: the only package inside it
+// that anything outside may import. The compiler enforces that for the internal/ subtree, and
+// internal/architecture/boundary_test.go enforces it for every other subpackage.
+package {{ featureName | lower }}
+
+import (
+	"context"
+
+	"{{ moduleHost }}/{{ solutionName | kebab }}/internal/features/{{ featureName | lower }}/internal/store"
+	"{{ moduleHost }}/{{ solutionName | kebab }}/internal/shared/apperr"
+)
+
+// Summary is the read model handed across the boundary. Never a persistence row.
+type Summary struct {
+	ID   string
+	Name string
+}
+
+// Feature is everything another feature may call. Widen it deliberately, not by accident.
+type Feature interface {
+	Find(ctx context.Context, id string) (*Summary, error)
+}
+
+// New wires the feature. The caller gets the interface and learns nothing about what is behind it.
+func New() Feature { return &service{repo: store.New()} }
+
+// service is unexported: the implementation is private even inside this package.
+type service struct {
+	repo *store.Repository
+}
+
+func (s *service) Find(ctx context.Context, id string) (*Summary, error) {
+	if id == "" {
+		return nil, apperr.New("invalid_id", "An id is required.")
+	}
+	return &Summary{ID: id, Name: s.repo.NameOf(ctx, id)}, nil
+}

package/templates/architectures/monolith/files/internal/features/__featureName.lower__/internal/store/store.go

@@ -0,0 +1,14 @@
+// Package store is private to the {{ featureName | lower }} feature: `go build` refuses this import from
+// anywhere outside internal/features/{{ featureName | lower }}. Replace it with real persistence.
+package store
+
+import "context"
+
+type Repository struct{}
+
+func New() *Repository { return &Repository{} }
+
+// NameOf stands in for a real query; ctx is threaded now so adding one changes no signature.
+func (r *Repository) NameOf(ctx context.Context, id string) string {
+	return "{{ featureName | title }} " + id
+}

package/templates/architectures/monolith/files/internal/features/features.go

@@ -0,0 +1,18 @@
+// Package features is the composition root: the one place features are assembled, and the only
+// package allowed to know all of them. Extracting a feature starts by deleting a field here.
+package features
+
+import (
+	"{{ moduleHost }}/{{ solutionName | kebab }}/internal/features/{{ featureName | lower }}"
+)
+
+// Set is handed to the transport layer, which calls front doors and nothing else.
+type Set struct {
+	{{ featureName | pascal }} {{ featureName | lower }}.Feature
+}
+
+func Build() Set {
+	return Set{
+		{{ featureName | pascal }}: {{ featureName | lower }}.New(),
+	}
+}

package/templates/architectures/monolith/files/internal/shared/apperr/apperr.go

@@ -0,0 +1,17 @@
+// Package apperr is the kernel's failure type. Features report failure with a stable code and
+// the edge — HTTP handler, worker, CLI — is the only place that turns a code into a status.
+//
+// The kernel admits a thing when a second feature needs it AND it names no feature. Skip the
+// second half and the kernel becomes what you cannot extract a feature away from.
+package apperr
+
+// Error carries a transport-agnostic code alongside the message.
+type Error struct {
+	Code    string
+	Message string
+}
+
+func (e *Error) Error() string { return e.Code + ": " + e.Message }
+
+// New keeps construction in one place so codes stay a closed set.
+func New(code, message string) *Error { return &Error{Code: code, Message: message} }

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

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

package/templates/architectures/monolith/files/scripts/check-monolith-boundaries.mjs

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/**
+ * Architecture fitness test for the monolith.
+ *
+ * Two rules, both of which exist so a feature can still be lifted out into its own service later:
+ *   1. from outside a feature, the only importable path is that feature's front door (index),
+ *   2. the shared kernel never imports a feature.
+ * Calling another feature through its front door is allowed — that is the whole point of paying
+ * for one deployable instead of several.
+ *
+ * Zero dependencies on purpose: the bases disagree on linter (ESLint vs Biome), so this check
+ * works without editing whichever config the base already owns. Exits non-zero on a violation.
+ * It reads import specifiers as written and never resolves them on disk, so it is immune to
+ * TypeScript/bundler resolution differences.
+ */
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+
+/** Every tunable lives here. Nothing below reads the environment directly. */
+const config = {
+  /** A child directory of this root is a feature. In a monorepo, point it at the app. */
+  featuresRoot: process.env.ARCH_FEATURES_ROOT ?? 'src/features',
+  /** The shared kernel. Code here may be used by anything and may depend on nothing above it. */
+  sharedRoot: process.env.ARCH_SHARED_ROOT ?? 'src/shared',
+  /** Basename of a feature's public entry file. */
+  frontDoor: 'index',
+  scanRoots: split(process.env.ARCH_SCAN_ROOTS) ?? ['src', 'apps', 'packages'],
+  extensions: ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs'],
+  skipDirs: ['node_modules', 'dist', 'build', 'out', 'coverage', '.git', '.turbo', '.next'],
+};
+
+function split(value) {
+  return value ? value.split(',').map((entry) => entry.trim()).filter(Boolean) : undefined;
+}
+
+const SPECIFIER_PATTERNS = [
+  /\bfrom\s*['"]([^'"]+)['"]/g,
+  /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+  /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+  /\bimport\s+['"]([^'"]+)['"]/g,
+];
+
+/** Last segment of the features root, as it appears inside alias imports like `@/features/x`. */
+const featuresSegment = config.featuresRoot.split('/').filter(Boolean).at(-1);
+
+export function specifiersOf(source) {
+  const found = new Set();
+  for (const pattern of SPECIFIER_PATTERNS) {
+    pattern.lastIndex = 0;
+    for (const match of source.matchAll(pattern)) found.add(match[1]);
+  }
+  return [...found];
+}
+
+/** `{ feature, rest }` for a path inside a feature, else null. A file sitting directly in the
+ *  features root — the registry — belongs to no feature and counts as outside every one. */
+function locate(posixPath) {
+  const prefix = `${config.featuresRoot}/`;
+  if (!posixPath.startsWith(prefix)) return null;
+  const segments = posixPath.slice(prefix.length).split('/');
+  return segments.length < 2 ? null : { feature: segments[0], rest: segments.slice(1) };
+}
+
+/** Alias and package specifiers carry no repo path, so match on the `features/<name>` segment. */
+function locateSpecifier(specifier) {
+  const segments = specifier.split('/');
+  const at = segments.lastIndexOf(featuresSegment);
+  if (at < 0 || at >= segments.length - 1) return null;
+  return { feature: segments[at + 1], rest: segments.slice(at + 2) };
+}
+
+function isFrontDoor(rest) {
+  if (rest.length === 0) return true;
+  return rest.length === 1 && path.posix.parse(rest[0]).name === config.frontDoor;
+}
+
+/** The two rules, isolated so `--self-test` can prove they still fire. */
+export function violationOf(fromFile, specifier) {
+  const target = specifier.startsWith('.')
+    ? locate(path.posix.normalize(path.posix.join(path.posix.dirname(fromFile), specifier)))
+    : locateSpecifier(specifier);
+  if (target === null) return null;
+
+  if (fromFile === config.sharedRoot || fromFile.startsWith(`${config.sharedRoot}/`)) {
+    return `imports "${specifier}" — the kernel must stay below the features, not name one`;
+  }
+
+  const owner = locate(fromFile);
+  if (owner !== null && owner.feature === target.feature) return null;
+  if (isFrontDoor(target.rest)) return null;
+
+  return (
+    `imports "${specifier}" — that is behind the front door of feature "${target.feature}"; ` +
+    `re-export what you need from ${config.featuresRoot}/${target.feature}/${config.frontDoor}`
+  );
+}
+
+async function listFiles(root) {
+  const found = [];
+  const walk = async (dir) => {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const child = path.posix.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!config.skipDirs.includes(entry.name)) await walk(child);
+      } else if (config.extensions.includes(path.extname(entry.name))) {
+        found.push(child);
+      }
+    }
+  };
+  await walk(root);
+  return found;
+}
+
+async function discoverFeatures() {
+  const entries = await readdir(config.featuresRoot, { withFileTypes: true }).catch(() => []);
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+
+const SELF_TEST_CASES = [
+  ['src/features/orders/orders.service.ts', '../catalog/catalog.service.js', true],
+  ['src/features/orders/orders.service.ts', '../catalog/index.js', false],
+  ['src/features/catalog/index.ts', './catalog.service.js', false],
+  ['src/features/index.ts', './catalog/index.js', false],
+  ['src/shared/errors.ts', '../features/catalog/index.js', true],
+  ['src/app.ts', '@/features/catalog/internal/store', true],
+  ['src/app.ts', '@/features/catalog', false],
+];
+
+function selfTest() {
+  const wrong = SELF_TEST_CASES.filter(
+    ([file, specifier, expected]) => Boolean(violationOf(file, specifier)) !== expected,
+  );
+  for (const [file, specifier] of wrong) console.error(`self-test failed: ${file} -> ${specifier}`);
+  return wrong.length === 0;
+}
+
+async function main() {
+  if (process.argv.includes('--self-test')) {
+    if (!selfTest()) process.exit(1);
+    console.log(`monolith boundary rules verified against ${SELF_TEST_CASES.length} cases`);
+    return;
+  }
+
+  const features = await discoverFeatures();
+  if (features.length === 0) {
+    // A silent pass over an empty file set is the failure mode this check exists to avoid.
+    console.error(`No features found under ${config.featuresRoot} — is ARCH_FEATURES_ROOT right?`);
+    process.exit(1);
+  }
+
+  const roots = [...new Set([...config.scanRoots, config.featuresRoot, config.sharedRoot])];
+  const files = [...new Set((await Promise.all(roots.map(listFiles))).flat())];
+
+  const violations = [];
+  for (const file of files) {
+    const source = await readFile(file, 'utf8');
+    for (const specifier of specifiersOf(source)) {
+      const violation = violationOf(file, specifier);
+      if (violation) violations.push(`${file}: ${violation}`);
+    }
+  }
+
+  if (violations.length > 0) {
+    console.error(`Monolith boundary violations (${violations.length}):`);
+    for (const violation of violations) console.error(`  ${violation}`);
+    process.exit(1);
+  }
+
+  const kernel = files.filter((file) => file.startsWith(`${config.sharedRoot}/`)).length;
+  console.log(
+    `Monolith boundaries hold: ${features.length} feature(s), ` +
+      `${kernel} kernel file(s), ${files.length} file(s) scanned.`,
+  );
+}
+
+if (!selfTest()) {
+  console.error('The boundary rules no longer detect a known violation — fix violationOf().');
+  process.exit(1);
+}
+await main();

package/templates/architectures/monolith/files/src/__solutionName.dot__.Api/Features/__featureName.pascal__/Internal/__featureName.pascal__Service.cs

@@ -0,0 +1,12 @@
+using {{ solutionName | dot }}.Api.Kernel;
+
+namespace {{ solutionName | dot }}.Api.Features.{{ featureName | pascal }}.Internal;
+
+/// <summary>Private to this feature. Replace with the real implementation; add types beside it
+/// freely — nothing outside the feature may reference this namespace.</summary>
+internal sealed class {{ featureName | pascal }}Service : I{{ featureName | pascal }}Feature
+{
+    public {{ featureName | pascal }}Summary Find(string id) => string.IsNullOrWhiteSpace(id)
+        ? throw new AppException("invalid_id", "An id is required.")
+        : new {{ featureName | pascal }}Summary(id, $"{{ featureName | title }} {id}");
+}

package/templates/architectures/monolith/files/src/__solutionName.dot__.Api/Features/__featureName.pascal__/__featureName.pascal__Feature.cs

@@ -0,0 +1,13 @@
+namespace {{ solutionName | dot }}.Api.Features.{{ featureName | pascal }};
+
+/// <summary>The read model handed across the boundary. Never a persistence row.</summary>
+public sealed record {{ featureName | pascal }}Summary(string Id, string Name);
+
+/// <summary>
+/// The front door. Everything under this feature's Internal namespace is private to it, and
+/// tests/ArchitectureTests fails the build when anything outside the feature depends on it.
+/// </summary>
+public interface I{{ featureName | pascal }}Feature
+{
+    {{ featureName | pascal }}Summary Find(string id);
+}

package/templates/architectures/monolith/files/src/__solutionName.dot__.Api/Features/__featureName.pascal__/__featureName.pascal__Registration.cs

@@ -0,0 +1,13 @@
+using {{ solutionName | dot }}.Api.Features.{{ featureName | pascal }}.Internal;
+
+namespace {{ solutionName | dot }}.Api.Features.{{ featureName | pascal }};
+
+/// <summary>
+/// The feature wires itself. Call Add{{ featureName | pascal }}Feature() from Program.cs; the
+/// composition root learns nothing about what sits behind the interface.
+/// </summary>
+public static class {{ featureName | pascal }}Registration
+{
+    public static IServiceCollection Add{{ featureName | pascal }}Feature(this IServiceCollection services) =>
+        services.AddSingleton<I{{ featureName | pascal }}Feature, {{ featureName | pascal }}Service>();
+}

package/templates/architectures/monolith/files/src/__solutionName.dot__.Api/Kernel/AppException.cs

@@ -0,0 +1,30 @@
+// Named Kernel, not Shared: CA1716 rejects a namespace that collides with a language keyword.
+namespace {{ solutionName | dot }}.Api.Kernel;
+
+/// <summary>
+/// The kernel's failure type: features fail with a stable code and the edge is the only place
+/// that turns a code into a status. The kernel admits a thing when a second feature needs it
+/// AND it names no feature — the second half is what keeps a feature extractable.
+/// </summary>
+public sealed class AppException : Exception
+{
+    public AppException()
+    {
+    }
+
+    public AppException(string message)
+        : base(message)
+    {
+    }
+
+    public AppException(string message, Exception innerException)
+        : base(message, innerException)
+    {
+    }
+
+    public AppException(string code, string message)
+        : base(message) => Code = code;
+
+    /// <summary>Transport-agnostic failure code.</summary>
+    public string Code { get; } = "unknown";
+}

package/templates/architectures/monolith/files/src/__solutionName.pascal__.Api/Features/__featureName.pascal__/Internal/__featureName.pascal__Service.cs

@@ -0,0 +1,12 @@
+using {{ solutionName | pascal }}.Api.Kernel;
+
+namespace {{ solutionName | pascal }}.Api.Features.{{ featureName | pascal }}.Internal;
+
+/// <summary>Private to this feature. Replace with the real implementation; add types beside it
+/// freely — nothing outside the feature may reference this namespace.</summary>
+internal sealed class {{ featureName | pascal }}Service : I{{ featureName | pascal }}Feature
+{
+    public {{ featureName | pascal }}Summary Find(string id) => string.IsNullOrWhiteSpace(id)
+        ? throw new AppException("invalid_id", "An id is required.")
+        : new {{ featureName | pascal }}Summary(id, $"{{ featureName | title }} {id}");
+}

package/templates/architectures/monolith/files/src/__solutionName.pascal__.Api/Features/__featureName.pascal__/__featureName.pascal__Feature.cs

@@ -0,0 +1,13 @@
+namespace {{ solutionName | pascal }}.Api.Features.{{ featureName | pascal }};
+
+/// <summary>The read model handed across the boundary. Never a persistence row.</summary>
+public sealed record {{ featureName | pascal }}Summary(string Id, string Name);
+
+/// <summary>
+/// The front door. Everything under this feature's Internal namespace is private to it, and
+/// tests/ArchitectureTests fails the build when anything outside the feature depends on it.
+/// </summary>
+public interface I{{ featureName | pascal }}Feature
+{
+    {{ featureName | pascal }}Summary Find(string id);
+}

package/templates/architectures/monolith/files/src/__solutionName.pascal__.Api/Features/__featureName.pascal__/__featureName.pascal__Registration.cs

@@ -0,0 +1,13 @@
+using {{ solutionName | pascal }}.Api.Features.{{ featureName | pascal }}.Internal;
+
+namespace {{ solutionName | pascal }}.Api.Features.{{ featureName | pascal }};
+
+/// <summary>
+/// The feature wires itself. Call Add{{ featureName | pascal }}Feature() from Program.cs; the
+/// composition root learns nothing about what sits behind the interface.
+/// </summary>
+public static class {{ featureName | pascal }}Registration
+{
+    public static IServiceCollection Add{{ featureName | pascal }}Feature(this IServiceCollection services) =>
+        services.AddSingleton<I{{ featureName | pascal }}Feature, {{ featureName | pascal }}Service>();
+}

package/templates/architectures/monolith/files/src/__solutionName.pascal__.Api/Kernel/AppException.cs

@@ -0,0 +1,30 @@
+// Named Kernel, not Shared: CA1716 rejects a namespace that collides with a language keyword.
+namespace {{ solutionName | pascal }}.Api.Kernel;
+
+/// <summary>
+/// The kernel's failure type: features fail with a stable code and the edge is the only place
+/// that turns a code into a status. The kernel admits a thing when a second feature needs it
+/// AND it names no feature — the second half is what keeps a feature extractable.
+/// </summary>
+public sealed class AppException : Exception
+{
+    public AppException()
+    {
+    }
+
+    public AppException(string message)
+        : base(message)
+    {
+    }
+
+    public AppException(string message, Exception innerException)
+        : base(message, innerException)
+    {
+    }
+
+    public AppException(string code, string message)
+        : base(message) => Code = code;
+
+    /// <summary>Transport-agnostic failure code.</summary>
+    public string Code { get; } = "unknown";
+}