diff --git a/Documentation/chronicle/add-event-sourcing.md b/Documentation/chronicle/add-event-sourcing.md
index 1f4f5899..197497ff 100644
--- a/Documentation/chronicle/add-event-sourcing.md
+++ b/Documentation/chronicle/add-event-sourcing.md
@@ -57,7 +57,7 @@ cd ../my-arc-app
 Install it together with the Chronicle SDK and RxJS:
 
 ```bash
-npm install ../arc-packages/arc.chronicle.tgz @cratis/chronicle@~6.19.0 rxjs@^7.8.2
+npm install ../arc-packages/arc.chronicle.tgz @cratis/chronicle@~6.29.0 rxjs@^7.8.2
 ```
 
 | Package | What it gives you |
diff --git a/Documentation/chronicle/reactors/scoped-activation.md b/Documentation/chronicle/reactors/scoped-activation.md
index 2e1bccfe..b8c06ee6 100644
--- a/Documentation/chronicle/reactors/scoped-activation.md
+++ b/Documentation/chronicle/reactors/scoped-activation.md
@@ -21,7 +21,7 @@ builder.withChronicle({
 });
 ```
 
-Scoped activation requires `@cratis/chronicle` 6.17.0 or later, the lowest version `@cratis/arc.chronicle` accepts as a peer. To use a Chronicle client you create yourself, see [Use a caller-owned client](#use-a-caller-owned-client).
+Scoped activation requires `@cratis/chronicle` 6.29.0 or later, the lowest version `@cratis/arc.chronicle` accepts as a peer. To use a Chronicle client you create yourself, see [Use a caller-owned client](#use-a-caller-owned-client).
 
 With the option set, Chronicle-only artifacts that `discover(...)` found before `withChronicle` was called are registered with Chronicle too. Without it, registration is unchanged.
 
diff --git a/Documentation/chronicle/read-models/index.md b/Documentation/chronicle/read-models/index.md
index dc7f8333..38df0539 100644
--- a/Documentation/chronicle/read-models/index.md
+++ b/Documentation/chronicle/read-models/index.md
@@ -57,6 +57,10 @@ Arc's `@readModel()` exposes the queries. Chronicle infers the same class as its
 
 `observeAll` keys the list by each model's `id`. Pass a key selector when your model names its identity differently, or when `id` is a concept, as `allAuthors` does with `author.id.toString()`. Unsubscribe, or let Arc end the subscription, to stop watching. SDK 6.9.1 and later omit the empty subscription marker from `watch()`; Arc also filters empty keys for older SDKs in its peer range.
 
+## Where the read model is stored
+
+Chronicle stores the projected read model in a container, a MongoDB collection by default. When the application also uses `withMongoDB` and Arc creates the Chronicle client, a class listed in its `readModels` is stored in the collection Arc's MongoDB integration reads, so `Author` is stored in `Authors` under the default naming policy. Any other read model, and every read model without `withMongoDB`, is stored under its identifier. `ChronicleReadModels` asks the kernel for the read model, so your queries never spell the name. See [Choose where read models are stored](../registration-options.md#choose-where-read-models-are-stored) for overrides and for a client you create yourself.
+
 ## Consistency
 
 - **Active projections are eventually consistent by default.** A command can succeed before its read model has updated. A client that reads right after a command can see the old state. An observable query catches up on its own. For a passive on-demand read or a bounded observer wait after a command, see [Read consistency](../../queries/read-consistency.md).
diff --git a/Documentation/chronicle/registration-options.md b/Documentation/chronicle/registration-options.md
index 28de0917..95113952 100644
--- a/Documentation/chronicle/registration-options.md
+++ b/Documentation/chronicle/registration-options.md
@@ -27,6 +27,7 @@ Each recorded reactor and reducer also gets a scoped service registration in Arc
 | `connectionString` | `string` | One of `connectionString` and `client` | Arc creates, connects, and disposes the SDK client |
 | `client` | `IChronicleClient` from `@cratis/chronicle` | One of `connectionString` and `client` | You own the client; see [Choose who owns the client](#choose-who-owns-the-client) |
 | `completionTimeoutMs` | positive integer, milliseconds | No; no wait by default | After each successful append, wait until Chronicle's observers have processed it before the command answers. See [Choose Chronicle read consistency](../queries/read-consistency.md) |
+| `readModelNamingPolicy` | `(identifier, readModelType?) => string` | No | Only with `connectionString`. Names the container each read model is stored in. Defaults to Arc's MongoDB collection name when `withMongoDB` is configured, otherwise to the read model identifier. See [Choose where read models are stored](#choose-where-read-models-are-stored) |
 | `activateArtifactsInScopes` | `boolean` | No; off by default | Preview. Resolve reactors and reducers from Arc's container, one scope per delivery. With `client`, registration verifies only that the client was created with `chronicleArtifactActivator`; passing `reactorCommandResultHandler` as `reactorResultHandler` is up to you. See [Scoped activation](reactors/scoped-activation.md) |
 
 Registration throws `Chronicle requires eventStore and exactly one of connectionString or client` when the event store is missing, or when neither or both of a connection string and a client are set.
@@ -52,7 +53,7 @@ Every append and read uses the current execution's tenant as the Chronicle names
 }
 ```
 
-With that file, call `builder.withChronicle({})`. Keys are case-insensitive. To override the file in a deployment, set `Cratis__Chronicle__ConnectionString` and `Cratis__Chronicle__EventStore`. Only these two keys are read from configuration; `client` and `completionTimeoutMs` are set in code.
+With that file, call `builder.withChronicle({})`. Keys are case-insensitive. To override the file in a deployment, set `Cratis__Chronicle__ConnectionString` and `Cratis__Chronicle__EventStore`. Only these two keys are read from configuration; `client`, `completionTimeoutMs`, and `readModelNamingPolicy` are set in code.
 
 Values follow this precedence:
 
