mirror-mind 0.36.2 → 0.37.0

package/docs/releases/v0.36.3.md

@@ -0,0 +1,142 @@
+---
+digest: >
+  v0.36.3 is a patch release of one Change Request, CR160, with CR159's docs.
+  On Pi, a skill picked from the command menu, or typed as `/skill:<name>`,
+  reached Mirror after Pi had expanded it into the skill's whole body, and
+  Mirror stored that body as something the person said. Pi's turns now go
+  through the rule every other runtime has: a skill invocation and its reply
+  are not recorded, and a question asked with `/mm-mirror` is recorded as the
+  question. `mirror conversations skill-turns` repairs what earlier versions
+  stored, only on `--apply` and only after a verified backup. No migration.
+---
+
+# v0.36.3 — A Skill You Invoke Is Not Something You Said
+
+**Date:** 2026-10-23
+
+## Highlights
+
+- **On Pi, a skill you invoke is not recorded as your words**
+  ([CR160](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr160-a-pi-skill-invoked-as-skill-is-logged-as-its-body.md)),
+  whether you pick it from the menu or type it, and neither is its answer. A question
+  you ask with `/mm-mirror` is recorded as the question, with one reply. A prompt has
+  one reply row.
+- **`mirror conversations skill-turns` repairs what an earlier version stored.** It
+  shows, by skill, what it would change, and each conversation it would delete because
+  no user turn would be left; on `--apply` it takes a dated backup, verifies it, and
+  repairs in one transaction. Mirror questions keep their question; other skill turns
+  go; a conversation left with no user turn goes, its memories kept, unlinked; a title
+  that came from a skill's body is rebuilt from the first remaining user turn.
+- **Pi joins the rule the other runtimes already had.** Mirror's Pi extension sends
+  what you typed, read before Pi expands a skill, to the same prompt and reply handlers
+  Claude Code, Codex, and Grok Build use.
+- **The docs say how Pi invokes a skill**
+  ([CR159](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr159-pi-skills-are-spelled-by-their-bare-name-and-step-7a-lost-two-dashes.md)):
+  typing `/mm-` opens Pi's command menu, which lists each skill as `skill:mm-<skill>`;
+  pick it there.
+
+## Where We Started
+
+Writing down how extensions reach each runtime (CV21.DS5.TS4), the docs called Pi's
+skill commands `/mm-<skill>`, as if Pi registered them. CR159 measured Pi 1.4.0: Pi
+registers each skill as `/skill:<name>`, its menu offers it under that name, and it
+expands the skill into its whole body before any extension sees the prompt. Mirror's
+Pi extension skipped a prompt only when it opened with `/`. An expanded skill opens
+with `<skill`, so it was stored as the person's turn. On the maintainer's two homes,
+225 and 185 such turns, from April to October: conversations titled
+`<skill name="mm-build" location=…`, and extraction reading a skill's instructions as
+something the person said.
+
+## What Changed
+
+**One rule, in one place.** The core already held the rule: what you say to the mirror
+is remembered, a skill you invoke is not. Claude Code, Codex, and Grok Build reach it
+through the hooks' prompt and reply handlers; Pi's extension kept a check of its own,
+and Pi's expansion slipped past it. Rather than teach the extension Pi's wrapper, Pi
+now uses the same handlers: the extension reads what you typed from Pi's documented
+`input` event, gives each run a turn id, and sends the prompt's whole reply once, when
+Pi settles. The payload travels as an argument, because Pi's extension API cannot
+write a process's input; Pi's prompts already travelled that way.
+
+**Measured before and after.** A route committed with the Change Request runs the same
+four prompts on Pi 1.4.0 against the tree before the fix and after it. Before, a skill
+picked from the menu or typed as `/skill:` was stored as the person's turn, a question
+typed with `/mm-mirror` was lost, and every skill's reply was kept. After, a skill
+invocation leaves nothing, and a Mirror question leaves the question and one reply.
+
+**A repair, careful by construction.** Shaped as v0.36.2's `remove`: a dry run first,
+with the exact command that applies it; on `--apply`, the set decided read-only, then a
+dated archive, verified, then one transaction that decides again and refuses if
+anything moved. It matches only Pi's whole skill block, and the one the old logger cut
+at its 50,000-character limit, and only in Pi conversations: a person may paste
+`<skill name=` anywhere. On copies of the maintainer's two homes it kept 20 Mirror
+questions in each, removed 205 and 165 skill turns, deleted 31 and 24 conversations
+left with no user turn, and a second dry run found nothing.
+
+**A review before any code.** Five personas reviewed the plan. The engineer found that
+the hooks already had the rule and a tested handler for each side of a turn, so Pi
+joined them rather than the core learning a second copy. The devops engineer found that
+a running Pi session keeps the extension it loaded, so the old logging commands stay
+for one more release, and the repair is run after every session has restarted.
+
+### What you will notice
+
+- In Pi, a skill you pick or type no longer appears in your conversations as something
+  you said, and neither does its answer.
+- A question you ask with `/mm-mirror` is recorded as the question; typed in full, it
+  used to be lost.
+- A new command, `mirror conversations skill-turns`.
+
+## Upgrading
+
+```bash
+mirror runtime update          # or: npm install -g mirror-mind
+```
+
+There is no database migration, and no runtime wiring changes. Then, for every home
+you use with Pi:
+
+1. Restart every Pi session on that home. A session keeps the extension it loaded and,
+   until it restarts, stores a skill's body as before.
+2. See what the repair would change, then repair:
+
+   ```bash
+   mirror conversations skill-turns
+   mirror conversations skill-turns --apply
+   ```
+
+The dry run lists each conversation it would delete, with its message count. Running it
+again later repairs anything a session that had not restarted stored meanwhile. The
+dated backup it takes, and the pre-write backup, keep copies until they age out (30
+days for an archive).
+
+## Conscious Exclusions
+
+- **Past replies to skipped turns.** A reply to a skill typed as `/mm-<skill>` was
+  recorded before this release, and cannot be told from a reply to an ordinary turn,
+  since one prompt can record more than one reply. Those replies stay.
+- **Summaries, their embeddings, and memories** of affected conversations stay: they
+  describe a session in which a skill was invoked.
+- **Pi's own session files** are not read or touched.
+- **Older weak titles.** Startup maintenance improves only the titles of the most
+  recently ended conversations; the rest wait for
+  [CR162](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr162-maintenance-retitles-only-the-latest-conversations.md).
+- **A tool for models.** No MCP tool and no skill runs the repair: a person does.
+
+## What We Learned
+
+A rule kept in two places drifts at the edges. The hooks' rule and the Pi extension's
+check agreed for months, until what Pi hands an extension stopped opening with `/`.
+The second copy kept the letter of the rule after its input changed shape; one copy,
+reached by every runtime, cannot.
+
+The data that says a thing is wrong is often already there. Four hundred rows titled
+`<skill name=…` sat in two homes for six months, read by every title, summary, and
+extraction pass, and named by none of them.
+
+## Next Horizon
+
+CV21.DS11, the contract and docs refresh with the parity matrix, then CV21's own
+release. Captured and open: CR161, the Pi extension's types and the check it lacks;
+CR162, the titles maintenance never reaches. `log-user` and `log-assistant`, kept here
+for sessions that have not restarted, retire in the release after this one.

