mirror-mind 0.36.1 → 0.36.3

package/.pi/extensions/mirror-logger.ts

@@ -6,9 +6,12 @@
  * Events handled:
  * - session_start      → unmute + welcome card + status line, in ONE front-door
  *                        process (CV9.E2.S32); maintenance detached
- * - before_agent_start → log user prompt, NOT awaited: queued on a per-session
+ * - input              → what the person typed, kept for the run it starts (CR160)
+ * - before_agent_start → the turn to the core's prompt rule (`user-prompt`), with a
+ *                        turn id minted for it, NOT awaited: queued on a per-session
  *                        chain so the turn starts at once (CV9.E2.S32)
- * - agent_end          → log assistant response, after the chain settles
+ * - agent_end          → the run's assistant text, kept for the prompt's reply
+ * - agent_settled      → the prompt's whole reply to `stop`, after the chain settles
  * - session_shutdown   → close conversation (after the chain settles) + backup
  *
  * All heavy logic lives in the TypeScript core, reached through the `mirror`
@@ -35,6 +38,7 @@ import { homedir } from "node:os";
 import { delimiter, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 
 /** The tree this extension ships in: `.pi/extensions/` sits two below the root. */
 const TREE_ROOT = fileURLToPath(new URL("../../", import.meta.url)).replace(/\/$/, "");
@@ -360,6 +364,60 @@ export default function (pi: ExtensionAPI) {
 		await (pendingUserLog.get(sessionId) ?? Promise.resolve());
 	}
 
+	/**
+	 * CR160: Pi's turns reach the core's prompt rule, the one the hooks use
+	 * (`user-prompt`, `stop`): a skill invocation and its reply are not
+	 * conversation, a Mirror question is (`commandTurn.ts`, `mirrorForm.ts`).
+	 *
+	 * The rule needs what the person typed, and Pi hands `before_agent_start` the
+	 * prompt after it expanded a skill into its body. Its documented `input` event
+	 * carries the text as sent, so that text is kept here for the run it starts --
+	 * only when it starts one: a message queued while Pi streams joins a run
+	 * already going. The payload travels as `--payload`: `pi.exec` cannot write
+	 * stdin (`conversationLoggerRoute.ts`).
+	 */
+	const typedInput = new Map<string, string>();
+
+	/** The prompt in flight and the assistant text its runs have produced so far. */
+	interface PendingReply {
+		turnId: string;
+		texts: string[];
+	}
+	const pendingReply = new Map<string, PendingReply>();
+
+	/**
+	 * Pi's expansion of `/skill:<name> args`: `<skill name="<name>" location="…">`,
+	 * `References are relative to ….`, the body, `</skill>`, then the arguments.
+	 * With no typed text kept for a run, the wrapper is read back to the command
+	 * it came from, so the rule still sees a command (CR160, A3).
+	 */
+	const PI_SKILL_WRAPPER =
+		/^<skill name="([^"]+)" location="[^"]*">\nReferences are relative to [^\n]*\n\n[\s\S]*?\n<\/skill>(?:\n\n([\s\S]*))?$/;
+
+	function typedFormOf(prompt: string): string {
+		const match = PI_SKILL_WRAPPER.exec(prompt);
+		if (!match) return prompt;
+		const args = (match[2] ?? "").trim();
+		return args ? `/skill:${match[1]} ${args}` : `/skill:${match[1]}`;
+	}
+
+	/** The `stop` argv for a prompt's reply, or null when it produced no text. */
+	function takeStopArgs(sessionId: string): string[] | null {
+		const reply = pendingReply.get(sessionId);
+		pendingReply.delete(sessionId);
+		if (!reply || reply.texts.length === 0) return null;
+		const content = truncate(reply.texts.join("\n\n---\n\n"));
+		log("INFO", `stop (turn ${reply.turnId}): ${reply.texts.length} block(s), ${content.length} chars`);
+		return [
+			"conversation-logger",
+			"stop",
+			"--interface",
+			"pi",
+			"--payload",
+			JSON.stringify({ session_id: sessionId, turn_id: reply.turnId, last_assistant_message: content }),
+		];
+	}
+
 	/** Extract readable text from a content blocks array or plain string. */
 	function extractText(content: unknown): string {
 		if (typeof content === "string") return content;
@@ -558,33 +616,60 @@ export default function (pi: ExtensionAPI) {
 		runMirrorBackground(["conversation-logger", "session-maintenance"], "session-maintenance");
 	});
 
-	// --- 2. before_agent_start → log user prompt with explicit session id ---
+	// --- 2. input → what the person typed, for the run it starts (CR160) ---
 
-	pi.on("before_agent_start", async (event, ctx) => {
+	pi.on("input", async (event, ctx) => {
 		const sessionId = ctx.sessionManager.getSessionFile() ?? null;
 		if (!sessionId) return;
+		// The fields are Pi's (`InputEvent`); the types this directory pins predate one.
+		const { text, streamingBehavior } = event as { text: string; streamingBehavior?: string };
+		// Queued while Pi streams: it joins a run already going and starts none.
+		if (streamingBehavior) return;
+		typedInput.set(sessionId, text);
+	});
 
-		const prompt = event.prompt ?? "";
-		if (!prompt || prompt.startsWith("/")) return;
+	// --- 3. before_agent_start → the turn to the core's prompt rule ---
 
-		log("INFO", `log-user: ${prompt.slice(0, 80)}...`);
-		// Not awaited (CV9.E2.S32): the turn starts now; `agent_end` and
+	pi.on("before_agent_start", async (event, ctx) => {
+		const sessionId = ctx.sessionManager.getSessionFile() ?? null;
+		if (!sessionId) return;
+		// A run a custom message started answers no prompt of the person's. Pi's
+		// field (`messageType`); the types this directory pins predate it.
+		const { messageType } = event as { messageType?: string };
+		if (messageType !== undefined && messageType !== "user") return;
+
+		const typed = typedInput.get(sessionId);
+		typedInput.delete(sessionId);
+		const prompt = typed ?? typedFormOf(event.prompt ?? "");
+
+		// A reply still unsent belongs to the prompt before this one: a Pi without
+		// `agent_settled` (before 0.80.4) never sent it. It goes first, on the chain.
+		const earlier = takeStopArgs(sessionId);
+		if (earlier) enqueueUserLog(sessionId, earlier);
+
+		const turnId = randomUUID();
+		pendingReply.set(sessionId, { turnId, texts: [] });
+		if (!prompt) return;
+
+		log("INFO", `user-prompt (turn ${turnId}): ${prompt.slice(0, 80)}...`);
+		// Not awaited (CV9.E2.S32): the turn starts now; `agent_settled` and
 		// `session_shutdown` settle the chain before anything that must follow.
 		enqueueUserLog(sessionId, [
 			"conversation-logger",
-			"log-user",
-			sessionId,
-			truncate(prompt),
+			"user-prompt",
 			"--interface",
 			"pi",
+			"--payload",
+			JSON.stringify({ session_id: sessionId, prompt: truncate(prompt), turn_id: turnId }),
 		]);
 	});
 
-	// --- 3. agent_end → log assistant response ---
+	// --- 4. agent_end → the run's assistant text, kept for the prompt's reply ---
 	//
-	// agent_end fires once per user prompt, with ALL messages in the cycle
-	// (assistant + tool calls + tool results). Extract only assistant text
-	// and log as a single consolidated message.
+	// agent_end fires once per run, with ALL messages in it (assistant + tool
+	// calls + tool results), and a prompt can take more than one run. The
+	// assistant text is kept until the prompt settles: the hooks' `stop` takes
+	// one answer per turn (CR160, A2).
 
 	pi.on("agent_end", async (event, ctx) => {
 		const sessionId = ctx.sessionManager.getSessionFile() ?? null;
@@ -610,21 +695,34 @@ export default function (pi: ExtensionAPI) {
 
 		if (assistantTexts.length === 0) return;
 
-		log("INFO", `log-assistant: ${assistantTexts.length} block(s), ${assistantTexts.join("").length} chars`);
+		// No prompt in flight: a run a custom message started, after the last
+		// prompt settled. It answers nothing the person asked, and `stop` would
+		// find nothing waiting, as on the other runtimes.
+		pendingReply.get(sessionId)?.texts.push(...assistantTexts);
+		await refreshMirrorStatus(ctx);
+	});
+
+	// --- 5. agent_settled → the prompt's whole reply to `stop` ---
 
-		const combined = assistantTexts.join("\n\n---\n\n");
-		const content = truncate(combined);
+	// `agent_settled` arrived in Pi 0.80.4, after the Pi types this directory pins
+	// (`.pi/package.json`), so it is registered by its name alone.
+	const onEvent = pi.on.bind(pi) as unknown as (
+		event: string,
+		handler: (event: unknown, ctx: { sessionManager: { getSessionFile(): string | undefined } }) => Promise<void>,
+	) => void;
 
-		// The user message's process has exited before this one is spawned.
+	onEvent("agent_settled", async (_event, ctx) => {
+		const sessionId = ctx.sessionManager.getSessionFile() ?? null;
+		if (!sessionId) return;
+		const args = takeStopArgs(sessionId);
+		if (!args) return;
+		// The prompt's process has exited before this one is spawned; detached, so
+		// the write survives Pi exiting right after the answer.
 		await settleUserLog(sessionId);
-		runMirrorBackground(
-			["conversation-logger", "log-assistant", sessionId, content, "--interface", "pi"],
-			"log-assistant",
-		);
-		await refreshMirrorStatus(ctx);
+		runMirrorBackground(args, "stop");
 	});
 
-	// --- 4. session_shutdown → close conversation + backup ---
+	// --- 6. session_shutdown → close conversation + backup ---
 	//
 	// Uses extract=False because extraction calls the LLM and can take 30s+.
 	// Extraction happens at the next session_start via extract_pending.
@@ -633,7 +731,11 @@ export default function (pi: ExtensionAPI) {
 		const sessionId = ctx.sessionManager.getSessionFile() ?? null;
 
 		if (sessionId) {
-			// A prompt still in flight must land before the conversation closes.
+			// A reply still unsent (a Pi without `agent_settled`) lands before the
+			// conversation closes, after its prompt; so does a prompt in flight.
+			const reply = takeStopArgs(sessionId);
+			if (reply) enqueueUserLog(sessionId, reply);
+			typedInput.delete(sessionId);
 			await settleUserLog(sessionId);
 			pendingUserLog.delete(sessionId);
 			await runMirror(["conversation-logger", "session-end-pi", sessionId]);

package/.pi/skills/mm-help/SKILL.md

@@ -6,7 +6,10 @@ user-invocable: true
 
 # Help
 
-Show the user the available commands:
+Show the user the available commands, starting with this line:
+
+> In Pi, type `/mm-` and pick a command from the menu, which lists each one as
+> `skill:mm-<name>`.
 
 ## Operating Modes
 

package/README.md

@@ -114,7 +114,7 @@ this repository, turning a personal experiment into a reusable framework:
 - **Multi-user** — independent mirrors for multiple users on the same machine
 - **Multi-session** — concurrent sessions tracked safely in a database-backed session registry
 - **Intelligence depth** — hybrid semantic and lexical search, honest reinforcement, two-pass extraction, memory consolidation, and shadow cultivation
-- **Extension system** — a stable contract for adding user-specific capabilities outside the core; extensions own their own SQLite tables, CLI subcommands, and Mirror Mode context providers without touching the framework
+- **Extension system** — a stable contract for adding user-specific capabilities outside the core; extensions own their own SQLite tables, CLI subcommands, and Mirror Mode context providers without touching the framework, and reach every runtime: Pi through the home's catalog, Claude Code, Codex, Antigravity, and Grok Build through a plugin each home generates
 
 The move toward Pi as the preferred runtime was inspired by
 [Henrique Bastos](https://github.com/henriquebastos) and his early work in

package/docs/releases/index.md

@@ -12,6 +12,8 @@ Future release notes should use the structure defined in [Release Notes](../proc
 
 ## Releases
 
+- [v0.36.3 — A Skill You Invoke Is Not Something You Said](v0.36.3.md) — patch release of one Change Request, CR160, with CR159's docs: on Pi, a skill picked from the menu or typed is no longer stored as the person's words, and neither is its reply; a question asked with `/mm-mirror` is stored as the question. Pi's turns go through the rule the other runtimes have. `mirror conversations skill-turns` repairs what earlier versions stored, only on `--apply` and after a verified backup. No migration.
+- [v0.36.2 — Clearing Out What Another Home Copied](v0.36.2.md) — patch release of one Change Request, CR154, finishing what v0.36.1 began: `mirror conversations imported` lists the Pi conversations an earlier version imported, by the folder each session came from and beside how many sessions the home logged live there, and `remove` deletes the ones you name, only on `--apply` and after a verified backup. `discard-current` no longer fails on a conversation a Soul Mode integration names. No migration.
 - [v0.36.1 — A Home Keeps Only Its Own Pi Sessions](v0.36.1.md) — patch release of one Change Request, CR153: session maintenance imports no Pi session, so the Mirror homes on one machine no longer copy each other's Pi conversations; a home's Pi conversations are the ones the Pi extension logged into it. `PI_SESSIONS_DIR` is inert. Conversations an earlier version imported stay, and the note shows how to list them. Update every install that has a home. No migration.
 - [v0.36.0 — Five Runtimes, and a Home's Extensions on Every One](v0.36.0.md) — minor release closing CV21.DS10: Grok Build is the fifth runtime, at its honest L3 through the canonical plugin in two printed steps, measured live on grok 1.0.62. With it, CV21.DS5.US2: a home's installed extensions reach Claude Code, Codex, Antigravity, and Grok Build as one generated plugin per home, chosen by measurement on all four. Three Change Requests found by use: an extension's settings file (`extensions/<id>.env`, merged under the environment for the one spawned process), a quiet exit on a closed pipe, and a `bind` that refuses what it cannot bind. No migration.
 - [v0.35.0 — Four Runtimes, One Successor](v0.35.0.md) — minor release closing CV21.DS8: the Gemini CLI integration no longer ships and Antigravity stands in its place, the gate met by DS7's live L4 on agy 1.4.2. Four runtimes — Pi, Claude Code, Codex, Antigravity — named everywhere; the cutoff recorded in full, with the four hook entries a Gemini CLI user deletes and v0.34.0 as the last release that carries the integration; a retired-surface guard keeps it removed. No migration.

package/docs/releases/v0.36.2.md

@@ -0,0 +1,130 @@
+---
+digest: >
+  v0.36.2 is a patch release of one Change Request, CR154, which finishes what
+  v0.36.1 began. v0.36.1 stopped Mirror importing Pi sessions, but the
+  conversations an earlier version had imported stayed, and the only way to
+  see them was a SQL query. `mirror conversations imported` now lists them by
+  the folder each session came from, beside how many Pi sessions the home
+  logged live there, and `remove` deletes the ones you name, only on
+  `--apply` and only after a verified backup. With it, `discard-current` no
+  longer fails on a conversation a Soul Mode integration names. No migration.
+---
+
+# v0.36.2 — Clearing Out What Another Home Copied
+
+**Date:** 2026-10-21
+
+## Highlights
+
+- **`mirror conversations imported` shows what an earlier version imported**
+  ([CR154](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr154-a-home-cannot-list-or-remove-the-pi-conversations-it-imported.md)):
+  one line per folder the session came from, with how many conversations were imported
+  from it and how many Pi sessions this home logged live there. A folder where the home
+  logged nothing live is most likely another home's work. `--project <text>` lists a
+  folder's conversations.
+- **`remove` deletes what you name, and nothing else.** Ids, or every import of one
+  folder, written exactly as the listing prints it. It is a dry run until `--apply`;
+  `--apply` takes a dated backup, verifies it, and removes in one transaction. Memories
+  and provider-call records that named a removed conversation are kept, unlinked, and
+  the report names the backups that still hold copies.
+- **A typo cannot widen a removal.** Every option is declared, and one the command does
+  not know is refused before the database opens.
+- **`discard-current` works on a Soul Mode conversation.** It failed with `FOREIGN KEY
+  constraint failed` on any conversation a Soul Mode integration named. Deleting a
+  conversation now decides every table that references one, and a test reads the
+  schema so the next such table cannot be missed.
+
+## Where We Started
+
+v0.36.1 stopped session maintenance from importing Pi sessions, the defect that let the
+Mirror homes on one machine copy each other's conversations. It removed the cause and
+said so: the copies stayed, and the note gave a SQL query to list them. Deleting them
+was the person's decision, and no command could carry it out — `discard-current`
+removes only the current conversation.
+
+## What Changed
+
+**One command, folders first.** A home can hold hundreds of imports, and the decision a
+person makes is about where they came from, so the listing leads with folders. The
+folder is the directory the Pi session file lived in, read from the path the home
+stored; Mirror reads no Pi file to learn it. Beside each folder, the number of Pi
+sessions the home logged live from it. On the maintainer's production home, 96 imports
+came from one development worktree and 76 from the development checkout, where it had
+logged none live, and 3 from its own workspace, where it had logged 714. In a home made
+by copying another, the copied rows count as its own, which blurs the number.
+
+**Removal is careful by construction.** A dry run first, with the exact command that
+applies it to the same home. On `--apply`, the set is decided read-only; a refusal or
+an empty set stops there, with no backup. Then the dated archive, verified; then one
+transaction that decides the set again and refuses if it moved. An id must name exactly
+one imported conversation, by its full id or by a prefix of at least eight characters:
+a live conversation, an unknown id, or an ambiguous prefix refuses the whole command.
+
+**A review before any code.** Five personas reviewed the plan. The database architect
+found that the deletion `discard-current` used, the one this command meant to reuse,
+missed one of the six tables that reference a conversation, so with foreign keys on, a
+conversation a Soul Mode integration named could not be deleted at all — measured on a
+scratch home, then fixed for both commands. The security engineer found that under the
+listing's lenient parser, a typo such as `--projet` would drop the folder filter and
+remove every import in the home; the command parses strictly, with the parser `backup`
+and `repair-encoding` already used.
+
+**Validated on a copy of the real thing.** On a scratch home made from a fresh backup of
+the maintainer's development home, the command listed 515 imports from 22 folders
+and 5 of unknown origin, refused the typo, and removed the 418 from the production workspace's folder with their
+21,901 messages. Live conversations, memories, and provider-call records kept their
+counts.
+
+### What you will notice
+
+- A new command, `mirror conversations imported`, and its `remove`.
+- `discard-current` deletes a conversation that a Soul Mode integration names.
+
+## Upgrading
+
+```bash
+mirror runtime update          # or: npm install -g mirror-mind
+```
+
+There is no database migration, and no runtime wiring changes. Then, if you ran more
+than one home:
+
+```bash
+mirror conversations imported
+mirror conversations imported --project <text>
+mirror conversations imported remove --all --project <folder>
+mirror conversations imported remove --all --project <folder> --apply
+```
+
+Start with the folders where "logged live here" is 0, and look at a folder's
+conversations before removing them. The dated backups made since the import, and the
+pre-write backup, keep copies until you delete them or they age out (30 days for an
+archive).
+
+## Conscious Exclusions
+
+- **Telling another home's copy from a gap this home filled for itself.** That takes
+  both homes' databases, and no home reads another's. The folders and the logged-live
+  counts are the evidence a person decides on.
+- **Removing anything from backups.**
+- **Options before the subcommand.** `mirror conversations --db-path X imported` shows
+  the plain listing and removes nothing; that is
+  [CR096](../project/refinement/rs009-cv22-front-door-routing-correctness/cr096-conversations-lists-instead-of-appending-when-options-come-first.md)'s
+  class.
+- **A tool for models.** No MCP tool and no skill runs this command: a person does.
+
+## What We Learned
+
+Reusing a routine is a claim about it. The deletion `discard-current` used was correct
+for the tables it knew, and wrong the day another table began to reference a
+conversation. The question that found it — which tables reference a conversation? — is
+now a test that asks the schema, not a person's memory.
+
+A lenient parser is harmless in a listing and dangerous in a deletion: the same ignored
+token is a no-op in one and a wider removal in the other.
+
+## Next Horizon
+
+CV21.DS5.TS4, then DS11 and CV21's own release. Captured and open: CR155, `runtime
+diagnose` reading the Pi extension's error lines; CR156, what copying a home makes;
+CR157, three settings `REFERENCE.md` lists that nothing reads.

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/package.json

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

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/conversationDeletion.ts

@@ -0,0 +1,45 @@
+// What deleting a conversation means, in one place (CR154, review findings D1
+// and E2).
+//
+// Ported as Python's `ConversationService.delete_conversations` for one id, and
+// private to `logger.ts` while `discard-current` was its only caller. CR154's
+// removal of imported Pi conversations is the second, so it lives here now.
+//
+// Six tables reference a conversation, and each gets a decision: what is only
+// the conversation's own is deleted with it, and what outlives it is kept with
+// its link cleared -- a memory extracted from the conversation is still a
+// memory, a provider call still happened, a session row still names its
+// session, an identity integration is still part of the identity. Foreign keys
+// are on (`database.ts`), so a table without a decision makes the conversation
+// undeletable: before CR154 the routine missed `identity_integrations`, and
+// `discard-current` failed with `FOREIGN KEY constraint failed` on any
+// conversation a Soul Mode integration named. `conversationDeletion.test.ts`
+// reads the schema's foreign keys and fails when a table appears that the
+// lists below do not decide.
+
+import type { WritableDatabase } from "#db/database.ts";
+
+/** Every table that references `conversations(id)`, by what deletion does to its rows. */
+export const CONVERSATION_REFERENCES = {
+  /** The conversation's own rows: deleted with it. */
+  deleted: ["conversation_embeddings", "messages"],
+  /** Rows that outlive it: kept, their `conversation_id` set to null. */
+  unlinked: ["identity_integrations", "llm_calls", "memories", "runtime_sessions"],
+} as const;
+
+/**
+ * Delete one conversation: its own rows first, then the links that outlive
+ * it, then the conversation. Runs no transaction of its own -- every caller
+ * wraps it in one with whatever else must move together.
+ */
+export function deleteConversation(db: WritableDatabase, conversationId: string): void {
+  for (const table of CONVERSATION_REFERENCES.deleted) {
+    db.prepare(`DELETE FROM ${table} WHERE conversation_id = ?`).run(conversationId);
+  }
+  for (const table of CONVERSATION_REFERENCES.unlinked) {
+    db.prepare(`UPDATE ${table} SET conversation_id = NULL WHERE conversation_id = ?`).run(
+      conversationId,
+    );
+  }
+  db.prepare("DELETE FROM conversations WHERE id = ?").run(conversationId);
+}