feat: one generic image, with installed modules in installation-owned storage (ADR 0048)

The production image now contains zero feature modules and is the same for every
installation. Installed modules live in module storage that one Core resolver
selects from EKKLESIA_MODULES_DIR: the checkout's modules/ when unset, an
absolute path that must exist when set (/var/lib/ekklesia/modules in the image).
A relative, blank, missing, or unreadable configured directory fails closed with
a sanitized error that never contains the value.

- Host configuration reads EKKLESIA_MODULES_DIR. The API, migration plan, apply
  and validate, module validation, module enablement, and Doctor all resolve it
  the same way; the test-only API override still takes precedence.
- Doctor receives Core's migrations directory explicitly instead of deriving it
  from the modules directory's parent.
- The migration runner retains and reports the applied history of a module that
  is not installed, and plans and applies Core's and present modules' migrations
  around it. Core's history and every installed module's history stay strict: a
  missing or changed applied migration, or a downgrade, still fails. No down
  migrations, no data deletion.
- deploy/Dockerfile copies no module and installs nothing for the module
  template; .dockerignore excludes modules/ and the build refuses a context that
  contains it; the runtime has an empty root-owned /var/lib/ekklesia/modules and
  sets EKKLESIA_MODULES_DIR.
- deploy/compose.yaml bind-mounts EKKLESIA_MODULES_HOST_DIR read-only into api
  and migrate, with create_host_path disabled.
- scripts/check-image.sh proves the image holds no modules and that a populated
  modules/ directory leaves its runtime file system identical; CI runs it.
- The split deploy smoke now uses the same generic image: it boots with no
  modules, installs a self-contained test module packaged from the template
  (test-only), migrates and restarts, removes it (Core runs, planning reports the
  retained history, data survives), and restores it with its data.

Docs: deploy README (module storage, install/update/remove/restore, the runtime
modules target), .env.example, API configuration, module development guide,
testing, workflow, security, and the architecture overview.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

apps/api/tests/api-http.integration.ts

@@ -2590,6 +2590,7 @@ describe.sequential("live API — installed module permission end-to-end", () =>
     });
 
     const report = await diagnoseEkklesia({
+      coreMigrationsDirectory,
       moduleDiscovery: {
         moduleSdkVersion: "0.1.0",
         modulesDirectory,
@@ -2599,10 +2600,8 @@ describe.sequential("live API — installed module permission end-to-end", () =>
       runtimeVersion: process.versions.node,
     });
 
-    // Only the module-discovery and permission-composition checks are asserted here — this
-    // fixture's temporary directory has no `core/drizzle` sibling for migrations discovery to
-    // find, which is unrelated to what this scenario proves and would otherwise make the check
-    // fail for a reason that has nothing to do with permission composition.
+    // Only the module-discovery and permission-composition checks are asserted here; nothing else
+    // in the report bears on what this scenario proves.
     const moduleCheck = report.checks.find((entry) => entry.id === "modules.discovery");
     const permissionsCheck = report.checks.find((entry) => entry.id === "modules.permissions");
     expect(moduleCheck).toMatchObject({ status: "pass" });

apps/api/tests/host-configuration-parity.test.ts

@@ -151,6 +151,13 @@ describe("host configuration parity between startApi and Doctor", () => {
     );
   });
 
+  it("hands the API the same modules directory Doctor and the operator commands read", () => {
+    expect(readConfigFromEnvironment(environment()).modulesDirectory).toBeUndefined();
+    const env = environment({ EKKLESIA_MODULES_DIR: "/var/lib/ekklesia/modules" });
+    expect(readConfigFromEnvironment(env).modulesDirectory).toBe("/var/lib/ekklesia/modules");
+    expect(loadHostConfiguration(env).modulesDirectory).toBe("/var/lib/ekklesia/modules");
+  });
+
   it("reads only this listener's own address and port outside the shared loader", () => {
     const config = apiView(
       environment({ EKKLESIA_API_HOST: "0.0.0.0", EKKLESIA_API_PORT: "8080" }),

apps/api/tests/lifecycle.test.ts

@@ -1004,6 +1004,73 @@ describe("Ekklesia API module permission composition at startup", () => {
     expect(poolEnd).toHaveBeenCalledTimes(1);
   });
 
+  it("discovers installed modules from the configured modules directory (ADR 0048)", async () => {
+    const modulesDirectory = await createTemporaryModulesDirectory();
+    await createFixtureModule(modulesDirectory, "incompatible", {
+      compatibility: { moduleSdk: "^0.1.0", platform: ">=99.0.0" },
+    });
+
+    // The module that fails discovery lives only in the configured directory, so this rejection
+    // proves discovery read it rather than the repository's own `modules/`.
+    await expect(
+      startApi(validConfig(), { configuredModulesDirectory: modulesDirectory }),
+    ).rejects.toBeInstanceOf(ModuleDiscoveryError);
+    expect(poolConstructor).not.toHaveBeenCalled();
+  });
+
+  it("starts with zero modules from an empty configured modules directory", async () => {
+    const modulesDirectory = await createTemporaryModulesDirectory();
+    poolConstructor.mockImplementation(function fakePool() {
+      return { end: vi.fn().mockResolvedValue(undefined), on: vi.fn(), query: emptyQuery() };
+    });
+    betterAuthMock.mockReturnValue({ api: { getSession: vi.fn() }, handler: vi.fn() });
+    mockSuccessfulServe();
+
+    const running = await startApi(validConfig(), { configuredModulesDirectory: modulesDirectory });
+
+    expect(poolConstructor).toHaveBeenCalledTimes(1);
+    await running.shutdown();
+  });
+
+  it.each([
+    ["a relative path", "relative/private-mount-5b2a", "MODULES_DIRECTORY_INVALID"],
+    ["a missing directory", "/nonexistent/private-mount-5b2a", "MODULES_DIRECTORY_UNREADABLE"],
+  ])("fails closed on %s, before any pool exists, naming no path", async (_label, configured, code) => {
+    let captured: unknown;
+    try {
+      await startApi(validConfig(), { configuredModulesDirectory: configured });
+    } catch (error) {
+      captured = error;
+    }
+
+    expect(captured).toBeInstanceOf(ModuleDiscoveryError);
+    const issues = (captured as ModuleDiscoveryError).issues;
+    expect(issues.map((issue) => issue.code)).toEqual([code]);
+    expect(JSON.stringify(issues)).not.toContain("private-mount-5b2a");
+    expect((captured as Error).message).not.toContain("private-mount-5b2a");
+    expect(poolConstructor).not.toHaveBeenCalled();
+    expect(betterAuthMock).not.toHaveBeenCalled();
+    expect(serveMock).not.toHaveBeenCalled();
+  });
+
+  it("lets the test-only override take precedence over a configured directory", async () => {
+    const modulesDirectory = await createTemporaryModulesDirectory();
+    poolConstructor.mockImplementation(function fakePool() {
+      return { end: vi.fn().mockResolvedValue(undefined), on: vi.fn(), query: emptyQuery() };
+    });
+    betterAuthMock.mockReturnValue({ api: { getSession: vi.fn() }, handler: vi.fn() });
+    mockSuccessfulServe();
+
+    // The configured value is unusable; the override wins, so it is never even resolved.
+    const running = await startApi(validConfig(), {
+      configuredModulesDirectory: "relative/never-resolved",
+      modulesDirectoryOverride: modulesDirectory,
+    });
+
+    expect(poolConstructor).toHaveBeenCalledTimes(1);
+    await running.shutdown();
+  });
+
   it("does not perform module discovery merely by importing the platform-permissions module", async () => {
     const module = await import("../src/platform-permissions.js");