@@ -69,6 +70,17 @@ Values follow this precedence:
 
 An Arc-owned client is also wired so that [reactors can return Arc commands](reactors/command-side-effects.md). A caller-owned client needs that handler passed to the SDK before it connects; the reactor page shows how. To use [scoped activation](reactors/scoped-activation.md#use-a-caller-owned-client) with a caller-owned client, also pass `chronicleArtifactActivator` as its `artifactActivator`. Dispose the Arc application before the client, so deliveries still running finish while the connection is open.
 
+## Choose where read models are stored
+
+A projected read model is stored in a container, which is a MongoDB collection by default. The Chronicle SDK names it after the read model identifier unless it is given a `readModelNamingPolicy`, a function of the identifier and, when the SDK knows it, the read model class. It changes only the container name.
+
+- **With `withMongoDB`.** An Arc-owned client gets a policy that returns the collection Arc's MongoDB integration reads for a class listed in `readModels`, so a projected read model lands where your queries look with no configuration. A class outside that list, and a read model known only by identifier, keep the identifier. This holds whichever of `withMongoDB` and `withChronicle` you call first. See [Naming policies](../mongodb/naming-policies.md#chronicle-projected-read-models) for the rule and for upgrading.
+- **With your own `readModelNamingPolicy`.** It replaces the automatic policy. Return the identifier when `readModelType` is undefined.
+- **Without `withMongoDB`.** Arc adds no policy, and the SDK default, the identifier, applies.
+- **With a caller-owned `client`.** Arc never changes the client, so it sets no policy, and `withChronicle` throws if you also pass `readModelNamingPolicy`. Set the policy in the `ChronicleOptions` you create the client with.
+
+The option needs `@cratis/chronicle` 6.29.0 or later.
+
 ## Related
 
 - [Add event sourcing](add-event-sourcing.md)
diff --git a/Documentation/client-snippets/scenarios/camel-casing/setup.md b/Documentation/client-snippets/scenarios/camel-casing/setup.md
index b5511dbe..a8a86397 100644
--- a/Documentation/client-snippets/scenarios/camel-casing/setup.md
+++ b/Documentation/client-snippets/scenarios/camel-casing/setup.md
@@ -1,6 +1,7 @@
 ```typescript
 import { field, Guid } from '@cratis/fundamentals';
 import { ArcApplication, key } from '@cratis/arc.core';
+import '@cratis/arc.chronicle';
 import { camelCaseMongoNamingPolicy } from '@cratis/arc.mongodb';
 
 // Users/User.ts
@@ -16,13 +17,11 @@ builder.withMongoDB({
     server: 'mongodb://localhost:27017',
     database: 'my-app',
     readModels: [User],
-    namingPolicy: camelCaseMongoNamingPolicy,
-    // Chronicle's TypeScript client stores a projected read model in a collection named after its
-    // identifier: the class name, unpluralized (User), unless @readModel gives it another id. Both
-    // built-in policies pluralize (users), so read the collection Chronicle writes. Return the
-    // @readModel id instead for a read model that sets one.
-    collectionName: type => type.name
+    namingPolicy: camelCaseMongoNamingPolicy
 });
+// The Chronicle client Arc creates stores a projected User in the collection this policy reads (users),
+// because withMongoDB is configured. No collectionName override is needed.
+builder.withChronicle({ connectionString: 'chronicle://localhost:35000', eventStore: 'my-app' });
 const app = await builder.build();
 await app.run();
 ```
diff --git a/Documentation/mongodb/naming-policies.md b/Documentation/mongodb/naming-policies.md
index 0f25356a..cb715365 100644
--- a/Documentation/mongodb/naming-policies.md
+++ b/Documentation/mongodb/naming-policies.md
@@ -52,6 +52,27 @@ builder.withMongoDB({ client, database: 'library', readModels: [Person],
 
 The function receives each registered model class and must return a nonempty name for all of them, or the request that resolves the collection fails with `MongoDB collection name is required`.
 
+## Chronicle-projected read models
+
+When Chronicle projects a read model into MongoDB, the collection name has to match the one Arc reads. If the Chronicle client is created by [`withChronicle`](../chronicle/registration-options.md) with a `connectionString` and the application also calls `withMongoDB`, Arc gives that client a naming policy that applies this page's rule to a read model class: `collectionName?.(model) ?? namingPolicy.collectionName(model)`. A projected `User` lands in `Users` under the default policy and in `users` under `camelCaseMongoNamingPolicy`, with no extra setup. The same collection name is used whether `withMongoDB` is called before or after `withChronicle`.
+
+The rule covers only the classes listed in `readModels`, because those are the only classes Arc reads from MongoDB: `mongoCollection(...)` and command read-model resolution both work from that list. A read model class that is not in `readModels`, such as a Chronicle-only read model served through `ChronicleReadModels`, keeps Chronicle's default collection name, its identifier. So does a read model Chronicle knows only by identifier, such as a projection with a custom `.containerName(...)`. The policy changes only the collection name. The database must still match: Chronicle writes the default namespace's read models to a database named after the event store, and to `<event store>+<namespace>` for any other namespace. `withMongoDB` uses `<database>` and `<database>+<tenantId>`, so set `database` to the event store name.
+
+Two cases are not wired automatically:
+
+- **You pass your own Chronicle `client`.** Arc never changes a client it does not own. Create it with `ChronicleOptions.fromConnectionString(connectionString, { readModelNamingPolicy })` and return the name you want, for example `(identifier, readModelType) => readModelType ? resolveMongoCollectionName(mongoOptions, readModelType) : identifier`. `resolveMongoCollectionName`, exported from `@cratis/arc.mongodb`, is the function Arc itself uses, and `mongoOptions` is an object with the same `namingPolicy` and `collectionName` you pass to `withMongoDB`. Passing `readModelNamingPolicy` to `withChronicle` together with a `client` throws.
+- **You pass `readModelNamingPolicy` to `withChronicle`.** Your policy replaces the automatic one.
+
+Without `withMongoDB`, Arc sets no policy and Chronicle names the collection after the read model identifier. The automatic policy needs `@cratis/chronicle` 6.29.0 or later, which is the lowest version `@cratis/arc.chronicle` accepts.
+
+:::caution[Upgrading]
+Before this behavior, a projected read model was stored in a collection named after its identifier, such as `User`, which the default `withMongoDB` policy never read. A workaround was `collectionName: model => model.name`. That workaround still gives `User`, so an application that uses it keeps its collection. An application on the default policy now has Chronicle register `Users` instead.
+
+Replay the projection after upgrading so the new collection is populated from the event log. The previous collection is left as it is, so drop it yourself when you no longer need it. This is guidance from reading the Chronicle kernel's registration code (`ReadModelsManager.Register` and the projection definition comparer on `main` of Cratis/Chronicle, release 19.22.1): a registered read model definition, including its container name, replaces the stored one, the kernel writes and reads through the new name, and it moves no data. Confirm it against your own kernel version before relying on it.
+
+A `collectionName` override that throws, or returns an empty name, for a class in `readModels` now fails when the Arc-created Chronicle client registers its read models, not only when a request resolves the collection.
+:::
+
 ## Write a custom policy
 
 A `MongoNamingPolicy` is two functions:
diff --git a/Documentation/reference/capabilities.md b/Documentation/reference/capabilities.md
index b4907a3c..53edfab7 100644
--- a/Documentation/reference/capabilities.md
+++ b/Documentation/reference/capabilities.md
@@ -126,7 +126,7 @@ Evidence paths are relative to the repository root. Spec folders follow `for_<Su
 
 - **MongoDB.** Also [joined observation](../mongodb/joined-observe.md), a [scoped watcher](../mongodb/change-stream-watcher.md), [GeoJSON geometry](../mongodb/geospatial.md), bounded transient read retries, MongoDB driver metrics for Arc-owned clients, and `Cratis:MongoDB:{Server,Database}` configuration binding. No durable watcher checkpoint; nonresumable stream failures terminate subscriptions. .NET's process-wide watcher, general-purpose resilience interceptors, and comprehensive metrics for supplied clients are not implemented.
 - **SQL with Drizzle.** `bash Source/Drizzle/run-integration.sh` exercises live PostgreSQL and MySQL for existing SQL reads and command lookup, not observation. In-process observation is checked using SQLite (`sql.js`), gated race and burst specs, and SSE/GET through Express, Fastify, and Hono. Command read models load by a single column-level `.primaryKey()` with `@field` in the tenant scope; models without `@field` on their column-level key still serve queries but cannot be injected into commands. Tables without a column-level primary key are rejected at registration. Custom columns bind typed keys, plain columns primitives. Command read models are tested against SQLite, live MySQL 8.4, and live PostgreSQL 16 with node-postgres. PostgreSQL coverage includes typed GUID and concept keys, tenant isolation, and missing required and optional rows.
-- **Chronicle.** It also resolves Chronicle read models by command key and in validators, batches nested returned events, and executes Arc commands returned from reactors through the SDK reactor result hook. SDK 6.19.0 loads in native Node ESM. Keyed aggregates and returned reactor commands are experimental.
+- **Chronicle.** It also resolves Chronicle read models by command key and in validators, batches nested returned events, and executes Arc commands returned from reactors through the SDK reactor result hook. SDK 6.29.0 loads in native Node ESM. Keyed aggregates and returned reactor commands are experimental.
 - **Chronicle compliance.** Mark projected read-model properties `@pii()` to encrypt them at rest; event-only marking does not protect the materialized field. Chronicle kernel reads already release values (including command injection), and Arc skips releasing those instances twice. For protected Chronicle models decoded into the exact read-model class by `MongoCollection`, Arc releases at the query edge, including snapshots, pages, and observable emissions. Raw `MongoReadModels` documents typed with `readModel` are released with the request's tenant and each document's subject: `subjectFor(document)` when given, otherwise the stored `__subject`, otherwise a string or numeric `_id`. It must match any stored `__subject` and the model's `@subject()` or `id`. Kernel bookkeeping fields are stripped. The path fails closed on undeclared fields, non-JSON BSON values (including `Guid` fields stored as `Binary`), per-property `__subjects`, a subject or tenant mismatch, typed documents nested in another shape, and MongoDB projections. Unreleased instances of a protected class nested in another returned shape, such as a joined `select` result, fail the query. Specs check snapshots, pages, and observable SSE through Express, Fastify, and Hono against a Chronicle substitute; the kernel integration reads a real materialized document through `MongoReadModels`. Untyped raw documents, typed documents of models not registered with Chronicle, codec-selected derived subtypes, `MongoDBWatcher.changes()` payloads, documents hidden behind `toJSON()`, getters, or private fields, and DTOs, mapped objects, or copies are served as stored and need explicit `readModels.release` on the tenant store. Nested, array-item, class-level PII and `@encrypted()` security metadata are detected. A directly read protected model needs `@subject()` or `id` matching the event subject to release; one without either is served only when it holds no protected value, and fails otherwise. The kernel integration checks raw MongoDB ciphertext, Chronicle delivery, and Arc query-edge release for a direct MongoDB read.
 
 ## Testing
@@ -184,7 +184,7 @@ The integration pages describe behavior. This section records the checks behind
 
 ### Chronicle checks
 
-The specs run with the published Chronicle TypeScript SDK, `@cratis/chronicle` 6.19.0, and `@cratis/fundamentals` 7.19.6; both load in native Node ESM with NodeNext resolution. The live suite was last verified with SDK 6.10.0; a 6.14.0 attempt could not start the local kernel because its MongoDB connection was refused. The ordinary `yarn test` specs use typed substitutes or the SDK's in-memory `ReadModelScenario` and never start a kernel. An opt-in suite, `bash Source/Chronicle/run-integration.sh`, runs [`Source/Chronicle/Integration/live.test.mjs`](https://github.com/Cratis/Arc.TypeScript/blob/main/Source/Chronicle/Integration/live.test.mjs) against a real development kernel and checks:
+The specs run with the published Chronicle TypeScript SDK, `@cratis/chronicle` 6.29.0, and `@cratis/fundamentals` 7.19.6; both load in native Node ESM with NodeNext resolution. The live suite was last verified with SDK 6.10.0; a 6.14.0 attempt could not start the local kernel because its MongoDB connection was refused. The ordinary `yarn test` specs use typed substitutes or the SDK's in-memory `ReadModelScenario` and never start a kernel. An opt-in suite, `bash Source/Chronicle/run-integration.sh`, runs [`Source/Chronicle/Integration/live.test.mjs`](https://github.com/Cratis/Arc.TypeScript/blob/main/Source/Chronicle/Integration/live.test.mjs) against a real development kernel and checks:
 
 - returned-event batches, readback, and tenant isolation;
 - a reactor that returns an Arc command, executed in the triggering event's tenant;
diff --git a/Documentation/reference/packages.md b/Documentation/reference/packages.md
index c93b1fbf..360382d0 100644
--- a/Documentation/reference/packages.md
+++ b/Documentation/reference/packages.md
@@ -21,7 +21,7 @@ Every package in this repository is at version 0.52.0, the version of the source
 | `@cratis/arc.testing` | `Source/Testing` | `CommandScenario`, `QueryScenario`, `ObservableQueryScenario`, `ArcScenario`, `given`, `shouldHaveRuleFailure` | |
 | `@cratis/arc.mongodb` | `Source/MongoDB` | `withMongoDB`, `mongoCollection`, `MongoCollection`, naming policies, `MongoReadModels` | `@cratis/arc.core`, `@cratis/fundamentals`, `mongodb` `^6.21.0` |
 | `@cratis/arc.drizzle` | `Source/Drizzle` | `withDrizzle`, `drizzleReadModel`, `drizzleDatabase`, `DrizzleReadModels`, column codecs | `@cratis/arc.core`, `@cratis/fundamentals`, `drizzle-orm` `^0.45.0` |
-| `@cratis/arc.chronicle` | `Source/Chronicle` | Experimental: `withChronicle`, `commandAggregate`, `reactorCommandResultHandler`, `executeCommandsAsSystem`, `eventForEventSourceId`, `eventSourceIdResponse`, `eventsWithConcurrencyScopes`, routing decorators, `notAudited`, `ChronicleReadModels`; `@cratis/arc.chronicle/testing` for `ChronicleCommandScenario` and `ChronicleKernelScenario` | `@cratis/arc.core`, `@cratis/arc.testing`, `@cratis/chronicle` `^6.17.0` (tested with 6.19.0), `@cratis/fundamentals`, `zod` |
+| `@cratis/arc.chronicle` | `Source/Chronicle` | Experimental: `withChronicle`, `commandAggregate`, `reactorCommandResultHandler`, `executeCommandsAsSystem`, `eventForEventSourceId`, `eventSourceIdResponse`, `eventsWithConcurrencyScopes`, routing decorators, `notAudited`, `ChronicleReadModels`; `@cratis/arc.chronicle/testing` for `ChronicleCommandScenario` and `ChronicleKernelScenario` | `@cratis/arc.core`, `@cratis/arc.testing`, `@cratis/chronicle` `^6.29.0` (tested with 6.29.0), `@cratis/fundamentals`, `zod` |
 | `@cratis/cratis` | `Source/Cratis` | Experimental composition, the counterpart of the C# `Cratis` package: `CratisApplication.createBuilder`, `builder.addCratis`; re-exports Arc, Chronicle and testing (`./testing`); no implicit authentication handler | Arc core, Arc Chronicle, Arc testing, Chronicle SDK, Fundamentals, `zod` |
 
 `@cratis/cratis` is experimental, like the Chronicle integration it composes, and is not published to npm yet. Unlike C# `AddCratis`, the TS composition does not install Microsoft identity automatically: for protected routes, explicitly choose an authentication handler (such as `microsoftIdentityPlatform()`) or your own trusted host principal; public routes need neither. It composes the client, not the event-store engine. See [The Cratis package](../chronicle/cratis-package.md).
diff --git a/Documentation/testing/chronicle.md b/Documentation/testing/chronicle.md
index b53b4f80..7b908f05 100644
--- a/Documentation/testing/chronicle.md
+++ b/Documentation/testing/chronicle.md
@@ -110,7 +110,7 @@ await scenario.dispose();
 
 Here `AccountBalanceReducer` handles `AccountOpened` and produces the `AccountBalance` injected into `CheckAccount`.
 The SDK's `ReadModelScenario` folds reducer history (since 6.14.0) and, starting in 6.19.0, evaluates supported flat projections from seeded events on demand for each source.
-The main `@cratis/arc.chronicle` entry supports `@cratis/chronicle` 6.17.0 and later. The scenario loads the SDK's testing subpath only when it needs to fold seeded history. A different source has no balance;
+The main `@cratis/arc.chronicle` entry supports `@cratis/chronicle` 6.29.0 and later. The scenario loads the SDK's testing subpath only when it needs to fold seeded history. A different source has no balance;
 required `commandReadModel(AccountBalance)` rejects it and an optional read model receives `null`. Seeding does not
 appear in `result.appendedEvents` or `scenario.appendedEvents`. Later command appends are **not** folded into this
 scenario's read models, matching the .NET command scenario's seeded-history lookup. Use a kernel scenario to test
diff --git a/Samples/Library/package.json b/Samples/Library/package.json
index 8a8f73ee..09813fdd 100644
--- a/Samples/Library/package.json
+++ b/Samples/Library/package.json
@@ -15,7 +15,7 @@
     "@cratis/arc.core": "workspace:^",
     "@cratis/arc.express": "workspace:^",
     "@cratis/arc.testing": "workspace:^",
-    "@cratis/chronicle": "6.19.0",
+    "@cratis/chronicle": "6.29.0",
     "@cratis/fundamentals": "7.19.6",
     "express": "^5.1.0",
     "rxjs": "^7.8.2"
diff --git a/Source/Chronicle/ChronicleOptions.ts b/Source/Chronicle/ChronicleOptions.ts
index b3b1f659..ce612219 100644
--- a/Source/Chronicle/ChronicleOptions.ts
+++ b/Source/Chronicle/ChronicleOptions.ts
@@ -1,6 +1,6 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
-import type { IChronicleClient } from '@cratis/chronicle';
+import type { IChronicleClient, ReadModelNamingPolicy } from '@cratis/chronicle';
 
 /** Choose either a caller-owned SDK client or an Arc-owned connection. */
 export type ChronicleRegistration = {
@@ -9,6 +9,8 @@ export type ChronicleRegistration = {
     readonly completionTimeoutMs?: number;
     readonly client: IChronicleClient;
     readonly connectionString?: never;
+    /** Not accepted with a caller-owned client: set `readModelNamingPolicy` in the `ChronicleOptions` you create it with. */
+    readonly readModelNamingPolicy?: never;
     /**
      * Preview: construct reactors and reducers in an Arc service scope per delivery. The client must have been created with
      * `artifactActivator: chronicleArtifactActivator(...)` for this event store; registration verifies only that. Passing
@@ -25,6 +27,13 @@ export type ChronicleRegistration = {
      * and correlation.
      */
     readonly activateArtifactsInScopes?: boolean;
+    /**
+     * Names the container each read model is stored in, given its identifier and, when known, its class. By default,
+     * when the application uses `withMongoDB`, a read model class is stored in the collection Arc's MongoDB integration
+     * reads it from, and one known only by identifier keeps that identifier as its name. Without `withMongoDB`
+     * the SDK default applies: the identifier. Setting this replaces that default.
+     */
+    readonly readModelNamingPolicy?: ReadModelNamingPolicy;
     readonly connectionString: string;
     readonly client?: never;
 };
diff --git a/Source/Chronicle/ChronicleRuntime.ts b/Source/Chronicle/ChronicleRuntime.ts
index 44819f57..67dfc956 100644
--- a/Source/Chronicle/ChronicleRuntime.ts
+++ b/Source/Chronicle/ChronicleRuntime.ts
@@ -1,8 +1,8 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 import { ChronicleClient, ChronicleOptions, EventStoreNamespaceName } from '@cratis/chronicle';
-import type { IEventStore } from '@cratis/chronicle';
-import type { ArcServer, ExecutionContext } from '@cratis/arc.core';
+import type { IEventStore, ReadModelNamingPolicy } from '@cratis/chronicle';
+import type { ArcServer, ExecutionContext, ReadModelCollectionName } from '@cratis/arc.core';
 import type { ClientArtifactsActivator } from '@cratis/chronicle/artifacts';
 import { reactorCommandResultHandler } from './reactorCommands.js';
 import type { ChronicleRegistration } from './ChronicleOptions.js';
@@ -14,12 +14,18 @@ export class ChronicleRuntime {
     readonly #owned;
     #disposed = false;
     constructor(readonly options: ChronicleRegistration, readonly artifacts: ChronicleArtifacts, server: () => ArcServer,
-        artifactActivator?: ClientArtifactsActivator) {
+        artifactActivator?: ClientArtifactsActivator, collectionName?: ReadModelCollectionName) {
         if (!options.eventStore) throw new Error('A Chronicle event store is required');
+        // An explicit policy wins. Otherwise store a read model class where the application's storage integration reads
+        // it, and keep the identifier when the client knows no class or the integration does not read it, as the SDK
+        // does without a policy.
+        const readModelNamingPolicy: ReadModelNamingPolicy | undefined = options.readModelNamingPolicy ??
+            (collectionName ? (identifier, readModelType) => readModelType ? collectionName(readModelType) ?? identifier : identifier : undefined);
         this.#owned = !options.client;
         this.#client = options.client ?? new ChronicleClient(ChronicleOptions.fromConnectionString(options.connectionString!, {
             clientArtifactsProvider: artifacts, discoveryPatterns: [], reactorResultHandler: reactorCommandResultHandler(server, options.eventStore),
-            ...artifactActivator ? { artifactActivator } : {}
+            ...artifactActivator ? { artifactActivator } : {},
+            ...readModelNamingPolicy ? { readModelNamingPolicy } : {}
         }));
     }
     /** Resolves the selected event store in the namespace authorized by Arc. */
diff --git a/Source/Chronicle/for_withChronicle/given/a_read_model_class.ts b/Source/Chronicle/for_withChronicle/given/a_read_model_class.ts
new file mode 100644
index 00000000..e1339e8e
--- /dev/null
+++ b/Source/Chronicle/for_withChronicle/given/a_read_model_class.ts
@@ -0,0 +1,8 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/** A read model class the naming specs hand to a policy. */
+export class Author {}
+
+/** A read model class the collection rule does not read. */
+export class Reviewer {}
diff --git a/Source/Chronicle/for_withChronicle/when_code_supplies_a_client_and_a_collection_name_rule.ts b/Source/Chronicle/for_withChronicle/when_code_supplies_a_client_and_a_collection_name_rule.ts
new file mode 100644
index 00000000..c2e65a9c
--- /dev/null
+++ b/Source/Chronicle/for_withChronicle/when_code_supplies_a_client_and_a_collection_name_rule.ts
@@ -0,0 +1,21 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { ChronicleOptions } from '@cratis/chronicle';
+import sinon from 'sinon';
+import { given } from '../given.js';
+import { ChronicleRuntime } from '../ChronicleRuntime.js';
+import { a_chronicle_builder } from './when_registering_artifact_fallbacks/given/a_chronicle_builder.js';
+
+describe('when code supplies a Chronicle client and a collection name rule is registered', given(a_chronicle_builder, context => {
+    let fromConnectionString: sinon.SinonSpy;
+    beforeEach(async () => {
+        fromConnectionString = sinon.spy(ChronicleOptions, 'fromConnectionString');
+        context.start();
+        context.withChronicle();
+        context.withCollectionNameRule(type => type.name);
+        await context.build();
+        await context.inScope(scope => scope.resolve(ChronicleRuntime));
+    });
+    afterEach(async () => { fromConnectionString.restore(); await context.dispose(); });
+    it('should not create or configure a client', () => { fromConnectionString.called.should.equal(false); });
+}));
diff --git a/Source/Chronicle/for_withChronicle/when_code_supplies_a_client_and_a_naming_policy.ts b/Source/Chronicle/for_withChronicle/when_code_supplies_a_client_and_a_naming_policy.ts
new file mode 100644
index 00000000..50fba5e3
--- /dev/null
+++ b/Source/Chronicle/for_withChronicle/when_code_supplies_a_client_and_a_naming_policy.ts
@@ -0,0 +1,22 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { should } from 'vitest';
+import { ArcApplicationBuilder } from '@cratis/arc.core';
+import type { ChronicleRegistration } from '../ChronicleOptions.js';
+import { withChronicle } from '../withChronicle.js';
+
+should();
+describe('when code supplies a Chronicle client and a read model naming policy', () => {
+    let failure: Error | undefined;
+    beforeEach(() => {
+        try {
+            withChronicle(new ArcApplicationBuilder(), {
+                client: {} as ChronicleRegistration['client'], eventStore: 'Tasks',
+                readModelNamingPolicy: (identifier: string) => identifier
+            } as unknown as Partial<ChronicleRegistration>);
+        } catch (error) { failure = error as Error; }
+    });
+    it('should reject it because Arc does not change a caller-owned client', () => {
+        failure!.message.should.contain('applies only to an Arc-owned client');
+    });
+});
diff --git a/Source/Chronicle/for_withChronicle/when_composing_with_mongodb.ts b/Source/Chronicle/for_withChronicle/when_composing_with_mongodb.ts
new file mode 100644
index 00000000..edfb22f2
--- /dev/null
+++ b/Source/Chronicle/for_withChronicle/when_composing_with_mongodb.ts
@@ -0,0 +1,47 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { ArcApplication, Severity } from '@cratis/arc.core';
+import type { ArcApplicationBuilder } from '@cratis/arc.core';
+import { camelCaseMongoNamingPolicy, resolveMongoCollectionName } from '@cratis/arc.mongodb';
+import type { MongoDBOptions } from '@cratis/arc.mongodb';
+import { ChronicleOptions } from '@cratis/chronicle';
+import type { ReadModelNamingPolicy } from '@cratis/chronicle';
+import sinon from 'sinon';
+import '../index.js';
+import { ChronicleRuntime } from '../ChronicleRuntime.js';
+import { Author, Reviewer } from './given/a_read_model_class.js';
+
+const mongoDB: MongoDBOptions = {
+    client: {} as MongoDBOptions['client'], database: 'Library', readModels: [Author],
+    namingPolicy: camelCaseMongoNamingPolicy, collectionName: type => `${type.name}Documents`
+};
+const chronicle = { connectionString: 'chronicle://localhost:35000', eventStore: 'Library' };
+const orders: [string, (builder: ArcApplicationBuilder) => void][] = [
+    ['withMongoDB before withChronicle', builder => { builder.withMongoDB(mongoDB); builder.withChronicle(chronicle); }],
+    ['withChronicle before withMongoDB', builder => { builder.withChronicle(chronicle); builder.withMongoDB(mongoDB); }]
+];
+
+for (const [order, register] of orders) {
+    describe(`when the real withMongoDB and withChronicle are registered (${order})`, () => {
+        let fromConnectionString: sinon.SinonSpy;
+        let policy: ReadModelNamingPolicy;
+        beforeEach(async () => {
+            fromConnectionString = sinon.spy(ChronicleOptions, 'fromConnectionString');
+            const builder = ArcApplication.createBuilder();
+            register(builder);
+            const application = await builder.build();
+            const scope = application.server.services.createScope({ tenantId: 'default', correlationId: crypto.randomUUID(),
+                principal: undefined, signal: new AbortController().signal, allowedSeverity: Severity.Warning });
+            try {
+                await scope.resolve(ChronicleRuntime);
+                policy = fromConnectionString.lastCall.args[1].readModelNamingPolicy;
+            } finally { await scope.dispose(); await application.dispose(); fromConnectionString.restore(); }
+        });
+        it('should name a registered class as the MongoDB integration resolves it', () => {
+            policy('Author', Author).should.equal(resolveMongoCollectionName(mongoDB, Author));
+        });
+        it('should use the collection name override for that class', () => { policy('Author', Author).should.equal('AuthorDocuments'); });
+        it('should keep the identifier when there is no class', () => { policy('custom-container').should.equal('custom-container'); });
+        it('should keep the identifier for a class MongoDB does not read', () => { policy('Reviewer', Reviewer).should.equal('Reviewer'); });
+    });
+}
diff --git a/Source/Chronicle/for_withChronicle/when_creating_the_arc_owned_client/with_a_collection_name_rule.ts b/Source/Chronicle/for_withChronicle/when_creating_the_arc_owned_client/with_a_collection_name_rule.ts
new file mode 100644
index 00000000..f68d5840
--- /dev/null
+++ b/Source/Chronicle/for_withChronicle/when_creating_the_arc_owned_client/with_a_collection_name_rule.ts
@@ -0,0 +1,27 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { ChronicleOptions } from '@cratis/chronicle';
+import type { ReadModelNamingPolicy } from '@cratis/chronicle';
+import sinon from 'sinon';
+import { given } from '../../given.js';
+import { ChronicleRuntime } from '../../ChronicleRuntime.js';
+import { a_chronicle_builder } from '../when_registering_artifact_fallbacks/given/a_chronicle_builder.js';
+import { Author, Reviewer } from '../given/a_read_model_class.js';
+
+describe('when creating the Arc-owned client with a collection name rule registered after Chronicle', given(a_chronicle_builder, context => {
+    let fromConnectionString: sinon.SinonSpy;
+    let policy: ReadModelNamingPolicy;
+    beforeEach(async () => {
+        fromConnectionString = sinon.spy(ChronicleOptions, 'fromConnectionString');
+        context.start();
+        context.withArcOwnedConnection(false);
+        context.withCollectionNameRule(type => type === Author ? `${type.name}s` : undefined);
+        await context.build();
+        await context.inScope(scope => scope.resolve(ChronicleRuntime));
+        policy = fromConnectionString.lastCall.args[1].readModelNamingPolicy;
+    });
+    afterEach(async () => { fromConnectionString.restore(); await context.dispose(); });
+    it('should name a read model class after the rule', () => { policy('Author', Author).should.equal('Authors'); });
+    it('should keep the identifier when the rule does not read the class', () => { policy('Reviewer', Reviewer).should.equal('Reviewer'); });
+    it('should keep the identifier when the client knows no class', () => { policy('custom-container').should.equal('custom-container'); });
+}));
diff --git a/Source/Chronicle/for_withChronicle/when_creating_the_arc_owned_client/with_an_explicit_naming_policy.ts b/Source/Chronicle/for_withChronicle/when_creating_the_arc_owned_client/with_an_explicit_naming_policy.ts
new file mode 100644
index 00000000..a0b376dd
--- /dev/null
+++ b/Source/Chronicle/for_withChronicle/when_creating_the_arc_owned_client/with_an_explicit_naming_policy.ts
@@ -0,0 +1,23 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { ChronicleOptions } from '@cratis/chronicle';
+import type { ReadModelNamingPolicy } from '@cratis/chronicle';
+import sinon from 'sinon';
+import { given } from '../../given.js';
+import { ChronicleRuntime } from '../../ChronicleRuntime.js';
+import { a_chronicle_builder } from '../when_registering_artifact_fallbacks/given/a_chronicle_builder.js';
+
+describe('when creating the Arc-owned client with an explicit naming policy and a collection name rule', given(a_chronicle_builder, context => {
+    let fromConnectionString: sinon.SinonSpy;
+    const explicit: ReadModelNamingPolicy = identifier => `explicit-${identifier}`;
+    beforeEach(async () => {
+        fromConnectionString = sinon.spy(ChronicleOptions, 'fromConnectionString');
+        context.start();
+        context.withArcOwnedConnection(false, explicit);
+        context.withCollectionNameRule(type => type.name);
+        await context.build();
+        await context.inScope(scope => scope.resolve(ChronicleRuntime));
+    });
+    afterEach(async () => { fromConnectionString.restore(); await context.dispose(); });
+    it('should pass the explicit policy to the client', () => { fromConnectionString.lastCall.args[1].readModelNamingPolicy.should.equal(explicit); });
+}));
diff --git a/Source/Chronicle/for_withChronicle/when_creating_the_arc_owned_client/without_a_collection_name_rule.ts b/Source/Chronicle/for_withChronicle/when_creating_the_arc_owned_client/without_a_collection_name_rule.ts
new file mode 100644
index 00000000..e705a8ba
--- /dev/null
+++ b/Source/Chronicle/for_withChronicle/when_creating_the_arc_owned_client/without_a_collection_name_rule.ts
@@ -0,0 +1,22 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { ChronicleOptions } from '@cratis/chronicle';
+import sinon from 'sinon';
+import { given } from '../../given.js';
+import { ChronicleRuntime } from '../../ChronicleRuntime.js';
+import { a_chronicle_builder } from '../when_registering_artifact_fallbacks/given/a_chronicle_builder.js';
+
+describe('when creating the Arc-owned client without a collection name rule or naming policy', given(a_chronicle_builder, context => {
+    let fromConnectionString: sinon.SinonSpy;
+    beforeEach(async () => {
+        fromConnectionString = sinon.spy(ChronicleOptions, 'fromConnectionString');
+        context.start();
+        context.withArcOwnedConnection(false);
+        await context.build();
+        await context.inScope(scope => scope.resolve(ChronicleRuntime));
+    });
+    afterEach(async () => { fromConnectionString.restore(); await context.dispose(); });
+    it('should not pass a naming policy so the SDK names containers by identifier', () => {
+        ('readModelNamingPolicy' in fromConnectionString.lastCall.args[1]).should.equal(false);
+    });
+}));
diff --git a/Source/Chronicle/for_withChronicle/when_registering_artifact_fallbacks/given/a_chronicle_builder.ts b/Source/Chronicle/for_withChronicle/when_registering_artifact_fallbacks/given/a_chronicle_builder.ts
index 9fe571bc..b04ddcdd 100644
--- a/Source/Chronicle/for_withChronicle/when_registering_artifact_fallbacks/given/a_chronicle_builder.ts
+++ b/Source/Chronicle/for_withChronicle/when_registering_artifact_fallbacks/given/a_chronicle_builder.ts
@@ -1,8 +1,8 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
-import { ArcApplicationBuilder, Severity } from '@cratis/arc.core';
-import type { ArcOptions, ServiceIdentifier, ServiceRegistration, ServiceScope } from '@cratis/arc.core';
-import type { IChronicleClient } from '@cratis/chronicle';
+import { ArcApplicationBuilder, readModelCollectionNameResolver, Severity } from '@cratis/arc.core';
+import type { ArcOptions, ReadModelCollectionName, ServiceIdentifier, ServiceRegistration, ServiceScope } from '@cratis/arc.core';
+import type { IChronicleClient, ReadModelNamingPolicy } from '@cratis/chronicle';
 import { withChronicle } from '../../../withChronicle.js';
 
 type BuiltApplication = Awaited<ReturnType<ArcApplicationBuilder['build']>>;
@@ -19,8 +19,14 @@ export class a_chronicle_builder {
     /** Opt in to scoped activation over an Arc-owned connection; building never connects. */
     withScopedActivation(): this { return this.withArcOwnedConnection(true); }
     /** Use an Arc-owned connection; building never connects. */
-    withArcOwnedConnection(activateArtifactsInScopes: boolean): this {
-        withChronicle(this.builder, { connectionString: 'chronicle://localhost:35000', eventStore: 'Fallbacks', activateArtifactsInScopes });
+    withArcOwnedConnection(activateArtifactsInScopes: boolean, readModelNamingPolicy?: ReadModelNamingPolicy): this {
+        withChronicle(this.builder, { connectionString: 'chronicle://localhost:35000', eventStore: 'Fallbacks', activateArtifactsInScopes,
+            ...readModelNamingPolicy ? { readModelNamingPolicy } : {} });
+        return this;
+    }
+    /** Register the collection rule a storage integration such as withMongoDB provides. */
+    withCollectionNameRule(rule: ReadModelCollectionName): this {
+        this.builder.services.addSingleton(readModelCollectionNameResolver, () => rule);
         return this;
     }
     async build(): Promise<BuiltApplication> { this.application = await this.builder.build(); return this.application; }
diff --git a/Source/Chronicle/package.json b/Source/Chronicle/package.json
index 283ddda9..4a1c1f26 100644
--- a/Source/Chronicle/package.json
+++ b/Source/Chronicle/package.json
@@ -36,7 +36,7 @@
   "peerDependencies": {
     "@cratis/arc.core": "^0.52.0",
     "@cratis/arc.testing": "^0.52.0",
-    "@cratis/chronicle": "^6.17.0",
+    "@cratis/chronicle": "^6.29.0",
     "@cratis/fundamentals": "^7.19.6",
     "rxjs": "^7.8.2",
     "zod": "^4.1.0"
@@ -48,9 +48,12 @@
   },
   "devDependencies": {
     "@cratis/arc.core": "workspace:^",
+    "@cratis/arc.mongodb": "workspace:^",
     "@cratis/arc.testing": "workspace:^",
-    "@cratis/chronicle": "6.19.0",
+    "@cratis/chronicle": "6.29.0",
     "@cratis/fundamentals": "7.19.6",
+    "@opentelemetry/api": "^1.9.0",
+    "mongodb": "^6.21.0",
     "rxjs": "^7.8.2",
     "zod": "^4.1.0"
   }
diff --git a/Source/Chronicle/withChronicle.ts b/Source/Chronicle/withChronicle.ts
index 4cb6a905..ffcc58a3 100644
--- a/Source/Chronicle/withChronicle.ts
+++ b/Source/Chronicle/withChronicle.ts
@@ -1,6 +1,6 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
-import { ArcApplicationBuilder, serviceToken } from '@cratis/arc.core';
+import { ArcApplicationBuilder, readModelCollectionNameResolver, serviceToken } from '@cratis/arc.core';
 import type { ArcServer, ReadModelInterceptor } from '@cratis/arc.core';
 import { ArcApplicationBuilder as FetchArcApplicationBuilder } from '@cratis/arc.core/fetch';
 import type { Constructor } from '@cratis/fundamentals';
@@ -25,6 +25,9 @@ export function withChronicle(builder: ArcApplicationBuilder, options: Partial<C
     const registration = { ...configured, ...options };
     if (!registration.eventStore || (!registration.connectionString && !registration.client) ||
         (registration.connectionString && registration.client)) throw new Error('Chronicle requires eventStore and exactly one of connectionString or client');
+    // Arc never changes a caller-owned client, so a policy passed here could not take effect.
+    if (registration.client && registration.readModelNamingPolicy)
+        throw new Error('Chronicle readModelNamingPolicy applies only to an Arc-owned client; set it in the ChronicleOptions the caller-owned client is created with');
     const artifacts = new ChronicleArtifacts();
     let server: ArcServer | undefined;
     builder.addBuiltObserver(built => { server = built; });
@@ -63,10 +66,17 @@ export function withChronicle(builder: ArcApplicationBuilder, options: Partial<C
         return matched;
     // Only scoped activation also claims Chronicle-only classes discovered before withChronicle; without it, behavior is unchanged.
     }, activator !== undefined);
-    builder.services.addSingleton(ChronicleRuntime, () => new ChronicleRuntime(registration as ChronicleRegistration, artifacts, () => {
-        if (!server) throw new Error('Arc must be built before Chronicle reactor commands can run');
-        return server;
-    }, registration.client ? undefined : activator));
+    builder.services.addSingleton(ChronicleRuntime, async scope => {
+        // withMongoDB may register the collection rule before or after this call; checking here, once Arc is built, sees both.
+        // optionalService only binds command and query parameters, and scope.resolve rejects it, so look the registration up.
+        const hasCollectionRule = builder.services.registrations.some(registered => registered.token === readModelCollectionNameResolver);
+        const collectionName = registration.client || registration.readModelNamingPolicy || !hasCollectionRule ? undefined :
+            await scope.resolve(readModelCollectionNameResolver);
+        return new ChronicleRuntime(registration as ChronicleRegistration, artifacts, () => {
+            if (!server) throw new Error('Arc must be built before Chronicle reactor commands can run');
+            return server;
+        }, registration.client ? undefined : activator, collectionName);
+    });
     builder.services.addScoped(ChronicleScopedStore, async scope => new ChronicleScopedStore(await scope.resolve(ChronicleRuntime), scope));
     builder.services.addScoped(ChronicleReadModels, async scope =>
         new ChronicleReadModels(await scope.resolve(ChronicleScopedStore), scope.identity!));
diff --git a/Source/Core/fetch.ts b/Source/Core/fetch.ts
index c3ca5e14..0384464d 100644
--- a/Source/Core/fetch.ts
+++ b/Source/Core/fetch.ts
@@ -10,6 +10,8 @@ export interface ArcBuilderExtensions {}
 export type { ArcBuilderIntegrationOptions } from './ArcBuilderIntegrationOptions.js';
 export { canonicalMetadataSignature } from './reflection/generatedMetadataSignature.js';
 export { optionalService } from './dependencyInjection/optionalService.js';
+export { readModelCollectionNameResolver } from './readModels/readModelCollectionNameResolver.js';
+export type { ReadModelCollectionName } from './readModels/ReadModelCollectionName.js';
 export type { GeneratedMetadata, GeneratedArtifactMetadata } from './reflection/GeneratedArtifactMetadata.js';
 /** Convert model-bound values to the same JSON-ready shape as Arc's HTTP pipeline. */
 export { encode as encodeWireValue } from './reflection/wireSchema.js';
diff --git a/Source/Core/for_exports/when_loading_the_public_barrels.ts b/Source/Core/for_exports/when_loading_the_public_barrels.ts
index 22270273..0102bfe9 100644
--- a/Source/Core/for_exports/when_loading_the_public_barrels.ts
+++ b/Source/Core/for_exports/when_loading_the_public_barrels.ts
@@ -15,6 +15,9 @@ describe('when loading the public Arc barrels', () => {
     it('should expose failure tracking to hosting integrations', () => {
         hosting.recordFailure.should.be.a('function');
     });
+    it('should share the read model collection rule token between the Node and Fetch roots', () => {
+        node.readModelCollectionNameResolver.should.equal(fetch.readModelCollectionNameResolver);
+    });
     it('should retain branded command outcomes on the root', () => {
         node.tuple.should.be.a('function');
         node.rejected.should.be.a('function');
diff --git a/Source/Core/index.ts b/Source/Core/index.ts
index a9ef4ccc..bf4a8d6c 100644
--- a/Source/Core/index.ts
+++ b/Source/Core/index.ts
@@ -9,6 +9,8 @@ export type { ArcBuilderOptions } from './configuration/ArcBuilderOptions.js';
 export { discoveryFiles } from './reflection/discoveryFiles.js';
 export { canonicalMetadataSignature } from './reflection/generatedMetadataSignature.js';
 export { optionalService } from './dependencyInjection/optionalService.js';
+export { readModelCollectionNameResolver } from './readModels/readModelCollectionNameResolver.js';
+export type { ReadModelCollectionName } from './readModels/ReadModelCollectionName.js';
 export type { GeneratedMetadata, GeneratedArtifactMetadata } from './reflection/GeneratedArtifactMetadata.js';
 /** Convert model-bound values to the same JSON-ready shape as Arc's HTTP pipeline. */
 export { encode as encodeWireValue } from './reflection/wireSchema.js';
diff --git a/Source/Core/readModels/ReadModelCollectionName.ts b/Source/Core/readModels/ReadModelCollectionName.ts
new file mode 100644
index 00000000..9f88b3de
--- /dev/null
+++ b/Source/Core/readModels/ReadModelCollectionName.ts
@@ -0,0 +1,8 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * Names the collection an Arc storage integration reads a read model class from, or returns undefined when the
+ * integration does not read that class, so another integration must not rename where it is stored.
+ */
+export type ReadModelCollectionName = (type: new () => object) => string | undefined;
diff --git a/Source/Core/readModels/readModelCollectionNameResolver.ts b/Source/Core/readModels/readModelCollectionNameResolver.ts
new file mode 100644
index 00000000..c195b871
--- /dev/null
+++ b/Source/Core/readModels/readModelCollectionNameResolver.ts
@@ -0,0 +1,10 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { serviceToken } from '../dependencyInjection/ServiceToken.js';
+import type { ReadModelCollectionName } from './ReadModelCollectionName.js';
+
+/**
+ * Registered by a storage integration such as `withMongoDB` so other integrations, such as Chronicle, can store a
+ * read model in the collection the application reads it from. Absent when no such integration is configured.
+ */
+export const readModelCollectionNameResolver = serviceToken<ReadModelCollectionName>('ReadModelCollectionNameResolver');
diff --git a/Source/Cratis/package.json b/Source/Cratis/package.json
index 9e2248ff..5dae7e83 100644
--- a/Source/Cratis/package.json
+++ b/Source/Cratis/package.json
@@ -31,13 +31,13 @@
     "@cratis/arc.testing": "workspace:^"
   },
   "peerDependencies": {
-    "@cratis/chronicle": "^6.17.0",
+    "@cratis/chronicle": "^6.29.0",
     "@cratis/fundamentals": "^7.19.6",
     "rxjs": "^7.8.2",
     "zod": "^4.1.0"
   },
   "devDependencies": {
-    "@cratis/chronicle": "6.19.0",
+    "@cratis/chronicle": "6.29.0",
     "@cratis/fundamentals": "7.19.6",
     "rxjs": "^7.8.2",
     "zod": "^4.1.0"
diff --git a/Source/MongoDB/for_resolveMongoCollectionName/when_resolving/with_a_collection_name_override.ts b/Source/MongoDB/for_resolveMongoCollectionName/when_resolving/with_a_collection_name_override.ts
new file mode 100644
index 00000000..5c48f10a
--- /dev/null
+++ b/Source/MongoDB/for_resolveMongoCollectionName/when_resolving/with_a_collection_name_override.ts
@@ -0,0 +1,12 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { describe, it, should } from 'vitest';
+import { TaskRecord } from '../../for_MongoCollection/given/TaskRecord.js';
+import { camelCaseMongoNamingPolicy } from '../../MongoNamingPolicy.js';
+import { resolveMongoCollectionName } from '../../resolveMongoCollectionName.js';
+
+should();
+describe('when resolving a collection name with an override and a naming policy', () => {
+    const name = resolveMongoCollectionName({ namingPolicy: camelCaseMongoNamingPolicy, collectionName: type => type.name }, TaskRecord);
+    it('should prefer the override', () => name.should.equal('TaskRecord'));
+});
diff --git a/Source/MongoDB/for_resolveMongoCollectionName/when_resolving/with_a_naming_policy.ts b/Source/MongoDB/for_resolveMongoCollectionName/when_resolving/with_a_naming_policy.ts
new file mode 100644
index 00000000..0aed7f96
--- /dev/null
+++ b/Source/MongoDB/for_resolveMongoCollectionName/when_resolving/with_a_naming_policy.ts
@@ -0,0 +1,12 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { describe, it, should } from 'vitest';
+import { TaskRecord } from '../../for_MongoCollection/given/TaskRecord.js';
+import { camelCaseMongoNamingPolicy } from '../../MongoNamingPolicy.js';
+import { resolveMongoCollectionName } from '../../resolveMongoCollectionName.js';
+
+should();
+describe('when resolving a collection name with a naming policy', () => {
+    const name = resolveMongoCollectionName({ namingPolicy: camelCaseMongoNamingPolicy }, TaskRecord);
+    it('should use the policy collection name', () => name.should.equal('taskRecords'));
+});
diff --git a/Source/MongoDB/for_resolveMongoCollectionName/when_resolving/with_an_empty_name.ts b/Source/MongoDB/for_resolveMongoCollectionName/when_resolving/with_an_empty_name.ts
new file mode 100644
index 00000000..3b67ba59
--- /dev/null
+++ b/Source/MongoDB/for_resolveMongoCollectionName/when_resolving/with_an_empty_name.ts
@@ -0,0 +1,13 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { describe, it, should } from 'vitest';
+import { TaskRecord } from '../../for_MongoCollection/given/TaskRecord.js';
+import { resolveMongoCollectionName } from '../../resolveMongoCollectionName.js';
+
+should();
+describe('when resolving a collection name and the override returns an empty name', () => {
+    let failure: Error | undefined;
+    try { resolveMongoCollectionName({ collectionName: () => '' }, TaskRecord); }
+    catch (error) { failure = error as Error; }
+    it('should fail instead of choosing a collection', () => failure!.message.should.equal('MongoDB collection name is required'));
+});
diff --git a/Source/MongoDB/for_resolveMongoCollectionName/when_resolving/with_the_default_policy.ts b/Source/MongoDB/for_resolveMongoCollectionName/when_resolving/with_the_default_policy.ts
new file mode 100644
index 00000000..7515fb2b
--- /dev/null
+++ b/Source/MongoDB/for_resolveMongoCollectionName/when_resolving/with_the_default_policy.ts
@@ -0,0 +1,11 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { describe, it, should } from 'vitest';
+import { TaskRecord } from '../../for_MongoCollection/given/TaskRecord.js';
+import { resolveMongoCollectionName } from '../../resolveMongoCollectionName.js';
+
+should();
+describe('when resolving a collection name without options', () => {
+    const name = resolveMongoCollectionName({}, TaskRecord);
+    it('should pluralize the class name as the default policy does', () => name.should.equal('TaskRecords'));
+});
diff --git a/Source/MongoDB/for_withMongoDB/when_registering_the_collection_name_rule.ts b/Source/MongoDB/for_withMongoDB/when_registering_the_collection_name_rule.ts
new file mode 100644
index 00000000..3630d1e0
--- /dev/null
+++ b/Source/MongoDB/for_withMongoDB/when_registering_the_collection_name_rule.ts
@@ -0,0 +1,39 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { beforeEach, describe, it, should } from 'vitest';
+import { ArcApplication, readModelCollectionNameResolver, Severity } from '@cratis/arc.core';
+import type { ReadModelCollectionName } from '@cratis/arc.core';
+import type { MongoClient } from 'mongodb';
+import { TaskRecord } from '../for_MongoCollection/given/TaskRecord.js';
+import { camelCaseMongoNamingPolicy } from '../MongoNamingPolicy.js';
+import { resolveMongoCollectionName } from '../resolveMongoCollectionName.js';
+import '../withMongoDB.js';
+
+class Unregistered {}
+
+should();
+describe('when registering MongoDB with a naming policy and a collection override', () => {
+    const overridden = (type: new () => object) => type === TaskRecord ? 'Tasks' : `${type.name}!`;
+    let rule: ReadModelCollectionName;
+    let ruleWithoutOverride: ReadModelCollectionName;
+    beforeEach(async () => {
+        const client = {} as MongoClient;
+        const resolve = async (options: { collectionName?: typeof overridden }) => {
+            const builder = ArcApplication.createBuilder();
+            builder.withMongoDB({ client, database: 'Items', readModels: [TaskRecord], namingPolicy: camelCaseMongoNamingPolicy, ...options });
+            const application = await builder.build();
+            const scope = application.server.services.createScope({ tenantId: 'default', correlationId: crypto.randomUUID(),
+                principal: undefined, signal: new AbortController().signal, allowedSeverity: Severity.Warning });
+            try { return await scope.resolve(readModelCollectionNameResolver); }
+            finally { await scope.dispose(); await application.dispose(); }
+        };
+        rule = await resolve({ collectionName: overridden });
+        ruleWithoutOverride = await resolve({});
+    });
+    it('should expose the override to other integrations', () => rule(TaskRecord)!.should.equal('Tasks'));
+    it('should expose the naming policy name when there is no override', () => ruleWithoutOverride(TaskRecord)!.should.equal('taskRecords'));
+    it('should leave a class that is not registered to the other integration', () =>
+        (ruleWithoutOverride(Unregistered) === undefined).should.equal(true));
+    it('should resolve the same name as Arc reads the collection from', () =>
+        ruleWithoutOverride(TaskRecord)!.should.equal(resolveMongoCollectionName({ namingPolicy: camelCaseMongoNamingPolicy }, TaskRecord)));
+});
diff --git a/Source/MongoDB/index.ts b/Source/MongoDB/index.ts
index a9d319c0..3371091c 100644
--- a/Source/MongoDB/index.ts
+++ b/Source/MongoDB/index.ts
@@ -7,6 +7,7 @@ export { encodeGeometry, decodeGeometry } from './MongoGeoJSON.js';
 export type { MongoGeometry } from './MongoGeoJSON.js';
 export { defaultMongoNamingPolicy, camelCaseMongoNamingPolicy } from './MongoNamingPolicy.js';
 export type { MongoNamingPolicy } from './MongoNamingPolicy.js';
+export { resolveMongoCollectionName } from './resolveMongoCollectionName.js';
 export { MongoClientFactory } from './MongoClientFactory.js';
 export { MongoCollection } from './MongoCollection.js';
 export { MongoObservable } from './MongoObservable.js';
diff --git a/Source/MongoDB/resolveMongoCollectionName.ts b/Source/MongoDB/resolveMongoCollectionName.ts
new file mode 100644
index 00000000..362d1dce
--- /dev/null
+++ b/Source/MongoDB/resolveMongoCollectionName.ts
@@ -0,0 +1,17 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import type { MongoDBOptions } from './MongoDBOptions.js';
+import { defaultMongoNamingPolicy } from './MongoNamingPolicy.js';
+
+/**
+ * Resolve the collection a read model class is stored in: the `collectionName` override when set, otherwise the
+ * naming policy's name. Arc reads the collection through this rule, and the Chronicle client Arc creates writes
+ * projected read models through the same one.
+ */
+export function resolveMongoCollectionName(options: Pick<MongoDBOptions, 'namingPolicy' | 'collectionName'>,
+    type: new () => object): string {
+    const namingPolicy = options.namingPolicy ?? defaultMongoNamingPolicy;
+    const collectionName = options.collectionName?.(type) ?? namingPolicy.collectionName(type);
+    if (!collectionName) throw new Error('MongoDB collection name is required');
+    return collectionName;
+}
diff --git a/Source/MongoDB/withMongoDB.ts b/Source/MongoDB/withMongoDB.ts
index 73977ba9..3fbacd4e 100644
--- a/Source/MongoDB/withMongoDB.ts
+++ b/Source/MongoDB/withMongoDB.ts
@@ -1,6 +1,6 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
-import { ArcApplicationBuilder, serviceToken } from '@cratis/arc.core';
+import { ArcApplicationBuilder, readModelCollectionNameResolver, serviceToken } from '@cratis/arc.core';
 import type { ExecutionContext, ServiceScope } from '@cratis/arc.core';
 import { ArcApplicationBuilder as FetchArcApplicationBuilder } from '@cratis/arc.core/fetch';
 import { MongoClientFactory } from './MongoClientFactory.js';
@@ -10,6 +10,7 @@ import { MongoReadModelForCommandResolver } from './MongoReadModelForCommandReso
 import type { MongoDBOptions } from './MongoDBOptions.js';
 import { mongoCollection } from './collectionToken.js';
 import { defaultMongoNamingPolicy } from './MongoNamingPolicy.js';
+import { resolveMongoCollectionName } from './resolveMongoCollectionName.js';
 
 /** Public token for applications needing to resolve clients explicitly. */
 export const mongoClientFactory = serviceToken<MongoClientFactory>('MongoClientFactory');
@@ -23,6 +24,10 @@ export function withMongoDB(builder: ArcApplicationBuilder, configured: MongoDBO
     if (!options.database && !options.databaseNameResolver) throw new Error('MongoDB requires database or databaseNameResolver');
     const factory = new MongoClientFactory(options);
     builder.services.addSingleton(mongoClientFactory, () => factory);
+    // Lets integrations that store read models elsewhere, such as Chronicle, use the collection Arc reads from.
+    // Arc reads only the classes registered in readModels, so any other class keeps the other integration's name.
+    builder.services.addSingleton(readModelCollectionNameResolver, () => (type: new () => object) =>
+        options.readModels.includes(type) ? resolveMongoCollectionName(options, type) : undefined);
     builder.services.addScoped(MongoReadModelForCommandResolver, () => new MongoReadModelForCommandResolver(options));
     builder.addReadModelForCommandResolver(MongoReadModelForCommandResolver);
     const resolveDatabase = async (scope: ServiceScope) => {
@@ -44,9 +49,7 @@ export function withMongoDB(builder: ArcApplicationBuilder, configured: MongoDBO
         builder.services.addScoped(token, async scope => {
             const { context, database } = await resolveDatabase(scope);
             const namingPolicy = options.namingPolicy ?? defaultMongoNamingPolicy;
-            const collectionName = options.collectionName?.(type) ?? namingPolicy.collectionName(type);
-            if (!collectionName) throw new Error('MongoDB collection name is required');
-            return new MongoCollection(database.collection(collectionName), database, type, context, {
+            return new MongoCollection(database.collection(resolveMongoCollectionName(options, type)), database, type, context, {
                 ignoreConventions: options.ignoreConventions, maxObservableItems: options.maxObservableItems,
                 maxPageSize: options.maxPageSize, namingPolicy
             });
diff --git a/scripts/chronicle-peer-floor-exports.json b/scripts/chronicle-peer-floor-exports.json
index 41c5d742..9c421bf2 100644
--- a/scripts/chronicle-peer-floor-exports.json
+++ b/scripts/chronicle-peer-floor-exports.json
@@ -1,5 +1,5 @@
 {
-  "version": "6.17.0",
+  "version": "6.29.0",
   "exports": {
     "@cratis/chronicle": [
       "AddBuilder",
@@ -343,9 +343,18 @@
       "reducer"
     ],
     "@cratis/chronicle/testing": [
+      "EventScenario",
+      "EventScenarioGiven",
+      "EventScenarioGivenBuilder",
+      "EventScenarioWhen",
+      "EventScenarioWhenBuilder",
+      "ReactorScenario",
       "ReadModelScenario",
       "ReadModelScenarioGiven",
-      "ReadModelScenarioGivenBuilder"
+      "ReadModelScenarioGivenBuilder",
+      "UnsupportedEventSequenceOperation",
+      "UnsupportedProjectionOperation",
+      "UnsupportedReactorOperation"
     ],
     "@cratis/chronicle/seeding": [
       "EventSeeding",
diff --git a/yarn.lock b/yarn.lock
index d860e747..7b091d2e 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -104,15 +104,18 @@ __metadata:
   resolution: "@cratis/arc.chronicle@workspace:Source/Chronicle"
   dependencies:
     "@cratis/arc.core": "workspace:^"
+    "@cratis/arc.mongodb": "workspace:^"
     "@cratis/arc.testing": "workspace:^"
-    "@cratis/chronicle": "npm:6.19.0"
+    "@cratis/chronicle": "npm:6.29.0"
     "@cratis/fundamentals": "npm:7.19.6"
+    "@opentelemetry/api": "npm:^1.9.0"
+    mongodb: "npm:^6.21.0"
     rxjs: "npm:^7.8.2"
     zod: "npm:^4.1.0"
   peerDependencies:
     "@cratis/arc.core": ^0.52.0
     "@cratis/arc.testing": ^0.52.0
-    "@cratis/chronicle": ^6.17.0
+    "@cratis/chronicle": ^6.29.0
     "@cratis/fundamentals": ^7.19.6
     rxjs: ^7.8.2
     zod: ^4.1.0
@@ -271,7 +274,7 @@ __metadata:
   languageName: unknown
   linkType: soft
 
-"@cratis/arc.mongodb@workspace:Source/MongoDB":
+"@cratis/arc.mongodb@workspace:Source/MongoDB, @cratis/arc.mongodb@workspace:^":
   version: 0.0.0-use.local
   resolution: "@cratis/arc.mongodb@workspace:Source/MongoDB"
   dependencies:
@@ -344,7 +347,7 @@ __metadata:
     "@cratis/arc.express": "workspace:^"
     "@cratis/arc.react": "npm:22.19.1"
     "@cratis/arc.testing": "workspace:^"
-    "@cratis/chronicle": "npm:6.19.0"
+    "@cratis/chronicle": "npm:6.29.0"
     "@cratis/components": "npm:4.6.0"
     "@cratis/fundamentals": "npm:7.19.6"
     "@testing-library/dom": "npm:^10.4.2"
@@ -393,9 +396,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@cratis/chronicle@npm:6.19.0":
-  version: 6.19.0
-  resolution: "@cratis/chronicle@npm:6.19.0"
+"@cratis/chronicle@npm:6.29.0":
+  version: 6.29.0
+  resolution: "@cratis/chronicle@npm:6.29.0"
   dependencies:
     "@bufbuild/protobuf": "npm:^2.15.0"
     "@cratis/chronicle.contracts": "npm:19.6.1"
@@ -408,7 +411,7 @@ __metadata:
     undici: "npm:^8.10.2"
   peerDependencies:
     "@cratis/fundamentals": ^7.19.2
-  checksum: 10c0/6de0b9b55eb4a32aa0f0386f559a599f75120d4e65c4d05839b858597b83c7a12642bc5a328230d76c03bd44848edaa12abd399739c60bab4c4ccd4ce1b97f15
+  checksum: 10c0/4dc269f68904be93f549826904f1bdfa7726d2b58bb1955c37686ddbb973dfff555e697c97b2acc80c2fee639033d919a76b86e166bb8a621eec20a268b50e81
   languageName: node
   linkType: hard
 
@@ -446,12 +449,12 @@ __metadata:
     "@cratis/arc.chronicle": "workspace:^"
     "@cratis/arc.core": "workspace:^"
     "@cratis/arc.testing": "workspace:^"
-    "@cratis/chronicle": "npm:6.19.0"
+    "@cratis/chronicle": "npm:6.29.0"
     "@cratis/fundamentals": "npm:7.19.6"
     rxjs: "npm:^7.8.2"
     zod: "npm:^4.1.0"
   peerDependencies:
-    "@cratis/chronicle": ^6.17.0
+    "@cratis/chronicle": ^6.29.0
     "@cratis/fundamentals": ^7.19.6
     rxjs: ^7.8.2
     zod: ^4.1.0