mirror-mind 0.40.0 → 0.41.0

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/guards/claudePlugin.ts

@@ -111,6 +111,10 @@ export const ABSOLUTE_PATH_CASE = "/*|\\\\*|[A-Za-z]:[\\\\/]*";
  * reason, in the Pi extension's words, and the search goes on without it. The
  * value is read once, into `mmnode`, and printed with `printf` and its line
  * breaks removed: dash's `echo` turns the `\n` of `\nodejs` into a newline.
+ * `MIRROR_BIN` follows the same rule (CR197): only an absolute path to a
+ * directory holding an executable `mirror`, read once, into `mmbindir`, and
+ * refused in the same words. A relative one would resolve against the project
+ * the client started the server from, and Node would run that project's file.
  *
  * Written for what three runtimes do to the string (the US6 spike):
  *
@@ -119,14 +123,17 @@ export const ABSOLUTE_PATH_CASE = "/*|\\\\*|[A-Za-z]:[\\\\/]*";
  *     runtime that did so with an unset name would blank it;
  *   * no positional parameter (`$1`, `$@`, ...) and no backtick, for the same
  *     reason, and because the text travels through two JSON encoders;
- *   * variables named `mmbin`, `mmnode`, `mmdir`: Grok substitutes SET
+ *   * variables named `mmbin`, `mmbindir`, `mmnode`, `mmdir`: Grok substitutes SET
  *     environment variables by name inside MCP args at load time (`$HOME`
  *     became the path), so a script variable with a name a person exports
  *     would be replaced before the shell ever saw it.
  */
 export const MCP_LOCATOR = [
   'mmbin=""',
-  '[ -n "$MIRROR_BIN" ] && [ -x "$MIRROR_BIN/mirror" ] && mmbin="$MIRROR_BIN/mirror"',
+  'mmbindir="$MIRROR_BIN"',
+  'mmwhy=""',
+  `[ -n "$mmbindir" ] && case "$mmbindir" in ${ABSOLUTE_PATH_CASE}) if [ ! -e "$mmbindir" ]; then mmwhy="missing"; elif [ ! -d "$mmbindir" ]; then mmwhy="not a directory"; elif [ ! -f "$mmbindir/mirror" ] || [ ! -x "$mmbindir/mirror" ]; then mmwhy="a directory without an executable mirror"; else mmbin="$mmbindir/mirror"; fi ;; *) mmwhy="relative" ;; esac`,
+  `[ -n "$mmwhy" ] && printf 'mirror-mind: MIRROR_BIN=%s is %s; searching the PATH and the usual places instead\\n' "$(printf '%s' "$mmbindir" | tr -d '\\r\\n')" "$mmwhy" >&2`,
   '[ -n "$mmbin" ] || mmbin="$(command -v mirror 2>/dev/null)"',
   `for mmdir in ${GLOBAL_BIN_DIRS.join(" ")}; do [ -n "$mmbin" ] && break; [ -x "$mmdir/mirror" ] && mmbin="$mmdir/mirror"; done`,
   '[ -n "$mmbin" ] || { echo "mirror-mind: mirror not found on PATH; the MCP server cannot start. Install mirror-mind (npm install -g mirror-mind) or set MIRROR_BIN to its bin directory." >&2; exit 1; }',

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,