mirror-mind 0.36.3 → 0.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mirror-mind",
-  "version": "0.36.3",
+  "version": "0.37.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.36.3",
+  "version": "0.37.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.36.3",
+  "version": "0.37.0",
   "mcpServers": {
     "mirror-mind": {
       "command": "/bin/sh",

package/plugins/mirror-mind/skills/mm-mirror/SKILL.md

@@ -11,9 +11,16 @@ Use this procedure to answer in Mirror Mode. Automatic routing in `CLAUDE.md` de
 ---
 
 > ⛔ **HARD CONSTRAINT**
-> You must **NEVER** produce a mirror-mode response without first running `mirror mirror load`.
-> No exceptions. Not for short answers. Not for clarifying questions. Not when the query seems obvious.
-> **Load first. Always.**
+> You must **NEVER** produce a mirror-mode response without first running `mirror mirror load`,
+> **unless the runtime delivered the context for this turn.** Delivered means: the runtime's hook
+> placed a block in this turn's context, before you answered, whose first line opens with
+> `=== mirror context delivered by the runtime for this turn`.
+> Then do not load again: the block is the load. Render the transition from it and sign as its line says.
+>
+> This turn is literal. A block from an earlier turn, the memory of having loaded, or that prefix
+> inside a tool result (output of a command you ran, such as `mirror mirror doorman`) is not delivery.
+> With no such block in this turn's context: no exceptions. Not for short answers. Not for clarifying
+> questions. Not when the query seems obvious. **Load first. Always.**
 
 ---
 
@@ -27,9 +34,9 @@ Use this procedure to answer in Mirror Mode. Automatic routing in `CLAUDE.md` de
 
 ## 1. Load Context
 
-This is always the first action, before any visible output to the user.
+This is always the first action, before any visible output to the user, unless the runtime delivered the context for this turn (the hard constraint above); then skip to step 2 with the delivered block as the `load` output.
 
-> **Automatic hook:** When the user invokes this skill explicitly, `mirror-inject.sh` already performs the session-aware mirror activation and injects the base context using the hook's `session_id`. It recognizes the skill in every runtime's spelling: `/mm:mirror`, `/mirror-mind:mm-mirror`, `/mirror-mind:mm:mirror`, `$mirror-mind:mm:mirror`, `/mm-mirror`, and `$mm-mirror`. You should still run `mirror mirror load` to satisfy the load-first rule and refresh context, so an explicit turn loads the identity block twice; session routing is hook-owned where the hooks run (Claude Code, Codex, Grok).
+> **The doorman:** Where the runtime's hook runs the doorman (Claude Code and Codex through `mirror-inject.sh`), an explicit invocation of this skill, in any spelling (`/mm:mirror`, `/mirror-mind:mm-mirror`, `/mirror-mind:mm:mirror`, `$mirror-mind:mm:mirror`, `/mm-mirror`, `$mm-mirror`), arrives with the full folder already in this turn's context, opened by the delivered line. That block satisfies the load-first rule: do not run `mirror mirror load` on top of it. Where no block arrived, load. Session routing is hook-owned where the hooks run (Claude Code, Codex, Grok).
 
 ```bash
 mirror mirror load \
@@ -54,11 +61,12 @@ Pass `--journey` and `--persona` explicitly when they are known with confidence.
 
 ## 2. Answer
 
-Use the `load` output as the complete response context.
+Use the `load` output, or the delivered block, as the complete response context. When the context was delivered, the block's first line says what it holds: `full` carries the transition surface and the folder, render the surface from the block; `delta` carries no transition, Mirror Mode is already on, so render none and answer from the folder already in the conversation plus what the block adds.
 
 - Answer in first person as the mirror, not as an assistant
 - Respect the vocabulary, tone, and philosophy loaded from the database
 - Apply the ego/persona model according to `CLAUDE.md`
+- An active persona signs `◇ persona-name` on its own line, the rule `AGENTS.md` states; the delivered line names the persona to sign. No signature when the ego answers alone.
 
 ## 3. Record Response
 

package/ts/src/builder/commands.ts

@@ -205,11 +205,12 @@ function rejectUnknownMethod(method: string): CommandResult | null {
  *
  * Decision C (CR008): when no session is named, `build load` still stamps a
  * GUESSED session, so each window's footer shows its own mode. A named session's
- * stamp may therefore have been written by another window's load. That cannot
- * bind today, because no runtime names its session. Before one does, stamps must
- * record whether they were written under the name, and this function must bind
- * only those (option B). `namedSessionPrecondition.test.ts` fails the day a
- * runtime starts naming its session.
+ * stamp may therefore have been written by another window's load. Since
+ * CV9.DS8.US5 runtimes name their sessions (Pi sets `MIRROR_SESSION_ID`; the
+ * Claude-family readers came with US4), so option B holds here: a stamp binds
+ * only when it records that it was written under the name
+ * (`OperatingModeState.namedSession`). A guessed stamp on a named session is
+ * the footer's business, not a journey.
  */
 function namedSessionBuilderJourney(
   context: BuilderCommandContext,
@@ -218,7 +219,9 @@ function namedSessionBuilderJourney(
   const named = resolveNamedRuntimeSessionId(sessionId, context.environmentSessionId ?? null);
   if (!named || !getRuntimeSession(context.db, named)?.active) return null;
   const state = getSessionOperatingMode(context.db, named);
-  return state?.mode === "Builder Mode" && state.journey ? state.journey : null;
+  return state?.mode === "Builder Mode" && state.journey && state.namedSession === true
+    ? state.journey
+    : null;
 }
 
 /**

package/ts/src/builder/load.ts

@@ -33,7 +33,7 @@ import { getIdentityContent } from "#identity/identityRead.ts";
 import { getProjectPath } from "#journey/journeyStatus.ts";
 import { loadMirrorContext } from "#mirror/context.ts";
 import { persistStickyDefaults } from "#mirror/orchestration.ts";
-import { resolveRuntimeSessionId } from "#mirror/runtimeSession.ts";
+import { resolveNamedRuntimeSessionId, resolveRuntimeSessionId } from "#mirror/runtimeSession.ts";
 import { activateOperatingMode } from "#mode/operatingMode.ts";
 import { ProviderConfigError } from "#providers/config.ts";
 import type { EmbeddingProvider } from "#providers/embedding.ts";
@@ -286,6 +286,13 @@ export async function runBuildLoad(
   }
 
   persistStickyDefaults(db, "engineer", slug, deps.nowIso());
+  // A named session's stamp records that it was (CR008 option B, CV9.DS8.US5):
+  // with no name, the guess still lands on some window's row so its footer
+  // shows the mode, and a lifecycle command must not bind from that.
+  const namedSessionId = resolveNamedRuntimeSessionId(
+    options.sessionId ?? null,
+    options.environmentSessionId ?? null,
+  );
   const resolvedSessionId = resolveRuntimeSessionId(
     db,
     options.sessionId ?? null,
@@ -293,7 +300,12 @@ export async function runBuildLoad(
   );
   activateOperatingMode(
     db,
-    { mode: "Builder Mode", journey: slug, sessionId: resolvedSessionId },
+    {
+      mode: "Builder Mode",
+      journey: slug,
+      sessionId: resolvedSessionId,
+      named: namedSessionId !== null && namedSessionId === resolvedSessionId,
+    },
     deps.nowIso(),
   );
   await deps.switchConversation?.(slug, resolvedSessionId);

package/ts/src/conversation/logger.ts

@@ -173,18 +173,24 @@ export function getOrCreateSessionConversation(
       options.persona ?? null,
       options.journey ?? null,
     );
-    // Mirrors the service's conflict clause exactly: it does NOT touch
-    // mirror_active, hook_injected, started_at, or metadata on update.
+    // Mirrors the service's conflict clause: it does NOT touch mirror_active,
+    // started_at, or metadata on update. Since CV9.DS8.US5 it
+    // does not erase a persona or journey either when the caller names none:
+    // on the first prompt of a session the doorman has already routed the
+    // explicit turn and written both to this row, and the prompt logger, which
+    // runs after it, wrote NULL over them -- the mirror lost its voice until a
+    // later prompt scored a persona again. A caller that names a persona or
+    // journey still sets it.
     db.prepare(
       `INSERT INTO runtime_sessions
          (session_id, conversation_id, interface, mirror_active, persona, journey,
-          hook_injected, active, started_at, updated_at, closed_at, metadata)
-       VALUES (?, ?, ?, 0, ?, ?, 0, 1, ?, ?, NULL, NULL)
+          active, started_at, updated_at, closed_at, metadata)
+       VALUES (?, ?, ?, 0, ?, ?, 1, ?, ?, NULL, NULL)
        ON CONFLICT(session_id) DO UPDATE SET
          conversation_id = excluded.conversation_id,
          interface = excluded.interface,
-         persona = excluded.persona,
-         journey = excluded.journey,
+         persona = COALESCE(excluded.persona, runtime_sessions.persona),
+         journey = COALESCE(excluded.journey, runtime_sessions.journey),
          active = 1,
          closed_at = NULL,
          updated_at = excluded.updated_at`,

package/ts/src/db/migrateOnOpen.ts

@@ -132,7 +132,7 @@ function appliedMigrationIds(dbPath: string, options: OpenOptions): Set<string>
  * No split any more. Until CV22.DS10.TS5 this separated the TS-authored tail
  * from Python-authored ids and declined the whole thing whenever a Python one
  * was pending -- correct while Python could still apply them. TypeScript
- * carries all seventeen and is the only engine left, so every pending known
+ * carries all of them and is the only engine left, so every pending known
  * migration is simply pending.
  */
 function pendingMigrations(applied: Set<string>): string[] {

package/ts/src/db/migrations.ts

@@ -514,6 +514,21 @@ function migrateJourneyParentColumn(db: WritableDatabase): void {
   );
 }
 
+/**
+ * 018 (CV9.DS8.US5) -- `runtime_sessions.hook_injected` goes. It was the
+ * Claude-family inject hook's once-per-session flag (CV21.DS2); US4 handed the
+ * hook to the one doorman and retired its last reader, and the four writers
+ * that still filled it were carried as one debt item, paid here with the
+ * column. Guarded on the column's presence: a fresh database's `createSchema`
+ * no longer has it, and a re-run finds nothing to drop. `DROP COLUMN` is
+ * SQLite 3.35; the engine ships 3.54.
+ */
+function migrateDropHookInjected(db: WritableDatabase): void {
+  if (!tableExists(db, "runtime_sessions")) return;
+  if (!tableColumns(db, "runtime_sessions").has("hook_injected")) return;
+  db.exec("ALTER TABLE runtime_sessions DROP COLUMN hook_injected");
+}
+
 export type MigrationApply = (db: WritableDatabase) => void;
 
 export const MIGRATIONS: readonly (readonly [string, MigrationApply])[] = [
@@ -534,6 +549,7 @@ export const MIGRATIONS: readonly (readonly [string, MigrationApply])[] = [
   ["015_create_builder_workbench", migrateCreateBuilderWorkbench],
   ["016_builder_workbench_display_codes", migrateBuilderWorkbenchDisplayCodes],
   ["017_journey_parent_column", migrateJourneyParentColumn],
+  ["018_drop_hook_injected", migrateDropHookInjected],
 ];
 
 /**

package/ts/src/db/schema.ts

@@ -84,7 +84,6 @@ CREATE TABLE IF NOT EXISTS runtime_sessions (
     mirror_active INTEGER NOT NULL DEFAULT 0,
     persona TEXT,
     journey TEXT,
-    hook_injected INTEGER NOT NULL DEFAULT 0,
     active INTEGER NOT NULL DEFAULT 1,
     started_at TEXT NOT NULL,
     updated_at TEXT NOT NULL,

package/ts/src/db/schemaInventorySnapshot.ts

@@ -1925,13 +1925,6 @@ export const SCHEMA_INVENTORY_SNAPSHOT: SchemaInventory = {
           "pk": 0,
           "type": "TEXT"
         },
-        {
-          "dflt_value": "0",
-          "name": "hook_injected",
-          "notnull": 1,
-          "pk": 0,
-          "type": "INTEGER"
-        },
         {
           "dflt_value": "1",
           "name": "active",
@@ -1979,7 +1972,7 @@ export const SCHEMA_INVENTORY_SNAPSHOT: SchemaInventory = {
         }
       ],
       "sql":
-        "CREATE TABLE runtime_sessions ( session_id TEXT PRIMARY KEY, conversation_id TEXT REFERENCES conversations(id), interface TEXT, mirror_active INTEGER NOT NULL DEFAULT 0, persona TEXT, journey TEXT, hook_injected INTEGER NOT NULL DEFAULT 0, active INTEGER NOT NULL DEFAULT 1, started_at TEXT NOT NULL, updated_at TEXT NOT NULL, closed_at TEXT, metadata TEXT)"
+        "CREATE TABLE runtime_sessions ( session_id TEXT PRIMARY KEY, conversation_id TEXT REFERENCES conversations(id), interface TEXT, mirror_active INTEGER NOT NULL DEFAULT 0, persona TEXT, journey TEXT, active INTEGER NOT NULL DEFAULT 1, started_at TEXT NOT NULL, updated_at TEXT NOT NULL, closed_at TEXT, metadata TEXT)"
     },
     "tasks": {
       "columns": [

package/ts/src/db/schemaState.ts

@@ -47,6 +47,8 @@ export const KNOWN_MIGRATION_IDS: readonly string[] = [
   "016_builder_workbench_display_codes",
   // TS-authored, no Python counterpart (CV22.DS6.US2 — first TS ⊋ Python migration).
   "017_journey_parent_column",
+  // CV9.DS8.US5: the inject hook's once-per-session flag, without a reader since US4.
+  "018_drop_hook_injected",
 ];
 
 /**

package/ts/src/db/schemaTsDivergence.ts

@@ -17,6 +17,15 @@ const TS_ONLY_COLUMNS: Record<string, ColumnInventory[]> = {
   identity: [{ name: "parent_journey", type: "TEXT", notnull: 0, dflt_value: null, pk: 0 }],
 };
 
+/**
+ * Columns the Python snapshot has that TS has dropped (CV9.DS8.US5, migration
+ * 018): `runtime_sessions.hook_injected`, the inject hook's once-per-session
+ * flag, without a reader since CV9.DS8.US4.
+ */
+const TS_REMOVED_COLUMNS: Record<string, string[]> = {
+  runtime_sessions: ["hook_injected"],
+};
+
 /** Indexes TS creates that the Python snapshot does not have. */
 const TS_ONLY_INDEXES: Record<string, { table: string; unique: number; columns: string[] }> = {
   idx_identity_parent_journey: { table: "identity", unique: 0, columns: ["parent_journey"] },
@@ -46,21 +55,33 @@ export function diffTsInventoryAgainstSnapshot(
     const actualTable = actual.tables[name];
     if (!actualTable) continue;
     const additions = TS_ONLY_COLUMNS[name] ?? [];
-    const expectedColumns = [...snapshot.tables[name].columns, ...additions];
+    const removals = TS_REMOVED_COLUMNS[name] ?? [];
+    const expectedColumns = [
+      ...snapshot.tables[name].columns.filter((column) => !removals.includes(column.name)),
+      ...additions,
+    ];
     if (!isDeepStrictEqual(actualTable.columns, expectedColumns)) {
-      problems.push(`tables[${name}].columns differ from snapshot + enumerated TS-only additions`);
+      problems.push(
+        `tables[${name}].columns differ from snapshot + enumerated TS-only additions and removals`,
+      );
     }
     if (!isDeepStrictEqual(actualTable.foreign_keys, snapshot.tables[name].foreign_keys)) {
       problems.push(`tables[${name}].foreign_keys differ from snapshot`);
     }
-    if (additions.length > 0) {
+    if (additions.length > 0 || removals.length > 0) {
       // The raw CREATE TABLE text diverges by exactly these columns; assert each
-      // added column name is present rather than reproduce SQLite's stored text.
+      // added column name is present and each removed one absent, rather than
+      // reproduce SQLite's stored text.
       for (const column of additions) {
         if (!(actualTable.sql ?? "").includes(column.name)) {
           problems.push(`tables[${name}].sql is missing TS-only column ${column.name}`);
         }
       }
+      for (const column of removals) {
+        if ((actualTable.sql ?? "").includes(column)) {
+          problems.push(`tables[${name}].sql still carries the dropped column ${column}`);
+        }
+      }
     } else if (!isDeepStrictEqual(actualTable.sql, snapshot.tables[name].sql)) {
       problems.push(`tables[${name}].sql differs from snapshot`);
     }

package/ts/src/frontDoor/cli.ts

@@ -52,6 +52,7 @@ import { setIdentity } from "#identity/setIdentity.ts";
 import { IdentityRootExistsError, initUserHome, TemplatesNotFoundError } from "#init/init.ts";
 import { JOURNEY_PATH_LAYER } from "#journey/journeyStatus.ts";
 import { JourneyNotFoundError } from "#journey/journeyWrite.ts";
+import { environmentSessionId } from "#mirror/runtimeSession.ts";
 import {
   CallOutcomeTally,
   formatCallOutcome,
@@ -116,9 +117,11 @@ import {
 import { applyJourneySetPath } from "./journeyWriteRoute.ts";
 import { openLiveWriteDatabase } from "./liveBackup.ts";
 import {
+  isMirrorDoorman,
   isMirrorWrite,
   isModeWrite,
   mirrorDeactivateMissingSession,
+  runMirrorDoormanRoute,
   runMirrorRead,
   runMirrorWriteRoute,
   runModeRead,
@@ -1477,7 +1480,10 @@ function runShadowWrite(argv: readonly string[]): number | Promise<number> {
   return runShadowScanWrite(argv); // "scan"
 }
 
-function withMirrorReadDb(argv: readonly string[], read: (db: Database) => number): number {
+function withMirrorReadDb<T = number>(
+  argv: readonly string[],
+  read: (db: Database) => T,
+): T | number {
   const dbPath = resolveDbPathForCli(argv.slice(1));
   if (dbPath === null) return 2;
   ensureDatabaseReadyForCli(dbPath, argv[0] ?? null);
@@ -1539,6 +1545,35 @@ function runModeWrite(argv: readonly string[]): Promise<number> {
   return withMirrorWriteDb(argv, (db) => runModeWriteRoute(db, argv));
 }
 
+/**
+ * `mirror doorman` (CV9.DS8.TS2): decide on a read-only handle, write behind
+ * the pre-write snapshot only for a turn that delivers. The memory scores a
+ * delta turn ranks go to the front-door log as numbers -- content-free -- the
+ * hybrid and the semantic the threshold reads (US5), every ranked memory's,
+ * so the threshold is read against measurement.
+ */
+function runMirrorDoorman(argv: readonly string[]): Promise<number> {
+  const reporter = outcomeReporter(argv, "reception");
+  const logPath = resolveLogPath(argv);
+  return runMirrorDoormanRoute(argv, {
+    withReadOnlyDatabase: (read) => withMirrorReadDb(argv, read),
+    withLiveWriteDatabase: (write) => withMirrorWriteDb(argv, write),
+    onReceptionOutcome: reporter.onOutcome,
+    onMemoryScores: (scores) =>
+      logFrontDoor(logPath, {
+        command: "mirror",
+        route: "ts",
+        exitCode: 0,
+        detail:
+          `doorman memory_scores=${scores.map((s) => s.score.toFixed(3)).join(",")}` +
+          ` memory_semantic=${scores.map((s) => s.semantic.toFixed(3)).join(",")}`,
+      }),
+  }).then((exitCode) => {
+    if (reporter.calls > 0) reporter.logSummary();
+    return exitCode;
+  });
+}
+
 function runSoulWrite(argv: readonly string[]): Promise<number> {
   return withMirrorWriteDb(argv, (db) => runSoulRoute(db, argv));
 }
@@ -1739,7 +1774,11 @@ async function dispatchTs(argv: readonly string[]): Promise<number | DispatchOut
       createLoadRuntime: (db, dbPath, ignoreProductionRole) =>
         createBuildLoadRuntime({ db, dbPath, ignoreProductionRole }),
       nowIso,
-      environmentSessionId: process.env.MIRROR_SESSION_ID ?? null,
+      // The session the harness named -- MIRROR_SESSION_ID, else Claude Code's or
+      // Codex's own -- the same reader the mirror route uses (CV9.DS8.US4: read
+      // MIRROR_SESSION_ID alone, a Builder switch on Claude Code stamped a guessed
+      // session and the doorman never saw it).
+      environmentSessionId: environmentSessionId(process.env),
     });
   }
   if (isInit(argv)) return runInit(argv);
@@ -1759,6 +1798,7 @@ async function dispatchTs(argv: readonly string[]): Promise<number | DispatchOut
   if (argv[0] === "descriptor" && argv[1] === "generate") return runDescriptorContentRoute(argv);
   if (isConsolidateSubcommandWrite(argv)) return runConsolidateWrite(argv);
   if (isShadowSubcommandWrite(argv)) return runShadowWrite(argv);
+  if (isMirrorDoorman(argv)) return runMirrorDoorman(argv);
   if (isMirrorWrite(argv)) return runMirrorWrite(argv);
   if (isModeWrite(argv)) return runModeWrite(argv);
   // CV22.DS7.US6: the Soul ritual; `routing.ts` allowlists its subcommands by

package/ts/src/frontDoor/exploreRoute.ts

@@ -61,7 +61,7 @@ import { getIdentityContent } from "#identity/identityRead.ts";
 import { getProjectPath } from "#journey/journeyStatus.ts";
 import { loadMirrorContext } from "#mirror/context.ts";
 import { persistStickyDefaults } from "#mirror/orchestration.ts";
-import { resolveRuntimeSessionId } from "#mirror/runtimeSession.ts";
+import { environmentSessionId, resolveRuntimeSessionId } from "#mirror/runtimeSession.ts";
 import { activateOperatingMode, deactivateOperatingMode } from "#mode/operatingMode.ts";
 import { newId, nowIso } from "#util/pyGenerators.ts";
 import { optionValue, stripOptionWithValue } from "./args.ts";
@@ -430,7 +430,7 @@ async function runPromote(
   // `--session-id`, which its promote parser does not even accept.
   const result = await runBuildLoad(
     db,
-    { slug, environmentSessionId: process.env.MIRROR_SESSION_ID ?? null },
+    { slug, environmentSessionId: environmentSessionId(process.env) },
     runtime.deps,
   );
   process.stderr.write(result.stderr);

package/ts/src/frontDoor/mirrorModeRoute.ts

@@ -1,12 +1,22 @@
 import { existsSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import type { Database, WritableDatabase } from "#db/database.ts";
+import {
+  type DoormanDecision,
+  decideDoorman,
+  doormanPersonas,
+  forgetDoormanDelivery,
+  type MemoryScore,
+  readDoormanSessionState,
+  runDoorman,
+} from "#mirror/doorman.ts";
 import {
   deactivateMirrorState,
   listActiveMirrorJourneys,
   logMirrorResponse,
   runMirrorLoad,
 } from "#mirror/orchestration.ts";
+import { environmentSessionId, resolveNamedRuntimeSessionId } from "#mirror/runtimeSession.ts";
 import {
   activateOperatingMode,
   deactivateOperatingMode,
@@ -16,7 +26,7 @@ import {
 } from "#mode/operatingMode.ts";
 import type { OnProviderCallOutcome } from "#observability/callOutcome.ts";
 import { resolveFamilyProviders } from "#providers/familyProviders.ts";
-import { MIRROR_QUERY_TRANSPORT } from "#providers/transport.ts";
+import { MIRROR_QUERY_TRANSPORT, mirrorQueryTransportFor } from "#providers/transport.ts";
 import { newId, nowIso } from "#util/pyGenerators.ts";
 import { hasOption, optionValue, stripOptionWithValue } from "./args.ts";
 
@@ -28,6 +38,8 @@ import { hasOption, optionValue, stripOptionWithValue } from "./args.ts";
  */
 export type MirrorRouteEnvironment = {
   MIRROR_SESSION_ID?: string;
+  CLAUDE_CODE_SESSION_ID?: string;
+  CODEX_SESSION_ID?: string;
   MEMORY_RECEPTION?: string;
   MIRROR_TS_MIRROR_LLM_REPLAY?: string;
   MIRROR_TS_MIRROR_EMBEDDING_REPLAY?: string;
@@ -37,14 +49,119 @@ export function isMirrorWrite(argv: readonly string[]): boolean {
   return argv[0] === "mirror" && ["load", "deactivate", "log"].includes(argv[1] ?? "");
 }
 
+/**
+ * `mirror doorman` is a write surface with its own handle discipline
+ * (CV9.DS8.TS2): it is not `isMirrorWrite`, because the front door's shared
+ * write seam opens the live-write path -- a database snapshot -- before any
+ * route runs, and a doorman turn that owes nothing must never pay that.
+ */
+export function isMirrorDoorman(argv: readonly string[]): boolean {
+  return argv[0] === "mirror" && argv[1] === "doorman";
+}
+
+export interface DoormanRouteDeps {
+  /** The database, read-only: enough to decide. */
+  withReadOnlyDatabase: (read: (db: Database) => DoormanDecision) => DoormanDecision | number;
+  /** The database behind the pre-write snapshot: only for a turn that delivers. */
+  withLiveWriteDatabase: (
+    write: (db: WritableDatabase, dbPath: string) => Promise<number>,
+  ) => Promise<number>;
+  onReceptionOutcome?: OnProviderCallOutcome;
+  /** Content-free: the turn's memory scores, hybrid and semantic, for the front-door log. */
+  onMemoryScores?: (scores: readonly MemoryScore[]) => void;
+}
+
+/**
+ * `mirror doorman --prompt "<text>" [--session-id <id>]`: the one doorman as a
+ * command, for the Pi extension (US5). Prints the block or nothing; exit 0.
+ * `mirror doorman --forget [--session-id <id>]`: the runtime compacted the
+ * transcript; the named session's next ordinary turn is full again (US5's
+ * debt). Nothing printed; an unnamed session is nothing to mark.
+ *
+ * Two steps on purpose. The decision is read from a read-only handle; the
+ * live-write handle -- `VACUUM INTO` first, 95 ms measured on a 53 MB database
+ * -- opens only when the decision is `full` or `delta`. The ordinary turn
+ * outside Mirror Mode costs a read and nothing else, as the inject hook's does.
+ */
+export async function runMirrorDoormanRoute(
+  argv: readonly string[],
+  deps: DoormanRouteDeps,
+  env: MirrorRouteEnvironment = process.env,
+): Promise<number> {
+  const args = argv.slice(2);
+  const sessionId = resolveNamedRuntimeSessionId(
+    optionValue(args, "--session-id") ?? null,
+    environmentSessionId(env),
+  );
+  if (hasOption(args, "--forget")) {
+    if (!sessionId) return 0;
+    return deps.withLiveWriteDatabase(async (db) => {
+      forgetDoormanDelivery(db, sessionId, nowIso());
+      return 0;
+    });
+  }
+  const prompt = optionValue(args, "--prompt");
+  if (prompt === null || prompt === undefined) {
+    console.error("mirror doorman requires --prompt");
+    return 2;
+  }
+  const decided = deps.withReadOnlyDatabase((db) =>
+    decideDoorman({
+      prompt,
+      state: readDoormanSessionState(db, sessionId),
+      personas: doormanPersonas(db),
+    }),
+  );
+  if (typeof decided === "number") return decided;
+  if (decided.kind === "nothing") return 0;
+
+  // Providers only now: a turn that delivers may embed (delta) or route
+  // (full); the turn above resolved none, let alone a key.
+  const receptionEnabled = env.MEMORY_RECEPTION !== "0";
+  const family = await resolveFamilyProviders(env, mirrorQueryTransportFor(env));
+  return deps.withLiveWriteDatabase(async (db, dbPath) => {
+    const mirrorHome = dirname(dbPath);
+    const rendered = await runDoorman(db, decided, {
+      identity: basename(mirrorHome),
+      databasePath: dbPath,
+      mirrorHome,
+      user: basename(mirrorHome),
+      sessionId,
+      receptionEnabled,
+      onReceptionOutcome: deps.onReceptionOutcome,
+      llmProvider: receptionEnabled ? family.llm : undefined,
+      embeddingProvider: family.embedding,
+      onMemoryScores: deps.onMemoryScores,
+      newId,
+      nowIso,
+    });
+    process.stdout.write(rendered.stdout);
+    process.stderr.write(rendered.stderr);
+    return 0;
+  });
+}
+
 export function isModeWrite(argv: readonly string[]): boolean {
   if (argv[0] !== "mode") return false;
   const args = modePositionals(argv.slice(1));
   return args[0] === "activate" || args[0] === "deactivate";
 }
 
-export function mirrorDeactivateMissingSession(argv: readonly string[]): boolean {
-  return argv[0] === "mirror" && argv[1] === "deactivate" && !optionValue(argv, "--session-id");
+/**
+ * `mirror deactivate` with nobody naming a session: `--session-id` absent AND
+ * no harness variable (CV9.DS8.US5 -- until then `--session-id` alone, so
+ * `/mm-new` on a Pi whose extension had named the session still refused).
+ */
+export function mirrorDeactivateMissingSession(
+  argv: readonly string[],
+  env: MirrorRouteEnvironment = process.env,
+): boolean {
+  return (
+    argv[0] === "mirror" &&
+    argv[1] === "deactivate" &&
+    !optionValue(argv, "--session-id") &&
+    environmentSessionId(env) === null
+  );
 }
 
 export function runMirrorRead(db: Database, args: readonly string[]): number {
@@ -70,7 +187,10 @@ export async function runMirrorWriteRoute(
   const args = argv.slice(2);
   const sessionId = optionValue(args, "--session-id");
   if (sub === "deactivate") {
-    deactivateMirrorState(db, sessionId as string, nowIso());
+    // The session the caller named, else the harness's (TS2's reader): the
+    // unnamed case was refused before this route ran.
+    const named = resolveNamedRuntimeSessionId(sessionId ?? null, environmentSessionId(env));
+    deactivateMirrorState(db, named as string, nowIso());
     console.error("Mirror Mode deactivated.");
     return 0;
   }
@@ -112,7 +232,11 @@ export async function runMirrorWriteRoute(
     org: hasOption(args, "--org"),
     contextOnly: hasOption(args, "--context-only"),
     sessionId,
-    environmentSessionId: env.MIRROR_SESSION_ID ?? null,
+    // The harness's variable, whichever runtime set it (CV9.DS8.TS2): the
+    // skill's own load on Claude Code or Codex names the session the hooks
+    // write. `mirror log` keeps reading `MIRROR_SESSION_ID` alone: its
+    // fallback is a guess, and widening that is a CR008 question.
+    environmentSessionId: environmentSessionId(env),
     receptionEnabled,
     onReceptionOutcome: options.onReceptionOutcome,
     llmProvider: receptionEnabled ? family?.llm : undefined,