mirror-mind 0.40.1 → 0.41.0

package/docs/releases/index.md

@@ -12,6 +12,7 @@ Future release notes should use the structure defined in [Release Notes](../proc
 
 ## Releases
 
+- [v0.41.0 — A Persona When the Subject Asks for One](v0.41.0.md) — minor release of CR203 and CR204: a Mirror Mode turn's persona is routed by its subject, by a Decisions model through OpenRouter taken only above a threshold, else the Journey's `default_persona`, else none; a turn never inherits the session's persona, and a turn with none tells the model not to sign; every routing failure is none; one content-free `llm_calls` row per call; `mirror-mind/desktop` returns `personaName` beside the persona's id. No migration.
 - [v0.40.1 — The Bins You Named, or Why Not](v0.40.1.md) — patch release of CR197: the plugin's hook wrappers and MCP entry use `MIRROR_BIN` only as an absolute path to a directory holding the bin they need, the rule `MIRROR_NODE` follows since v0.39.5; a relative value is never used, so a project's own `bin/mirror-hook` cannot run, and a refused value is named with its reason, once a day in `hooks.log` and on the MCP entry's stderr; the forward-slash `C:/…` form Windows machines set counts as absolute, in CI under Git Bash. Also carries CV9's re-baseline (documents only). No migration.
 - [v0.40.0 — A Reply Stays in Its Own Conversation, and a Journey Can Go](v0.40.0.md) — minor release closing the first release train: CR151, a session's transcript fills only the conversation that session is bound to, each reply stamped with its transcript time, where it used to fill every open reply-less conversation in the transcript's window, another session's included; a transcript no session owns backfills nothing; and CR200, previewed as v0.40.0-next.1, `mirror-mind/desktop` deletes a Journey with every record that belongs to it, by digest, behind a verified backup. Update every install that has a home. No migration.
 - [v0.40.0-next.1 — A Journey Can Go, Showing What Goes With It](v0.40.0-next.1.md) — preview under npm's `next`, read by no updater, for Nautilus for Mirror (the release train): CR200, `mirror-mind/desktop` gains `previewJourneyDeletion` and `deleteJourneyWithRecords`, deleting a Journey with every record that belongs to it after a preview that counts it, by digest, behind a verified backup; child Journeys refuse. Terminal users receive it with v0.40.0. No migration.

package/docs/releases/v0.41.0.md

@@ -0,0 +1,116 @@
+---
+digest: >
+  v0.41.0 routes each Mirror Mode turn's persona by what the turn is about, and lets a turn
+  have none. A Decisions model chooses among your personas and says whether the subject
+  belongs to any of them; its choice is taken only above a threshold, else the persona the
+  turn's Journey names as its default, else none. A turn no longer inherits the session's
+  persona, and a turn with none tells the model not to sign. `mirror-mind/desktop` also hands
+  its host the persona's own name beside its id. One new model call per turn, made beside
+  the embedding the turn already makes. No schema change, no migration.
+---
+
+# v0.41.0 — A Persona When the Subject Asks for One
+
+**Date:** 2026-11-08
+
+## Highlights
+
+- **A turn's persona follows its subject, or there is none**
+  ([CR203](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr203-route-a-turns-persona-by-its-subject-and-let-it-have-none.md)).
+  In Mirror Mode, on the delta of an ordinary turn and on the full load alike, the persona
+  is, in order: the one you named (`mirror load --persona`); the router's answer, a
+  Decisions model through OpenRouter's Decisions API asked which persona the subject
+  belongs to and whether it belongs to any, taken only at or above a threshold; the persona
+  the turn's Journey names as `default_persona` in its metadata; or none. It is never the
+  session's by inheritance.
+- **None is said, not left silent.** A turn with no persona delivers
+  `persona: none` and the clause
+  `answer as the mirror; no persona this turn: do not sign, and do not answer as an earlier persona`,
+  so the model does not keep signing as the last persona it answered as.
+- **Every routing failure is none, and the turn goes on.** No key, a timeout, a refusal, a
+  malformed answer or a persona that does not exist each give a turn with no persona. One
+  attempt, bounded like reception (`MEMORY_LLM_TIMEOUT_RECEPTION`, 10 s by default).
+- **Two settings.** `MEMORY_PERSONA_ROUTER_MODEL` (`liquid/d1-ultra`) and
+  `MEMORY_PERSONA_ROUTER_THRESHOLD` (`0.6`), in [`REFERENCE.md`](../../REFERENCE.md); an
+  invalid value reads as unset.
+- **The host gets the persona's name**
+  ([CR204](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr204-hand-the-host-the-personas-name-with-its-id.md)).
+  `deliverMirrorContext` in `mirror-mind/desktop` returns `personaName`, the persona's own
+  `name` from its metadata, or `null`; `persona` stays the id. Additive.
+- No schema change, no migration.
+
+## Where We Started
+
+A keyword count chose every turn's persona, and when no keyword scored, the session's
+persona kept answering. Measured on the maintainer's own data over five days (550
+deliveries), every turn had a persona, the persona changed on one turn in three, and
+specialists from unrelated domains answered: health, customer support and QA personas on a
+book-writing Journey. The maintainer's criterion: a wrong persona is worse than none,
+because it puts a false specialist into the answer, while no persona only loses one
+domain's lens and keeps identity, voice and memories.
+
+## What Changed
+
+**One router for both paths.** `ts/src/mirror/personaRouter.ts` owns the Decisions route,
+which OpenRouter marks `alpha`: its request and answer shapes live in that module and a
+contract test pins them, so a change in the route fails a test, not a turn. The doorman's
+delta and the full load call the same rule, so the two cannot disagree. The delta asks the
+router and embeds the prompt at the same time, so the call adds no wait of its own to the
+delivery. Each persona is offered with its own `description`, else its generated
+descriptor, else the start of its content.
+
+**The session records the turn's answer.** A session's persona is now the last turn's,
+none included. Which persona sections the conversation already holds is kept apart
+(`doorman_personas` in the session's metadata), so a section is delivered the first time
+its persona answers and not again; a full load starts that list over, and a compaction
+clears it.
+
+**Reception still runs** on a full load, for the Journey and the turn's shaping. It no
+longer chooses the persona. Its prompt is unchanged.
+
+**The ledger.** Each routing call writes one `llm_calls` row, `role = persona_routing`,
+with the model, latency and cost, and an empty prompt and response in every logging mode:
+the subject of your turn is not the ledger's to keep.
+
+**Measured before the release.** The router was chosen by an eval of 100 labelled turns
+from the maintainer's production data
+([report](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr203-persona-routing-eval-2026-11-07.md)).
+The same 100, rerun through this release's code on a copy of a home with 28 personas: 93
+right, 3 wrong, 4 missed (the keyword router: 35 wrong), at 0.61 s median and 1.32 s at
+p95, about US$ 0.00008 per turn. The private turns stay out of this repository; a
+synthetic set runs in CI.
+
+**Model-behavior gate.** This release changes no extraction model, embedding model or
+`prompts.ts` prompt, so the gate's letter does not apply; it does add a model call and a
+line the model reads, and the rerun above is its evidence in place of `eval --all`, which
+does not probe routing.
+
+## Conscious Exclusions
+
+- **No command sets a Journey's `default_persona` yet.** The Core reads it; setting it is a
+  follow-up. Two of the rerun's three wrong picks are a Journey's own writing persona on
+  turns that asked for none, the case a default resolves.
+- **The no-persona clause is a first wording**, one constant (`NO_PERSONA_CLAUSE`), to be
+  settled in prompt review.
+- **`detect-persona` stays** as a command, an MCP tool and a package export. It no longer
+  decides a turn.
+- **Reception's prompt still lists the personas**: its bytes are digest-pinned, and
+  changing it is its own decision.
+- **A full load's worst case grows**: reception, then routing, each bounded at 10 s. A
+  delta's is unchanged.
+- **Two personas covering one domain** remain content for their owner to merge.
+
+## Upgrading
+
+```bash
+mirror runtime update
+```
+
+Nothing to configure: the router uses the OpenRouter key Mirror already reads. The routing
+calls are the `persona_routing` rows of `mirror inspect llm-calls`. Turns without a persona
+are expected: they answer as the mirror, unsigned.
+
+## Next Horizon
+
+A command and a host call to set a Journey's `default_persona`; prompt review of the
+no-persona clause; Nautilus for Mirror showing the persona's name from `personaName`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mirror-mind",
-  "version": "0.40.1",
+  "version": "0.41.0",
   "description": "Mirror Mind: a local-first memory and identity framework for agentic AI runtimes (Pi, Claude Code, Codex, Antigravity)",
   "license": "MIT",
   "repository": {

package/plugins/mirror-mind/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "mirror-mind",
-  "version": "0.40.1",
+  "version": "0.41.0",
   "description": "Mirror Mind — local-first memory and identity for agentic runtimes.",
   "author": {
     "name": "Mirror Mind"

package/plugins/mirror-mind/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "mirror-mind",
   "description": "Mirror Mind — local-first memory and identity for agentic runtimes.",
-  "version": "0.40.1",
+  "version": "0.41.0",
   "mcpServers": {
     "mirror-mind": {
       "command": "/bin/sh",

package/ts/src/frontDoor/mirrorModeRoute.ts

@@ -4,7 +4,6 @@ import type { Database, WritableDatabase } from "#db/database.ts";
 import {
   type DoormanDecision,
   decideDoorman,
-  doormanPersonas,
   forgetDoormanDelivery,
   type MemoryScore,
   readDoormanSessionState,
@@ -16,6 +15,12 @@ import {
   logMirrorResponse,
   runMirrorLoad,
 } from "#mirror/orchestration.ts";
+import {
+  LivePersonaRouter,
+  loadReplayPersonaRouter,
+  PERSONA_ROUTER_REPLAY_ENV,
+  type PersonaRouter,
+} from "#mirror/personaRouter.ts";
 import { environmentSessionId, resolveNamedRuntimeSessionId } from "#mirror/runtimeSession.ts";
 import {
   activateOperatingMode,
@@ -43,6 +48,7 @@ export type MirrorRouteEnvironment = {
   MEMORY_RECEPTION?: string;
   MIRROR_TS_MIRROR_LLM_REPLAY?: string;
   MIRROR_TS_MIRROR_EMBEDDING_REPLAY?: string;
+  MIRROR_TS_PERSONA_ROUTER_REPLAY?: string;
 };
 
 export function isMirrorWrite(argv: readonly string[]): boolean {
@@ -109,7 +115,6 @@ export async function runMirrorDoormanRoute(
     decideDoorman({
       prompt,
       state: readDoormanSessionState(db, sessionId),
-      personas: doormanPersonas(db),
     }),
   );
   if (typeof decided === "number") return decided;
@@ -131,6 +136,7 @@ export async function runMirrorDoormanRoute(
       onReceptionOutcome: deps.onReceptionOutcome,
       llmProvider: receptionEnabled ? family.llm : undefined,
       embeddingProvider: family.embedding,
+      personaRouter: personaRouterFor(family.mode, env),
       onMemoryScores: deps.onMemoryScores,
       newId,
       nowIso,
@@ -141,6 +147,21 @@ export async function runMirrorDoormanRoute(
   });
 }
 
+/**
+ * CR203: the persona router for the family's transport. Live asks the
+ * Decisions route; a replay run reaches no network, so it answers from its
+ * recorded fixture when one is named, and otherwise routes nothing: its turns
+ * have the Journey's default or none.
+ */
+export function personaRouterFor(
+  mode: "replay" | "live",
+  env: MirrorRouteEnvironment,
+): PersonaRouter | undefined {
+  if (mode === "live") return new LivePersonaRouter({ env: { ...env } });
+  const fixture = env[PERSONA_ROUTER_REPLAY_ENV];
+  return fixture ? loadReplayPersonaRouter(fixture) : undefined;
+}
+
 export function isModeWrite(argv: readonly string[]): boolean {
   if (argv[0] !== "mode") return false;
   const args = modePositionals(argv.slice(1));
@@ -241,6 +262,7 @@ export async function runMirrorWriteRoute(
     onReceptionOutcome: options.onReceptionOutcome,
     llmProvider: receptionEnabled ? family?.llm : undefined,
     embeddingProvider: family?.embedding,
+    personaRouter: family ? personaRouterFor(family.mode, env) : undefined,
     newId,
     nowIso,
   });

package/ts/src/mirror/defaultResolution.ts

@@ -1,11 +1,11 @@
 import type { Database } from "#db/database.ts";
 import { descriptorsByLayer } from "#descriptor/descriptorRead.ts";
 import type { OnProviderCallOutcome } from "#observability/callOutcome.ts";
-import { detectPersona, type PersonaRoutingRow } from "#persona/detectPersona.ts";
 import { type EmbeddingProvider, generateEmbeddingSafely } from "#providers/embedding.ts";
 import type { LlmProvider, LlmResponse } from "#providers/llm.ts";
 import { cosineSimilarity } from "#search/ranker.ts";
 import { stripAccents } from "#util/slug.ts";
+import { type PersonaRouter, type PersonaRouting, routeTurnPersona } from "./personaRouter.ts";
 import { runReception, sliceCodePoints } from "./reception.ts";
 import { GLOBAL_STICKY_DEFAULTS_SESSION_ID, getRuntimeSession } from "./runtimeSession.ts";
 
@@ -28,6 +28,10 @@ export interface ResolveMirrorDefaultsInput {
   onReceptionLlmCall?: (response: LlmResponse, prompt: string) => void;
   /** Reception's outcome, category only; see `observability/callOutcome.ts`. */
   onReceptionOutcome?: OnProviderCallOutcome;
+  /** CR203: routes the persona when none was named; absent, no call is made. */
+  personaRouter?: PersonaRouter;
+  /** CR203: the routing call, for its ledger row; content-free. */
+  onPersonaRouting?: (routing: PersonaRouting) => void;
 }
 
 interface IdentityRoutingRow {
@@ -48,7 +52,6 @@ export async function resolveMirrorDefaults(
 
   const session = input.sessionId ? getRuntimeSession(db, input.sessionId) : null;
   const global = getRuntimeSession(db, GLOBAL_STICKY_DEFAULTS_SESSION_ID);
-  const stickyPersona = session?.persona || global?.persona || null;
   const stickyJourney = session?.journey || global?.journey || null;
   const query = input.query ?? null;
 
@@ -73,23 +76,33 @@ export async function resolveMirrorDefaults(
       input.onReceptionLlmCall,
       input.onReceptionOutcome,
     );
-    if (reception.personas.length > 0 && persona === null) persona = reception.personas[0] ?? null;
+    // Reception still names personas, and its prompt still offers them: the
+    // prompt is digest-pinned, and changing it is its own decision. Its pick
+    // no longer decides the turn (CR203): the router does, below.
     if (reception.journey && journey === null) journey = reception.journey;
     touchesIdentity = reception.touchesIdentity;
     touchesShadow = reception.touchesShadow;
   }
 
-  persona ??= stickyPersona;
   journey ??= stickyJourney;
 
-  if (persona === null && query) {
-    const matches = detectPersona(query, personaRoutingRows(db));
-    persona = matches[0]?.key ?? null;
-  }
   if (journey === null && query) {
     detectedJourney = await detectJourney(db, query, input.embeddingProvider);
     journey = detectedJourney[0]?.[0] ?? null;
   }
+  // CR203: the persona the person named, else the turn's own by its subject,
+  // else the Journey's default, else none. Never the session's or the last
+  // load's by inheritance: a wrong persona is worse than none.
+  if (persona === null) {
+    persona = (
+      await routeTurnPersona(db, {
+        prompt: query ?? "",
+        journey,
+        router: query ? input.personaRouter : undefined,
+        onRouting: input.onPersonaRouting,
+      })
+    ).persona;
+  }
 
   return { persona, journey, detectedJourney, touchesIdentity, touchesShadow };
 }
@@ -177,14 +190,6 @@ function descriptorMap(db: Database, layer: string): Map<string, string> {
   return new Map(descriptorsByLayer(db, layer).map((row) => [row.key, row.descriptor]));
 }
 
-/** Every persona's routing table, as `detectPersona` scores it. Shared with the doorman (CV9.DS8.TS2). */
-export function personaRoutingRows(db: Database): PersonaRoutingRow[] {
-  return identityRoutingRows(db, "persona").map((row) => ({
-    key: row.key,
-    routing_keywords: routingKeywords(row.metadata),
-  }));
-}
-
 function routingKeywords(metadata: string | null): string[] {
   if (!metadata) return [];
   try {

package/ts/src/mirror/deliverContext.ts

@@ -36,7 +36,7 @@
 import { basename, dirname } from "node:path";
 import { isCommandTurn } from "#conversation/commandTurn.ts";
 import { DatabaseNotCurrentError } from "#conversation/hostCalls.ts";
-import { openDatabaseReadOnly } from "#db/database.ts";
+import { type Database, openDatabaseReadOnly } from "#db/database.ts";
 import { inspectMigrationState } from "#db/migrationReport.ts";
 import { openLiveWriteDatabase } from "#frontDoor/liveBackup.ts";
 import type { ProviderConfig } from "#providers/config.ts";
@@ -48,11 +48,11 @@ import {
   type DoormanDecision,
   type DoormanSessionState,
   decideDoorman,
-  doormanPersonas,
   forgetDoormanDelivery,
   readDoormanSessionState,
   runDoorman,
 } from "./doorman.ts";
+import { LivePersonaRouter, type PersonaRouter } from "./personaRouter.ts";
 
 export type MirrorContextRejection = "invalid_request" | "no_key";
 
@@ -81,7 +81,7 @@ export interface DeliverMirrorContextOptions {
   /** Reception's classifier for the full folder; on unless turned off. */
   receptionEnabled?: boolean;
   /** Tests only: providers in place of the live ones the key would build. */
-  providers?: { llm?: LlmProvider; embedding?: EmbeddingProvider };
+  providers?: { llm?: LlmProvider; embedding?: EmbeddingProvider; personaRouter?: PersonaRouter };
 }
 
 export interface DeliveredMirrorContext {
@@ -90,6 +90,11 @@ export interface DeliveredMirrorContext {
   block: string;
   /** The session's persona and Journey after the delivery. */
   persona: string | null;
+  /**
+   * CR204: the persona's own name, from its metadata, for a host to show; `null` when it has
+   * none or the turn has no persona. Display text only: `persona` stays the id.
+   */
+  personaName: string | null;
   journey: string | null;
 }
 
@@ -97,7 +102,6 @@ export interface DeliveredMirrorContext {
 export function decideHostTurn(input: {
   prompt: string;
   state: DoormanSessionState | null;
-  personas: Parameters<typeof decideDoorman>[0]["personas"];
 }): DoormanDecision {
   const decided = decideDoorman(input);
   // In Mirror Mode the doorman answers nothing only for a command turn, which
@@ -121,8 +125,11 @@ function assertCurrent(dbPath: string): void {
 /**
  * The providers' environment for a host call: the key, one attempt per call,
  * and the embedding bounded like reception (10 s). A full turn makes one
- * reception call and, with attachments, one embedding; a delta, one embedding.
- * So a turn waits at most about 20 s on its providers.
+ * reception call, one persona-routing call (CR203) and, with attachments, one
+ * embedding; a delta, one embedding and one routing call made beside it. So a
+ * delta waits at most about 10 s on its providers and a full turn about 30 s,
+ * only when every call runs to its bound; the routing settings are the
+ * defaults, since a host passes no environment.
  */
 export function hostProviderEnv(apiKey: string): Record<string, string> {
   return {
@@ -137,11 +144,12 @@ export function hostProviderEnv(apiKey: string): Record<string, string> {
 export function hostProviders(
   apiKey: string,
   createClient?: (config: ProviderConfig) => OpenRouterClient,
-): { llm: LlmProvider; embedding: EmbeddingProvider } {
+): { llm: LlmProvider; embedding: EmbeddingProvider; personaRouter: PersonaRouter } {
   const env = hostProviderEnv(apiKey);
   return {
     llm: new LiveLlmProvider({ env, ...(createClient ? { createClient } : {}) }),
     embedding: new LiveEmbeddingProvider({ env, ...(createClient ? { createClient } : {}) }),
+    personaRouter: new LivePersonaRouter({ env, ...(createClient ? { createClient } : {}) }),
   };
 }
 
@@ -172,18 +180,17 @@ export async function deliverMirrorContext(
     decision = decideHostTurn({
       prompt,
       state: readDoormanSessionState(read, sessionId),
-      personas: doormanPersonas(read),
     });
   } finally {
     read.close();
   }
   if (decision.kind === "nothing")
-    return { kind: "nothing", block: "", persona: null, journey: null };
+    return { kind: "nothing", block: "", persona: null, personaName: null, journey: null };
 
   const apiKey = typeof options.apiKey === "string" ? options.apiKey.trim() : "";
   if (!apiKey && !options.providers) throw new MirrorContextRejectedError("no_key");
   const receptionEnabled = options.receptionEnabled !== false;
-  const { llm, embedding } = options.providers ?? hostProviders(apiKey);
+  const { llm, embedding, personaRouter } = options.providers ?? hostProviders(apiKey);
 
   const db = openLiveWriteDatabase(dbPath);
   try {
@@ -198,15 +205,18 @@ export async function deliverMirrorContext(
       receptionEnabled,
       llmProvider: receptionEnabled ? llm : undefined,
       embeddingProvider: embedding,
+      personaRouter,
       extensionRuntime: { environment: {} },
       newId,
       nowIso,
     });
     const state = readDoormanSessionState(db, sessionId);
+    const persona = state?.persona ?? null;
     return {
       kind: decision.kind,
       block: rendered.stdout,
-      persona: state?.persona ?? null,
+      persona,
+      personaName: persona ? personaName(db, persona) : null,
       journey: state?.journey ?? null,
     };
   } finally {
@@ -214,6 +224,20 @@ export async function deliverMirrorContext(
   }
 }
 
+/** CR204: the `name` the seed kept in a persona's metadata, when it kept one. */
+function personaName(db: Database, key: string): string | null {
+  const row = db
+    .prepare("SELECT metadata FROM identity WHERE layer = 'persona' AND key = ?")
+    .get(key);
+  if (typeof row?.metadata !== "string") return null;
+  try {
+    const name: unknown = (JSON.parse(row.metadata) as Record<string, unknown> | null)?.name;
+    return typeof name === "string" && name.trim() ? name.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * The host compacted the Conversation's transcript: the folder left it, so the
  * next turn delivers it whole again. An unknown session is nothing to mark.

package/ts/src/mirror/doorman.ts

@@ -13,11 +13,13 @@
 //
 //   1. the explicit Mirror form in the prompt -> the full folder, routed from
 //      the query, before the first token; the session marked active by its id;
-//   2. Mirror Mode active, an ordinary turn -> the prompt is routed with
-//      `detectPersona` (a keyword score, no model call); a persona that newly
-//      scores has its section delivered and becomes the session's; the
-//      memories and attachments relevant to the prompt follow; the identity
-//      layers are not repeated -- they already sit in the transcript;
+//   2. Mirror Mode active, an ordinary turn -> the turn's persona is routed
+//      by its subject (CR203, `personaRouter.ts`): the router's answer, else
+//      the Journey's own default, else none -- never the session's by
+//      inheritance; a persona the conversation has not read yet has its
+//      section delivered; the memories and attachments relevant to the prompt
+//      follow; the identity layers are not repeated -- they already sit in
+//      the transcript;
 //      a skill invocation other than the Mirror form is not a question and
 //      gets nothing (CR160's command-turn rule);
 //   3. Mirror Mode not active -> nothing. The model's own routing may invoke
@@ -37,7 +39,8 @@
 //
 // What a turn costs: nothing when Mirror Mode is off; on an ordinary active
 // turn, ONE embedding, shared by the memory and attachment searches and
-// counted once in `llm_calls` (DS8 decision 1); on the explicit turn, what
+// counted once in `llm_calls` (DS8 decision 1), and ONE persona-routing call,
+// made beside the embedding, not after it (CR203); on the explicit turn, what
 // `mirror load --query` costs today (reception's LLM call when enabled, the
 // attachment embedding), plus the skill's own load until TS3 teaches it to
 // trust this line.
@@ -48,14 +51,13 @@ import { memoriesById } from "#frontDoor/searchRoute.ts";
 import { getIdentityContent } from "#identity/identityRead.ts";
 import { getActiveOperatingMode } from "#mode/operatingMode.ts";
 import { embeddingLedgerHook } from "#observability/ledgerHooks.ts";
-import { detectPersona, type PersonaRoutingRow } from "#persona/detectPersona.ts";
 import { type EmbeddingProvider, generateEmbeddingSafely } from "#providers/embedding.ts";
 import { searchMemoriesWithStatus } from "#search/memorySearch.ts";
 import { pythonJsonDumps } from "#util/pyGenerators.ts";
 import { relevantAttachments } from "./context.ts";
-import { personaRoutingRows } from "./defaultResolution.ts";
 import { mirrorForm } from "./mirrorForm.ts";
 import { type MirrorLoadInput, runMirrorLoad } from "./orchestration.ts";
+import { personaRoutingLedger, routeTurnPersona } from "./personaRouter.ts";
 import {
   decodeMetadata,
   getRuntimeSession,
@@ -80,8 +82,6 @@ export type DoormanDecision =
   | {
       readonly kind: "delta";
       readonly query: string;
-      /** The persona that newly scored, or null when the session's stands. */
-      readonly persona: string | null;
     };
 
 /** The stable prefix TS3's skill reads; everything after the colon varies. */
@@ -116,6 +116,15 @@ export const DOORMAN_MEMORY_SEMANTIC_THRESHOLD = 0.4;
  */
 export const DOORMAN_DELIVERED_METADATA_KEY = "doorman_delivered";
 
+/**
+ * The personas whose section the conversation already holds (CR203). A turn
+ * may now have none, so "the session's persona" no longer says which sections
+ * the transcript carries: a writer turn, a turn with none, and a writer turn
+ * again must deliver the writer's section once. A full load starts the list
+ * over with its own persona.
+ */
+export const DOORMAN_PERSONAS_METADATA_KEY = "doorman_personas";
+
 /**
  * Set on the session when the runtime compacted the transcript (the Pi
  * extension's `session_compact`, CV9.DS8.US5): a delta's premise -- the
@@ -139,38 +148,56 @@ export function forgetDoormanDelivery(
   const metadata = decodeMetadata(session.metadata);
   metadata[DOORMAN_REFRESH_METADATA_KEY] = true;
   metadata[DOORMAN_DELIVERED_METADATA_KEY] = [];
+  metadata[DOORMAN_PERSONAS_METADATA_KEY] = [];
   updateRuntimeSessionColumns(db, sessionId, { metadata: pythonJsonDumps(metadata) }, nowIso);
 }
 
 /** How many ranked memories a delta may read through to fill its five. */
 const DOORMAN_SEARCH_CEILING = 25;
 
-function deliveredMemoryIds(db: Database, sessionId: string | null): Set<string> {
+function deliveredList(db: Database, sessionId: string | null, key: string): Set<string> {
   if (!sessionId) return new Set();
-  const raw = decodeMetadata(getRuntimeSession(db, sessionId)?.metadata ?? null)[
-    DOORMAN_DELIVERED_METADATA_KEY
-  ];
+  const raw = decodeMetadata(getRuntimeSession(db, sessionId)?.metadata ?? null)[key];
   return new Set(
     Array.isArray(raw) ? raw.filter((id): id is string => typeof id === "string") : [],
   );
 }
 
+function deliveredMemoryIds(db: Database, sessionId: string | null): Set<string> {
+  return deliveredList(db, sessionId, DOORMAN_DELIVERED_METADATA_KEY);
+}
+
 function rememberDelivered(
   db: WritableDatabase,
   sessionId: string | null,
   ids: readonly string[],
   nowIso: string,
-  options: { clearRefresh?: boolean } = {},
+  options: { clearRefresh?: boolean; personas?: readonly string[] } = {},
 ): void {
   if (!sessionId) return;
   const session = getRuntimeSession(db, sessionId);
   if (!session) return;
   const metadata = decodeMetadata(session.metadata);
   metadata[DOORMAN_DELIVERED_METADATA_KEY] = [...ids];
+  if (options.personas) metadata[DOORMAN_PERSONAS_METADATA_KEY] = [...options.personas];
   if (options.clearRefresh) delete metadata[DOORMAN_REFRESH_METADATA_KEY];
   updateRuntimeSessionColumns(db, sessionId, { metadata: pythonJsonDumps(metadata) }, nowIso);
 }
 
+function rememberPersonas(
+  db: WritableDatabase,
+  sessionId: string | null,
+  personas: readonly string[],
+  nowIso: string,
+): void {
+  if (!sessionId) return;
+  const session = getRuntimeSession(db, sessionId);
+  if (!session) return;
+  const metadata = decodeMetadata(session.metadata);
+  metadata[DOORMAN_PERSONAS_METADATA_KEY] = [...personas];
+  updateRuntimeSessionColumns(db, sessionId, { metadata: pythonJsonDumps(metadata) }, nowIso);
+}
+
 /** One ranked memory's scores, content-free, for the front-door log. */
 export interface MemoryScore {
   readonly score: number;
@@ -206,7 +233,6 @@ export function readDoormanSessionState(
 export function decideDoorman(input: {
   prompt: string;
   state: DoormanSessionState | null;
-  personas: readonly PersonaRoutingRow[];
 }): DoormanDecision {
   const explicit = mirrorForm(input.prompt);
   if (explicit) return { kind: "full", query: explicit.query };
@@ -220,19 +246,29 @@ export function decideDoorman(input: {
   // The runtime compacted the transcript: the folder is a summary now, so this
   // turn delivers it whole, routed from the prompt, and the deltas resume after.
   if (input.state.refresh) return { kind: "full", query: input.prompt };
-  const match = detectPersona(input.prompt, input.personas)[0]?.key ?? null;
-  const persona = match !== null && match !== input.state.persona ? match : null;
-  return { kind: "delta", query: input.prompt, persona };
+  // The persona is not decided here: routing it is a model call (CR203), and
+  // this function stays pure. `runDoorman` routes it, beside the embedding.
+  return { kind: "delta", query: input.prompt };
 }
 
+/**
+ * What the line says when a turn has no persona (CR203). Draft wording, for the
+ * prompt engineer to settle in review: no signature, and no earlier persona
+ * carried over.
+ */
+export const NO_PERSONA_CLAUSE =
+  "no persona this turn: do not sign, and do not answer as an earlier persona";
+
 export function deliveredLine(input: {
   kind: "full" | "delta";
   persona: string | null;
   journey: string | null;
 }): string {
+  // CR203: a turn may have no persona, and the model must hear that as this
+  // turn's answer, not as silence it may fill with the last persona it signed.
   const clause = input.persona
     ? `answer as the mirror; sign ◇ ${input.persona}`
-    : "answer as the mirror";
+    : `answer as the mirror; ${NO_PERSONA_CLAUSE}`;
   const what =
     input.kind === "full"
       ? "full"
@@ -289,7 +325,10 @@ async function runFull(
     // The conversation's context starts over with the folder: so does the
     // list of memories the deltas have put in it, and a compaction's refresh
     // is answered.
-    rememberDelivered(db, input.sessionId, [], input.nowIso(), { clearRefresh: true });
+    rememberDelivered(db, input.sessionId, [], input.nowIso(), {
+      clearRefresh: true,
+      personas: loaded.resolved.persona ? [loaded.resolved.persona] : [],
+    });
   }
   const line = deliveredLine({
     kind: "full",
@@ -305,28 +344,37 @@ async function runDelta(
   input: RunDoormanInput,
 ): Promise<RenderedDoorman> {
   const state = readDoormanSessionState(db, input.sessionId);
-  const persona = decision.persona ?? state?.persona ?? null;
   const journey = state?.journey ?? null;
+  // The turn's persona and its embedding, side by side: neither waits on the
+  // other. One embedding for the turn, in the ledger once; both searches share
+  // it. Without a provider, or when it fails, the memory search degrades to FTS
+  // and the attachments are skipped: the delta still carries the line and the
+  // persona.
+  const [turn, queryEmbedding] = await Promise.all([
+    routeTurnPersona(db, {
+      prompt: decision.query,
+      journey,
+      router: input.personaRouter,
+      onRouting: personaRoutingLedger(db, { sessionId: input.sessionId, now: input.nowIso }),
+    }),
+    embedOnce(db, decision.query, input),
+  ]);
+  const persona = turn.persona;
   const parts: string[] = [deliveredLine({ kind: "delta", persona, journey })];
 
-  if (decision.persona) {
-    const content = getIdentityContent(db, "persona", decision.persona);
-    if (content) parts.push(`=== persona/${decision.persona} ===\n${content}`);
-    if (input.sessionId) {
-      updateRuntimeSessionColumns(
-        db,
-        input.sessionId,
-        { persona: decision.persona },
-        input.nowIso(),
-      );
+  const deliveredPersonas = deliveredList(db, input.sessionId, DOORMAN_PERSONAS_METADATA_KEY);
+  if (persona && !deliveredPersonas.has(persona)) {
+    const content = getIdentityContent(db, "persona", persona);
+    if (content) {
+      parts.push(`=== persona/${persona} ===\n${content}`);
+      rememberPersonas(db, input.sessionId, [...deliveredPersonas, persona], input.nowIso());
     }
   }
-
-  // One embedding for the turn, in the ledger once; both searches share it.
-  // Without a provider, or when it fails, the memory search degrades to FTS
-  // and the attachments are skipped: the delta still carries the line and the
-  // persona.
-  const queryEmbedding = await embedOnce(db, decision.query, input);
+  // The session records the turn's answer, none included: a session's persona
+  // is the last turn's, not a default the next turn inherits.
+  if (input.sessionId && persona !== (state?.persona ?? null)) {
+    updateRuntimeSessionColumns(db, input.sessionId, { persona }, input.nowIso());
+  }
 
   const delivered = deliveredMemoryIds(db, input.sessionId);
   const memories = await searchMemoriesWithStatus(db, {
@@ -413,8 +461,3 @@ async function embedOnce(
     return null;
   }
 }
-
-/** The persona routing table the decision scores against; read once per turn. */
-export function doormanPersonas(db: Database): PersonaRoutingRow[] {
-  return personaRoutingRows(db);
-}

package/ts/src/mirror/orchestration.ts

@@ -12,6 +12,7 @@ import type { EmbeddingProvider } from "#providers/embedding.ts";
 import type { LlmProvider } from "#providers/llm.ts";
 import { loadMirrorContext } from "./context.ts";
 import { type ResolvedMirrorDefaults, resolveMirrorDefaults } from "./defaultResolution.ts";
+import { type PersonaRouter, personaRoutingLedger } from "./personaRouter.ts";
 import { pythonTruthy, sliceCodePoints } from "./reception.ts";
 import {
   renderJourneyDetected,
@@ -47,6 +48,8 @@ export interface MirrorLoadInput {
   onReceptionOutcome?: OnProviderCallOutcome;
   llmProvider?: LlmProvider;
   embeddingProvider?: EmbeddingProvider;
+  /** CR203: routes a turn's persona by its subject; absent, the turn has the Journey's default or none. */
+  personaRouter?: PersonaRouter;
   databasePath?: string;
   mirrorHome?: string;
   user?: string;
@@ -72,6 +75,10 @@ export async function runMirrorLoad(
   const resolved = await resolveMirrorDefaults(db, {
     ...input,
     onReceptionOutcome: input.onReceptionOutcome,
+    onPersonaRouting: personaRoutingLedger(db, {
+      sessionId: input.sessionId ?? null,
+      now: input.nowIso,
+    }),
     // Priced, as Python's `build_llm_logger(role="reception")` prices it
     // (CV22.DS8.US3). The row existed before but carried a null cost, so
     // every Mirror Mode activation with a query would have logged live spend
@@ -289,7 +296,9 @@ function writeMirrorState(
     input.sessionId,
     {
       mirrorActive: input.active,
-      ...(input.persona !== undefined && input.persona !== null ? { persona: input.persona } : {}),
+      // A load's persona is recorded even when it is none (CR203): the session
+      // must not keep an earlier turn's persona as if this one had chosen it.
+      ...(input.persona !== undefined ? { persona: input.persona } : {}),
       ...(input.journey !== undefined && input.journey !== null ? { journey: input.journey } : {}),
     },
     nowIso,

package/ts/src/mirror/personaRouter.ts

@@ -0,0 +1,389 @@
+// CR203: a turn's persona, by its subject, or none.
+//
+// Until CR203 a turn always had a persona: a keyword count chose one, and when
+// nothing scored the session's kept answering. Measured on production data, a
+// third of consecutive turns switched persona and specialists from unrelated
+// domains answered. The Navigator's criterion: a wrong persona is worse than
+// none, because it puts a false specialist into the answer, while no persona
+// only loses one domain's lens.
+//
+// So a turn's persona is, in order:
+//
+//   1. the router's answer: a Decisions model through OpenRouter's Decisions
+//      API, asked one Choice (which persona) and one Noul (does the subject
+//      belong to any of them) in one request; the Choice is taken only when
+//      the Noul is at or above the threshold and it names a known persona;
+//   2. else the persona the turn's Journey names as its own default
+//      (`default_persona` in the Journey's metadata): the Journey's word, not
+//      an inference;
+//   3. else none.
+//
+// Every failure lands on none: no key, a timeout, a refusal, a malformed
+// answer, an unknown persona. The router never throws into a turn. Both the
+// doorman's delta and the full load call `routeTurnPersona`, so the two paths
+// cannot disagree.
+//
+// The route is `alpha`. Its request and answer shapes live here and nowhere
+// else, pinned by a contract test, so a change in the shape fails a test, not
+// a turn.
+
+import { readFileSync } from "node:fs";
+import type { Database, StatementRunner } from "#db/database.ts";
+import { descriptorsByLayer } from "#descriptor/descriptorRead.ts";
+import { logLlmCall } from "#observability/llmCalls.ts";
+import {
+  DEFAULT_PERSONA_ROUTER_THRESHOLD,
+  hasOpenRouterKey,
+  type ProviderConfig,
+  resolveLlmTimeoutMs,
+  resolvePersonaRouterModel,
+  resolvePersonaRouterThreshold,
+  resolveProviderConfig,
+} from "#providers/config.ts";
+import { createOpenRouterClient, type OpenRouterClient } from "#providers/openrouter.ts";
+import { sliceCodePoints } from "./reception.ts";
+
+/** A persona as the router offers it: its key and what it is for. */
+export interface RoutablePersona {
+  readonly key: string;
+  readonly description: string;
+}
+
+export interface PersonaRouteInput {
+  readonly prompt: string;
+  readonly journey: string | null;
+  readonly personas: readonly RoutablePersona[];
+}
+
+/** Why the router answered what it did; content-free. */
+export type PersonaRoutingOutcome =
+  | "chosen"
+  | "below_threshold"
+  | "unknown_persona"
+  | "malformed"
+  | "failed"
+  | "no_key"
+  | "no_personas";
+
+export interface PersonaRouting {
+  readonly persona: string | null;
+  readonly outcome: PersonaRoutingOutcome;
+  /** The model asked; absent when no call was made. */
+  readonly model?: string;
+  readonly noul?: number;
+  readonly latencyMs?: number;
+  readonly costUsd?: number | null;
+}
+
+export interface PersonaRouter {
+  route(input: PersonaRouteInput): Promise<PersonaRouting>;
+}
+
+/** The Decisions route, under `/api`, not the chat client's `/api/v1`. */
+export const DECISIONS_BASE_URL = "https://openrouter.ai/api";
+export const DECISIONS_PATH = "/alpha/decisions";
+
+/** The bounds the eval measured with: what the model reads of each part. */
+const REQUEST_CHARS = 2000;
+const DESCRIPTION_CHARS = 280;
+const NOUL_DESCRIPTION_CHARS = 90;
+
+/** The request body, as the eval of 2026-11-07 sent it. Pure. */
+export function decisionsRequest(model: string, input: PersonaRouteInput): unknown {
+  const criteria = Object.fromEntries(
+    input.personas.map((persona) => [
+      persona.key,
+      sliceCodePoints(persona.description, DESCRIPTION_CHARS),
+    ]),
+  );
+  const listed = input.personas
+    .map(
+      (persona) =>
+        `${persona.key}: ${sliceCodePoints(persona.description, NOUL_DESCRIPTION_CHARS)}`,
+    )
+    .join("; ");
+  return {
+    model,
+    state: { journey: input.journey, request: sliceCodePoints(input.prompt, REQUEST_CHARS) },
+    questions: {
+      persona: {
+        type: "choice",
+        instructions:
+          "Which specialist should answer this request, judging only by the subject of `request`?",
+        criteria,
+      },
+      fits: {
+        type: "noul",
+        instructions: `Does the subject of \`request\` clearly belong to the domain of one specific specialist from this list: ${listed}?`,
+        criteria: {
+          true: "The request asks for expertise that one listed specialist clearly owns.",
+          false:
+            "The request is a plain instruction, a confirmation, a general question, or its subject belongs to no listed specialist.",
+        },
+      },
+    },
+  };
+}
+
+function record(value: unknown): Record<string, unknown> | null {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+/** The answer read against the personas offered and the threshold. Pure. */
+export function readDecisionsAnswer(
+  body: unknown,
+  personas: readonly RoutablePersona[],
+  threshold: number,
+): PersonaRouting {
+  const answers = record(record(body)?.answers);
+  const choice = record(answers?.persona)?.choice;
+  const noul = record(answers?.fits)?.noul;
+  const cost = record(record(body)?.usage)?.cost;
+  const costUsd = typeof cost === "number" && Number.isFinite(cost) ? cost : null;
+  if (typeof choice !== "string" || typeof noul !== "number" || !(noul >= 0 && noul <= 1)) {
+    return { persona: null, outcome: "malformed", costUsd };
+  }
+  if (noul < threshold) return { persona: null, outcome: "below_threshold", noul, costUsd };
+  if (!personas.some((persona) => persona.key === choice)) {
+    return { persona: null, outcome: "unknown_persona", noul, costUsd };
+  }
+  return { persona: choice, outcome: "chosen", noul, costUsd };
+}
+
+export interface LivePersonaRouterOptions {
+  /** Where the key and the settings are read; a host passes its own. */
+  env?: Record<string, string | undefined>;
+  /** Tests only: a client in place of the live one. */
+  createClient?: (config: ProviderConfig) => OpenRouterClient;
+  /** Tests only: the clock latency is measured with. */
+  clock?: () => number;
+}
+
+/**
+ * The router over OpenRouter's Decisions API: one attempt, bounded like
+ * reception (10 s), since a person's turn waits on it. The eval's p95 was 1.1 s.
+ */
+export class LivePersonaRouter implements PersonaRouter {
+  readonly #env: Record<string, string | undefined>;
+  readonly #createClient: (config: ProviderConfig) => OpenRouterClient;
+  readonly #clock: () => number;
+
+  constructor(options: LivePersonaRouterOptions = {}) {
+    this.#env = options.env ?? process.env;
+    this.#createClient = options.createClient ?? ((config) => createOpenRouterClient(config));
+    this.#clock = options.clock ?? (() => performance.now());
+  }
+
+  async route(input: PersonaRouteInput): Promise<PersonaRouting> {
+    if (input.personas.length === 0) return { persona: null, outcome: "no_personas" };
+    if (!hasOpenRouterKey(this.#env)) return { persona: null, outcome: "no_key" };
+    const env = this.#env;
+    const model = resolvePersonaRouterModel({ env });
+    const started = this.#clock();
+    try {
+      const client = this.#createClient({
+        ...resolveProviderConfig("openrouter", { env }),
+        baseUrl: DECISIONS_BASE_URL,
+      });
+      const body = await client.postJson(DECISIONS_PATH, decisionsRequest(model, input), {
+        timeoutMs: resolveLlmTimeoutMs("reception", { env }),
+        maxRetries: 0,
+      });
+      const latencyMs = Math.round(this.#clock() - started);
+      return {
+        ...readDecisionsAnswer(body, input.personas, resolvePersonaRouterThreshold({ env })),
+        model,
+        latencyMs,
+      };
+    } catch {
+      return {
+        persona: null,
+        outcome: "failed",
+        model,
+        latencyMs: Math.round(this.#clock() - started),
+      };
+    }
+  }
+}
+
+/**
+ * Where a replay run finds its router's recorded answers. A family's replay
+ * reaches no network, and without this its turns could only ever have none:
+ * the route from the command to the session row would go untested.
+ */
+export const PERSONA_ROUTER_REPLAY_ENV = "MIRROR_TS_PERSONA_ROUTER_REPLAY";
+
+export interface PersonaRouterReplayFixture {
+  readonly kind: "persona_router";
+  /** The first answer whose `contains` is in the prompt, case aside, is the route's body. */
+  readonly answers: readonly { readonly contains: string; readonly body: unknown }[];
+}
+
+/**
+ * Recorded Decisions bodies, read through the same `readDecisionsAnswer` the
+ * live route's are. A prompt no answer matches is below the threshold. No
+ * model is named, so a replay writes no ledger row.
+ */
+export class ReplayPersonaRouter implements PersonaRouter {
+  readonly #fixture: PersonaRouterReplayFixture;
+  readonly #threshold: number;
+
+  constructor(fixture: PersonaRouterReplayFixture, threshold = DEFAULT_PERSONA_ROUTER_THRESHOLD) {
+    this.#fixture = fixture;
+    this.#threshold = threshold;
+  }
+
+  async route(input: PersonaRouteInput): Promise<PersonaRouting> {
+    const prompt = input.prompt.toLowerCase();
+    const answer = this.#fixture.answers.find((candidate) =>
+      prompt.includes(candidate.contains.toLowerCase()),
+    );
+    if (!answer) return { persona: null, outcome: "below_threshold" };
+    const {
+      model: _model,
+      latencyMs: _latency,
+      ...read
+    } = readDecisionsAnswer(answer.body, input.personas, this.#threshold);
+    return read;
+  }
+}
+
+export function loadReplayPersonaRouter(path: string): ReplayPersonaRouter {
+  const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+  const fixture = record(parsed);
+  if (fixture?.kind !== "persona_router" || !Array.isArray(fixture.answers)) {
+    throw new Error(`${PERSONA_ROUTER_REPLAY_ENV} is not a persona_router fixture: ${path}`);
+  }
+  return new ReplayPersonaRouter(fixture as unknown as PersonaRouterReplayFixture);
+}
+
+/**
+ * Every persona with what it is for: its own `description` (seeded from its
+ * YAML), else its generated descriptor, else the start of its content. The
+ * description comes first because it is the persona's declared purpose and
+ * what the eval measured with; the rerun on the Core's code with descriptors
+ * first doubled the wrong picks, since 11 of 28 production personas had none
+ * and fell back to a heading.
+ */
+export function routablePersonas(db: Database): RoutablePersona[] {
+  const descriptors = new Map(
+    descriptorsByLayer(db, "persona").map((row) => [row.key, row.descriptor]),
+  );
+  return db
+    .prepare("SELECT key, content, metadata FROM identity WHERE layer = 'persona' ORDER BY key")
+    .all()
+    .map((row) => {
+      const key = String(row.key);
+      return {
+        key,
+        description:
+          declaredDescription(row.metadata) ||
+          descriptors.get(key)?.trim() ||
+          sliceCodePoints(String(row.content), 200),
+      };
+    });
+}
+
+function declaredDescription(metadata: unknown): string {
+  if (typeof metadata !== "string") return "";
+  try {
+    const description = record(JSON.parse(metadata))?.description;
+    return typeof description === "string" ? description.trim() : "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * The persona a Journey names as its own default, when it names one that
+ * exists. Read from the Journey's metadata (`default_persona`).
+ */
+export function journeyDefaultPersona(db: Database, journey: string | null): string | null {
+  if (!journey) return null;
+  const row = db
+    .prepare("SELECT metadata FROM identity WHERE layer = 'journey' AND key = ?")
+    .get(journey);
+  if (typeof row?.metadata !== "string") return null;
+  let named: unknown;
+  try {
+    named = record(JSON.parse(row.metadata))?.default_persona;
+  } catch {
+    return null;
+  }
+  if (typeof named !== "string" || !named.trim()) return null;
+  const exists = db
+    .prepare("SELECT 1 AS found FROM identity WHERE layer = 'persona' AND key = ?")
+    .get(named.trim());
+  return exists ? named.trim() : null;
+}
+
+export interface TurnPersona {
+  readonly persona: string | null;
+  /** Where the persona came from; null when the turn has none. */
+  readonly source: "router" | "journey" | null;
+}
+
+export interface RouteTurnPersonaInput {
+  readonly prompt: string;
+  readonly journey: string | null;
+  /** Absent: no call is made, and the turn falls to the Journey's default or none. */
+  readonly router?: PersonaRouter;
+  /** Where the call's ledger row goes; content-free. */
+  readonly onRouting?: (routing: PersonaRouting) => void;
+}
+
+/** The turn's persona: the router's answer, else the Journey's default, else none. */
+export async function routeTurnPersona(
+  db: Database,
+  input: RouteTurnPersonaInput,
+): Promise<TurnPersona> {
+  if (input.router) {
+    const personas = routablePersonas(db);
+    let routing: PersonaRouting;
+    try {
+      routing = await input.router.route({
+        prompt: input.prompt,
+        journey: input.journey,
+        personas,
+      });
+    } catch {
+      routing = { persona: null, outcome: "failed" };
+    }
+    input.onRouting?.(routing);
+    const chosen = routing.persona;
+    if (chosen !== null && personas.some((persona) => persona.key === chosen)) {
+      return { persona: chosen, source: "router" };
+    }
+  }
+  const fallback = journeyDefaultPersona(db, input.journey);
+  return fallback ? { persona: fallback, source: "journey" } : { persona: null, source: null };
+}
+
+/**
+ * One `llm_calls` row for a call that was made, without the prompt or the
+ * answer in any logging mode: the subject of a person's turn is not the
+ * ledger's to keep.
+ */
+export function personaRoutingLedger(
+  db: StatementRunner,
+  context: { sessionId?: string | null; now?: () => string } = {},
+): (routing: PersonaRouting) => void {
+  return (routing) => {
+    if (!routing.model) return;
+    logLlmCall(
+      db,
+      {
+        role: "persona_routing",
+        model: routing.model,
+        prompt: "",
+        response: "",
+        latencyMs: routing.latencyMs ?? null,
+        costUsd: routing.costUsd ?? null,
+        sessionId: context.sessionId ?? null,
+      },
+      context.now ? { now: context.now } : {},
+    );
+  };
+}

package/ts/src/providers/config.ts

@@ -161,6 +161,31 @@ export function resolveExtractionReasoning(
   return { model, effort: null, source: null, invalid: setting.invalid };
 }
 
+/**
+ * CR203: the Decisions model that routes a turn's persona, and the Noul score
+ * at or above which its choice is taken. The eval of 2026-11-07 chose the pair
+ * (`docs/project/refinement/rs010-cv22-oracle-and-port-hygiene/`); they are
+ * settings so a later model replaces it without a code change, measured again
+ * on a labelled set first. An empty or invalid value reads as unset: a typo
+ * must not turn routing off, or on for every turn.
+ */
+export const DEFAULT_PERSONA_ROUTER_MODEL = "liquid/d1-ultra";
+export const DEFAULT_PERSONA_ROUTER_THRESHOLD = 0.6;
+
+export function resolvePersonaRouterModel(options: ModelPinOptions = {}): string {
+  const env = options.env ?? process.env;
+  return env.MEMORY_PERSONA_ROUTER_MODEL?.trim() || DEFAULT_PERSONA_ROUTER_MODEL;
+}
+
+export function resolvePersonaRouterThreshold(options: ModelPinOptions = {}): number {
+  const env = options.env ?? process.env;
+  const raw = env.MEMORY_PERSONA_ROUTER_THRESHOLD?.trim() ?? "";
+  const parsed = Number(raw);
+  return raw !== "" && Number.isFinite(parsed) && parsed >= 0 && parsed <= 1
+    ? parsed
+    : DEFAULT_PERSONA_ROUTER_THRESHOLD;
+}
+
 // Observability (AI-09, CV9.E2.S13): mirrors Python's MEMORY_LOG_LLM_CALLS
 // resolution exactly -- off | metadata | full, default metadata (never a
 // silent full -- bodies are opt-in only). Legacy "1" maps to "full" for