package/docs/releases/v0.37.0.md

@@ -0,0 +1,221 @@
+---
+digest: >
+  v0.37.0 is a minor release closing CV9.DS8 and, with CV21.DS11, CV21. On Pi,
+  Claude Code, Codex, and Antigravity, Mirror's context now reaches the model before
+  it answers through one decision in the core, the doorman: all of it on the turn
+  Mirror Mode starts, then on every turn the persona the question calls for and the
+  memories relevant to it, so the mirror keeps its voice and its `◇ persona-name`
+  signature across a conversation. Pi, the recommended harness, moves from L3 to L4,
+  measured live. CV21 closes with one parity matrix in the runtime interface
+  contract, each row sourced to the measurement behind it. Migration 018 drops a
+  column nothing reads any more, and Mirror applies it on its own.
+---
+
+# v0.37.0 — The Mirror Stays in the Conversation
+
+**Date:** 2026-10-25
+
+## Highlights
+
+- One doorman decides what Mirror puts before the model on each turn, on Pi, Claude
+  Code, Codex, and Antigravity: the full context on the turn Mirror Mode starts, then
+  the persona each question calls for and the memories relevant to it, and nothing
+  when Mirror Mode is off.
+- Pi reaches L4. A Pi conversation keeps the mirror's voice after the first answer,
+  moves to another persona when the topic moves, and signs every answer. Measured live
+  on Pi 1.4.0.
+- An explicit Mirror turn loads once. The `mm-mirror` skill no longer loads a second
+  time when the runtime already delivered the context.
+- One signature rule, `◇ persona-name`, in `AGENTS.md`, the skill, and the core's
+  banner; `✦ Persona:` is gone.
+- Measured live before it was written down: Claude Code 2.1.310 and Codex 0.164.0
+  (16 of 16 checks), Pi 1.4.0 (three walks), agy 1.4.7.
+- CV21 closes: the runtime interface contract holds one parity matrix, each row
+  sourced to a measurement, and a test holds README, Getting Started, REFERENCE, and
+  the architecture to it.
+- Migration 018 drops `runtime_sessions.hook_injected`; Mirror backs up and migrates
+  each home on its own.
+- Codex, Antigravity, and Grok Build keep their own copy of the plugin: bring it level
+  after updating; `mirror runtime diagnose` names the command.
+
+## Where We Started
+
+Mirror Mode is the product. Mirror builds a folder from the database (the identity
+layers, a persona routed from the question, the journey, the shadow patterns, and the
+memories and attachments relevant to it) and the model answers as the mirror with that
+folder open. What decides the experience is whether the folder reaches the model, and
+when.
+
+Until this release, three runtimes gave three answers. The Claude-family inject hook
+delivered the folder on an explicit Mirror turn and once on the next ordinary turn,
+then never again. Antigravity's hook delivered the whole folder on every turn, but agy
+1.4.2's hooks carried no prompt, so nothing could be routed from the question. Pi had
+no doorman at all. Measured on Pi 1.4.0 on 2026-10-24
+([CR165](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr165-pi-puts-no-mirror-context-before-the-model.md)),
+the model loaded the folder once, through the skill, and answered every follow-up from
+that one load: no reload, no new persona when the topic changed, no signature after the
+first reply. And wherever a doorman did exist, the skill's own rule, "never answer
+without loading first", made the explicit turn load twice.
+
+CV21.DS11, writing the parity matrix, made the line explicit: at L4 the runtime puts
+Mirror's context before the model; at L3 the model loads it itself. By that line Pi, the
+harness Getting Started recommends, was L3.
+
+## What Changed
+
+### One doorman
+
+[CV9.DS8](../project/roadmap/cv9-mirror-1-0/cv9-ds8-one-doorman-mirror-s-context-before-the-model-on-every-runtime/index.md)
+built one decision in the core, `ts/src/mirror/doorman.ts`. Given a turn's prompt and
+the session's state it answers one of three things:
+
+- **the full folder**, when the prompt opens with the explicit Mirror form in any
+  runtime's spelling (`/mm-mirror …`, `/mm:mirror …`, `$mm-mirror …`, the plugin
+  spellings); the session is marked in Mirror Mode;
+- **a delta**, on an ordinary turn while Mirror Mode is on: the section of a persona the
+  question newly calls for, which becomes the session's; up to five memories scoring at
+  least 0.4 on the semantic score that the conversation has not been given yet; and the
+  attachments scoring above 0.4. The identity layers are already in the transcript and
+  are not repeated;
+- **nothing**, when Mirror Mode is off, or on a skill command other than the Mirror
+  form, with no model call.
+
+Every block opens with one line the model reads, on every turn Mirror Mode is on: it
+says what was delivered and carries the persona and the signature rule across the
+conversation. The `mm-mirror` skill trusts that line and loads only when the runtime
+did not deliver the context for this turn, so an explicit turn loads once.
+
+"Mirror Mode on" takes two facts: the session's Mirror flag, and its operating mode
+still being Mirror Mode. Switching to Builder, Explorer, or Soul Mode ends the deltas,
+and `/mm-new` ends Mirror Mode; on Pi it now does, because the session is named. When
+the model answers a personal question as the mirror on its own, its load names the
+session from the runtime's environment (`MIRROR_SESSION_ID`, `CLAUDE_CODE_SESSION_ID`,
+`CODEX_SESSION_ID`), so the doorman takes over from the next turn. The doorman never
+guesses a session.
+
+Three choices shaped the policy, recorded in the
+[decisions log](../project/decisions.md#one-doorman-puts-mirrors-context-before-the-model-on-every-runtime):
+memories are refreshed on every turn in Mirror Mode, at one embedding call each, counted
+in the ledger; there is one signature, `◇ persona-name`; and the work was a Delivery
+Story under CV9, measured live on every runtime it touched.
+
+### Each runtime through it
+
+- **Claude Code and Codex.** The inject hook hands each prompt to the doorman and
+  returns its block as the hook's context. Measured live on Claude Code 2.1.310 and
+  Codex 0.164.0: the explicit turn loads once, a follow-up in another domain moves to
+  that persona and signs it, a Builder switch ends the deltas, and a personal question
+  the model answers on its own is followed by doorman turns. 16 of 16.
+- **Pi.** The extension's `before_agent_start` hands each turn to the doorman and
+  carries its block into the run; after Pi compacts a session, the next turn gets the
+  full folder again. Measured live on Pi 1.4.0 in three walks, and Pi's row in the
+  parity matrix moves to L4.
+- **Antigravity.** agy 1.4.7 carries the prompt in every hook payload
+  (`lastUserInput`), so `PreInvocation` hands each turn to the doorman and answers its
+  block as a persistent step; a conversation's first turn gets the full folder.
+  Measured live on agy 1.4.7, at 0.23–1.02 s a turn against agy's 15 s budget. Before
+  agy 1.4.7, the earlier injection stays as it was.
+- **Grok Build** stays at L3. Grok discards the context a hook offers, so Mirror Mode
+  there still comes from the skill.
+
+### What a turn costs
+
+A turn in Mirror Mode writes one `embedding` row in `llm_calls`; the explicit turn
+costs what `mirror load --query` costs; a turn outside Mirror Mode makes no model call.
+Measured with the `mirror mirror doorman` command on a copy of a real home: a delta in
+about 1 s, 142–154 bytes when no memory passes the threshold and up to 8.5 KB when some
+do; the full folder, 33 KB, in 1.33 s; a turn outside Mirror Mode in 0.21 s. No price in
+dollars was measured; the ledger counts the calls.
+
+### CV21 closes
+
+[CV21.DS11](../project/roadmap/cv21-runtime-expansion-ii/cv21-ds11-contract-docs-refresh/index.md)
+put one parity matrix in the
+[runtime interface contract](../product/specs/runtime-interface/index.md#parity-matrix):
+five runtimes, each row sourced to the record that measured it, with version, binary,
+and date. A decision makes it the single authority, and `runtimeParityDocs.test.ts`
+holds README, Getting Started, REFERENCE, and the architecture to it. Measured on Claude
+Code 2.1.310: Mirror's status line is a step a user adds
+(`mirror welcome --status-line --session-id $CLAUDE_CODE_SESSION_ID`), and Claude Code
+reads a project's `AGENTS.md` only when the project has no `CLAUDE.md`. `runtime
+diagnose` and `runtime update` now name an Antigravity copy of the plugin that an
+update left behind. With DS11,
+[CV21, Runtime Expansion II](../project/roadmap/cv21-runtime-expansion-ii/index.md), is
+done: one canonical plugin, five runtimes, each at the level it was measured at.
+
+### Also
+
+- The pages a user reads (the runtime interface contract, Getting Started, REFERENCE,
+  and the architecture) describe the doorman as it was measured (CV9.DS8.TS7).
+- Pi run inside a checkout of this repository, where Pi reaches Mirror's extension
+  twice, ran none of its handlers: no welcome, no logging. It now runs each once.
+- With Pi now naming its session, a Builder journey binds only from a mode stamp written
+  under that session's name, never from a guessed session's (CR008).
+- For contributors: the test suite leaves no temp directories behind, and CI fails if it
+  does (CR163).
+
+## Upgrading
+
+```bash
+mirror runtime update          # or: npm install -g mirror-mind@latest
+```
+
+Migration 018 drops one column nothing reads any more, `runtime_sessions.hook_injected`.
+Mirror applies it on its own: the first time it opens a home after the update, it backs
+the database up and migrates it.
+
+Then, for each runtime you use:
+
+- **Pi:** restart every Pi session. A session keeps the extension it loaded.
+- **Claude Code:** start a new session. The plugin is a link into the package, so there
+  is nothing to re-wire.
+- **Codex, Antigravity, Grok Build:** each keeps its own copy of the plugin, which an
+  update leaves behind, and the `mm-mirror` skill in it changed. Run
+  `mirror runtime diagnose`: it names the one command that brings each copy level
+  (`codex plugin add mirror-mind@mirror-mind` for Codex, `agy plugin install
+  "<pkg>/plugins/mirror-mind"` for Antigravity, an uninstall and an install for Grok
+  Build). Then start a new session.
+- **Antigravity before 1.4.7** keeps the earlier injection; update agy to get the
+  doorman.
+
+## Conscious Exclusions
+
+- **Grok Build stays at L3** (CR143): it discards hook context, so there is nothing for
+  a doorman to deliver through.
+- **The model's own commands on Antigravity cannot name the session yet**
+  ([CR169](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr169-on-agy-the-model-s-own-mirror-commands-cannot-name-the-session.md)):
+  a Mirror load the model starts by itself there is not followed by doorman turns, and a
+  Builder switch the model runs guesses the session. Antigravity's compaction has no
+  hook to bring the folder back (CR173), and an execution agy starts with no new user
+  input would hand the doorman the previous prompt (CR170, unmeasured).
+- **A prompt that is exactly a doorman flag**, such as `--forget`, is read as the flag
+  (CR171).
+- **What the folder contains is unchanged.** The doorman decides when Mirror's context
+  reaches the model and which part of it; how personas are scored and how memories are
+  ranked stay as they were.
+- **No price was measured.** The ledger counts every call; a turn's cost in dollars is
+  still decision 1's estimate.
+- **A checkout plus the installed plugin runs Claude Code's inject hook twice**, paying
+  two embeddings a turn: a contributor-only condition, named in CV9.DS8.US4 and not yet
+  a Change Request.
+
+## What We Learned
+
+- **A level is a measurement.** Pi was claimed at L4 until the parity matrix asked for
+  the record behind every level; asking is what showed the gap this release closes.
+- **Probe before building.** The plan for Antigravity was to read the prompt from the
+  transcript. The probe meant to time that read found agy 1.4.7 carrying the prompt in
+  every payload, and the transcript reader was never written.
+- **Say what "on" means.** "Mirror Mode on" needed two facts, the session's flag and its
+  operating mode. A review found it before a live walk did, which would have been a
+  Builder answer in the mirror's voice.
+- **Threshold the score that measures relevance.** A threshold on the hybrid ranking
+  score would have been a recency gate; the memory threshold reads the semantic score,
+  the one attachments already used.
+
+## Next Horizon
+
+CV9, Mirror Mind 1.0, continues: Boundary Hardening and the rest of Stabilization, with
+CV9.E2.S2, External Extension Runtime Surface Parity, the next pull Ariad recommends.
+The Change Requests DS8 left, CR169 to CR174, wait for their triggers. When CV9's done
+condition is met, the release is `v1.0.0`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mirror-mind",
-  "version": "0.36.2",
+  "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.2",
+  "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.2",
+  "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/commandTurn.ts

@@ -29,8 +29,9 @@
 // One rule for every runtime: a Claude Code user who types `$mm-journeys`,
 // which Claude Code does not understand, is still invoking a skill, and that
 // turn is not conversation either. The rule has one home for every hook that
-// runs in our process (the Claude-family logger, agy's Stop); the Pi
-// extension, a separate process in Pi's file, keeps its own `/` check.
+// runs in our process (the Claude-family logger, agy's Stop), and since CR160
+// for Pi as well: its extension sends what the person typed, read before Pi
+// expands a skill into its body, to the same `user-prompt` and `stop` handlers.
 
 const SKILL_SEGMENT = "[a-z][a-z0-9_-]*";
 const DOLLAR_SKILL_FORM = new RegExp(`^\\$${SKILL_SEGMENT}(?::${SKILL_SEGMENT})*(?=\\s|$)`);

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`,