mirror-mind 0.36.2 → 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,7 @@ 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.

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.2",
+  "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.2",
+  "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.2",
+  "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/piSkillTurns.ts

@@ -0,0 +1,267 @@
+// The Pi user turns an earlier version stored as a skill's body, and their repair
+// (CR160).
+//
+// Pi turns a prompt that opens with `/skill:<name>`, which is also what its command
+// menu sends, into the skill's whole body before its extensions see it. Until CR160
+// Pi's extension logged that prompt, so a skill invocation was stored as
+// `<skill name="…" location="…">` and the body, as if the person had said it; every
+// later reader -- the title, the embedding, extraction -- read it so.
+//
+// The repair applies the rule the core logs by (`commandTurn.ts`): a Mirror
+// question keeps its question, without the block (`mirrorForm.ts`); any other skill
+// invocation is not conversation, and neither are its arguments (a `mm-build`
+// slug), so its row goes. A conversation the repair leaves with no user turn goes
+// too, through the shared deletion, which keeps its memories unlinked (the
+// Navigator's decision, A7). A conversation titled from a block, and not titled by
+// hand, gets the title every conversation gets from its first user turn, marked
+// provisional so the title paths can improve it. Replies stay: they are what the
+// mirror said, and a reply to a skipped turn cannot be told from another. Summaries
+// and their embeddings stay: they describe a session in which a skill was invoked
+// (A6).
+//
+// Only Pi's whole wrapper, only in Pi conversations (A8): a person may type or
+// paste `<skill name=` at the start of a message anywhere. One more shape counts:
+// the wrapper the old logger cut at its size limit, whose ending only it writes.
+
+import { isCommandTurn } from "#conversation/commandTurn.ts";
+import { deleteConversation } from "#conversation/conversationDeletion.ts";
+import { generateTitle, setProvisionalTitle } from "#conversation/logger.ts";
+import { type Database, type WritableDatabase, withTransaction } from "#db/database.ts";
+
+/**
+ * Pi's expansion of `/skill:<name> args`, whole: the opening tag, Pi's line naming
+ * where the skill's references resolve, the body, the closing tag, and the
+ * arguments after a blank line when there are any (Pi 1.3.0 and 1.4.0,
+ * `_expandSkillCommand`). Pi's own extension reads the same shape back
+ * (`.pi/extensions/mirror-logger.ts`); `piSkillTurns.test.ts` holds the two alike.
+ */
+export const PI_SKILL_WRAPPER =
+  /^<skill name="([^"]+)" location="[^"]*">\nReferences are relative to [^\n]*\n\n[\s\S]*?\n<\/skill>(?:\n\n([\s\S]*))?$/;
+
+/**
+ * The same block when the old logger cut it: the extension kept the first 50,000
+ * characters and added its own marker (`truncate`, `.pi/extensions/mirror-logger.ts`),
+ * so the closing tag never arrived. Pi's opening lines, then an ending only the
+ * logger writes: no person types that. Whatever followed the block was cut with it.
+ */
+const PI_SKILL_WRAPPER_CUT =
+  /^<skill name="([^"]+)" location="[^"]*">\nReferences are relative to [^\n]*\n\n[\s\S]*\n\[… truncated\]$/;
+
+/** The one skill whose turn is conversation: its question is the turn. */
+const MIRROR_SKILL = "mm-mirror";
+
+export interface StoredSkillTurn {
+  messageId: string;
+  conversationId: string;
+  skill: string;
+  /** What followed the block, trimmed; "" when nothing did. */
+  tail: string;
+  /** The Mirror question the row keeps, or null when the row goes. */
+  question: string | null;
+}
+
+export interface ConversationToDelete {
+  id: string;
+  title: string | null;
+  messageCount: number;
+  startedAt: string;
+}
+
+export interface ConversationToRetitle {
+  id: string;
+  title: string;
+  newTitle: string;
+}
+
+export interface SkillTurnRepairPlan {
+  /** Every stored skill turn, in the order the rows were written. */
+  turns: StoredSkillTurn[];
+  /** The Mirror questions: each row keeps its question. */
+  kept: StoredSkillTurn[];
+  /** Every other skill turn: each row goes. */
+  removed: StoredSkillTurn[];
+  conversationsToDelete: ConversationToDelete[];
+  conversationsToRetitle: ConversationToRetitle[];
+}
+
+export interface SkillTurnRepairResult {
+  kept: number;
+  removed: number;
+  conversationsDeleted: number;
+  /** Messages that went with the deleted conversations, beyond the removed turns. */
+  messagesDeletedWithConversations: number;
+  conversationsRetitled: number;
+}
+
+/** The set the transaction found is not the set the person was shown. */
+export class SkillTurnRepairSetMovedError extends Error {
+  constructor() {
+    super("the stored skill turns changed since they were listed");
+    this.name = "SkillTurnRepairSetMovedError";
+  }
+}
+
+/** The skill turn a stored row holds, or null when the row is not Pi's whole wrapper. */
+export function readSkillTurn(content: string): { skill: string; tail: string } | null {
+  const match = PI_SKILL_WRAPPER.exec(content);
+  if (match) return { skill: match[1] as string, tail: (match[2] ?? "").trim() };
+  const cut = PI_SKILL_WRAPPER_CUT.exec(content);
+  if (cut) return { skill: cut[1] as string, tail: "" };
+  return null;
+}
+
+function isManualTitle(rawMetadata: unknown): boolean {
+  if (typeof rawMetadata !== "string") return false;
+  try {
+    const metadata = JSON.parse(rawMetadata) as Record<string, unknown>;
+    return metadata.title_status === "manual" || metadata.title_source === "manual";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * What the repair would change, decided once for the dry run and again inside the
+ * repair's transaction.
+ */
+export function planSkillTurnRepair(db: Database): SkillTurnRepairPlan {
+  // SQL narrows to the prefix; `readSkillTurn` decides on the whole wrapper.
+  const candidates = db
+    .prepare(
+      `SELECT m.id, m.conversation_id, m.content
+         FROM messages m JOIN conversations c ON c.id = m.conversation_id
+        WHERE c.interface = 'pi' AND m.role = 'user' AND substr(m.content, 1, 13) = '<skill name="'
+        ORDER BY m.created_at, m.rowid`,
+    )
+    .all();
+  const turns: StoredSkillTurn[] = [];
+  for (const row of candidates) {
+    const read = readSkillTurn(String(row.content));
+    if (read === null) continue;
+    const question = read.skill === MIRROR_SKILL && read.tail !== "" ? read.tail : null;
+    turns.push({
+      messageId: String(row.id),
+      conversationId: String(row.conversation_id),
+      skill: read.skill,
+      tail: read.tail,
+      question,
+    });
+  }
+  const kept = turns.filter((turn) => turn.question !== null);
+  const removed = turns.filter((turn) => turn.question === null);
+  const removedIds = new Set(removed.map((turn) => turn.messageId));
+  const keptQuestion = new Map(kept.map((turn) => [turn.messageId, turn.question as string]));
+
+  // A conversation the repair leaves with no user turn goes. Otherwise a block-born
+  // title is rebuilt from its first remaining user turn that is not a command: a
+  // command is not conversation (`commandTurn.ts`), so it names one only when
+  // nothing else remains.
+  const touched = [...new Set(turns.map((turn) => turn.conversationId))];
+  const userRows = db.prepare(
+    `SELECT id, content FROM messages WHERE conversation_id = ? AND role = 'user'
+      ORDER BY created_at, rowid`,
+  );
+  const remainingUserTurns = (conversationId: string, removing: ReadonlySet<string>): string[] =>
+    userRows
+      .all(conversationId)
+      .filter((row) => !removing.has(String(row.id)))
+      .map((row) => keptQuestion.get(String(row.id)) ?? String(row.content))
+      .filter((content) => content.trim() !== "");
+  const titleSource = (remaining: readonly string[]): string | null =>
+    remaining.find((content) => !isCommandTurn(content)) ?? remaining[0] ?? null;
+  const remainingFirstUser = new Map<string, string | null>();
+  for (const conversationId of touched) {
+    remainingFirstUser.set(
+      conversationId,
+      titleSource(remainingUserTurns(conversationId, removedIds)),
+    );
+  }
+
+  const conversationRow = db.prepare(
+    `SELECT id, title, started_at, metadata,
+            (SELECT COUNT(*) FROM messages m WHERE m.conversation_id = c.id) AS message_count
+       FROM conversations c WHERE id = ?`,
+  );
+  const conversationsToDelete: ConversationToDelete[] = [];
+  for (const conversationId of touched) {
+    if (remainingFirstUser.get(conversationId) !== null) continue;
+    const row = conversationRow.get(conversationId);
+    if (!row) continue;
+    conversationsToDelete.push({
+      id: conversationId,
+      title: typeof row.title === "string" ? row.title : null,
+      messageCount: Number(row.message_count),
+      startedAt: String(row.started_at),
+    });
+  }
+  const deleting = new Set(conversationsToDelete.map((item) => item.id));
+
+  // Titles born of a block, in any Pi conversation that stays, unless set by hand.
+  const titled = db
+    .prepare(
+      `SELECT id, title, metadata FROM conversations
+        WHERE interface = 'pi' AND lower(substr(trim(title), 1, 6)) = '<skill'
+        ORDER BY started_at, id`,
+    )
+    .all();
+  const conversationsToRetitle: ConversationToRetitle[] = [];
+  for (const row of titled) {
+    const id = String(row.id);
+    if (deleting.has(id) || isManualTitle(row.metadata)) continue;
+    const source = remainingFirstUser.has(id)
+      ? remainingFirstUser.get(id)
+      : titleSource(remainingUserTurns(id, new Set()));
+    if (!source || readSkillTurn(source) !== null) continue;
+    const newTitle = generateTitle(source).trim();
+    if (newTitle === "") continue;
+    conversationsToRetitle.push({ id, title: String(row.title), newTitle });
+  }
+
+  return { turns, kept, removed, conversationsToDelete, conversationsToRetitle };
+}
+
+/** One string that names everything a plan changes, to compare a plan with the one shown. */
+export function skillTurnRepairKey(plan: SkillTurnRepairPlan): string {
+  const sorted = (values: readonly string[]) => [...values].sort().join(",");
+  return [
+    sorted(plan.kept.map((turn) => turn.messageId)),
+    sorted(plan.removed.map((turn) => turn.messageId)),
+    sorted(plan.conversationsToDelete.map((item) => item.id)),
+    sorted(plan.conversationsToRetitle.map((item) => `${item.id}=${item.newTitle}`)),
+  ].join("|");
+}
+
+/**
+ * Repair what the plan names, in one transaction: all or nothing. The plan is
+ * decided again inside the transaction and must be the one the person was shown
+ * (`expectedKey`); if it moved, nothing changes.
+ */
+export function applySkillTurnRepair(
+  db: WritableDatabase,
+  expectedKey: string,
+): SkillTurnRepairResult {
+  return withTransaction(db, () => {
+    const plan = planSkillTurnRepair(db);
+    if (skillTurnRepairKey(plan) !== expectedKey) throw new SkillTurnRepairSetMovedError();
+    const keepQuestion = db.prepare("UPDATE messages SET content = ? WHERE id = ?");
+    for (const turn of plan.kept) keepQuestion.run(turn.question as string, turn.messageId);
+    const removeTurn = db.prepare("DELETE FROM messages WHERE id = ?");
+    for (const turn of plan.removed) removeTurn.run(turn.messageId);
+    const remainingMessages = db.prepare(
+      "SELECT COUNT(*) AS n FROM messages WHERE conversation_id = ?",
+    );
+    let messagesDeletedWithConversations = 0;
+    for (const item of plan.conversationsToDelete) {
+      messagesDeletedWithConversations += Number(remainingMessages.get(item.id)?.n ?? 0);
+      deleteConversation(db, item.id);
+    }
+    for (const item of plan.conversationsToRetitle) setProvisionalTitle(db, item.id, item.newTitle);
+    return {
+      kept: plan.kept.length,
+      removed: plan.removed.length,
+      conversationsDeleted: plan.conversationsToDelete.length,
+      messagesDeletedWithConversations,
+      conversationsRetitled: plan.conversationsToRetitle.length,
+    };
+  });
+}

package/ts/src/frontDoor/cli.ts

@@ -172,6 +172,7 @@ import { runRuntimeReadRoute, runWelcomeRoute } from "./runtimeRoute.ts";
 import { runMemorySearchRoute } from "./searchRoute.ts";
 import { resolveSeedPaths } from "./seedPaths.ts";
 import { isSessionStartWelcome, runSessionStartWelcomeRoute } from "./sessionStartWelcomeRoute.ts";
+import { isSkillTurnsCommand, runSkillTurnsRoute } from "./skillTurnsRoute.ts";
 import { runSoulRoute } from "./soulRoute.ts";
 import {
   applyTasksImport,
@@ -1781,6 +1782,21 @@ async function dispatchTs(argv: readonly string[]): Promise<number | DispatchOut
       verifyBackup: (archive) => verifyBackupArchive(archive),
     });
   }
+  // CR160: the same shape -- the dry run reads; `--apply` writes behind the
+  // pre-write backup, after its own dated, verified archive.
+  if (isSkillTurnsCommand(argv)) {
+    return runSkillTurnsRoute(argv, {
+      withReadOnlyDatabase: (read) => withMirrorReadDb(argv, read),
+      withLiveWriteDatabase: (write) => {
+        const dbPath = resolveDbPathForCli(argv.slice(1));
+        if (dbPath === null) return 2;
+        return withLiveWriteDbAt(dbPath, "conversations", (db) => write(db, dbPath));
+      },
+      backup: (dbPath) =>
+        createZipBackup({ dbPath, mirrorHome: dirname(dbPath), backupDir: null, silent: true }),
+      verifyBackup: (archive) => verifyBackupArchive(archive),
+    });
+  }
   // CV22.DS7.TS1: the DB safety tools. `backup` never opens or bootstraps the
   // database; `repair-encoding --apply` rides the live-write seam.
   if (argv[0] === "backup") {

package/ts/src/frontDoor/conversationLoggerRoute.ts

@@ -35,6 +35,24 @@ function subcommandOf(args: readonly string[]): string {
  */
 const readStdin = takeStdin;
 
+/**
+ * `--payload <json>`: a hook subcommand's payload in argv rather than on stdin
+ * (CR160). Pi's extension reaches the core through `pi.exec`, which cannot write
+ * a child's stdin, and since CR160 it sends Pi's turns to `user-prompt` and
+ * `stop`. Pi's prompt has travelled in argv since CV9, as `log-user`'s argument,
+ * so this is the exposure Pi always had, no wider (`stdinSource.ts`). The option
+ * is taken out of argv before the subcommand sees it, and a route given one
+ * never reads fd 0: a stdin pipe nobody closes cannot hang it.
+ */
+function takePayloadOption(args: readonly string[]): { payload: string | null; rest: string[] } {
+  const index = args.indexOf("--payload");
+  if (index === -1 || index + 1 >= args.length) return { payload: null, rest: [...args] };
+  return {
+    payload: args[index + 1] as string,
+    rest: [...args.slice(0, index), ...args.slice(index + 2)],
+  };
+}
+
 /**
  * Where the route's lines go. The default is the process's own streams; the
  * `session-start --welcome` composite (CV9.E2.S32) captures them instead, so
@@ -51,7 +69,7 @@ export async function runConversationLoggerRoute(
   argv: readonly string[],
   io: ConversationLoggerRouteIo = {},
 ): Promise<number> {
-  const args = argv.slice(1);
+  const { payload, rest: args } = takePayloadOption(argv.slice(1));
   const subcommand = subcommandOf(args);
   const runtime = createLoggerRuntime({
     db,
@@ -73,7 +91,7 @@ export async function runConversationLoggerRoute(
       }),
   });
   const result = await runConversationLoggerCommand(db, args, runtime, {
-    stdin: STDIN_SUBCOMMANDS.has(subcommand) ? readStdin() : undefined,
+    stdin: STDIN_SUBCOMMANDS.has(subcommand) ? (payload ?? readStdin()) : undefined,
   });
   const out = io.stdout ?? ((line: string) => process.stdout.write(`${line}\n`));
   const err = io.stderr ?? ((line: string) => process.stderr.write(`${line}\n`));

package/ts/src/frontDoor/routing.ts

@@ -591,6 +591,16 @@ export function routeByFamily(
           : "CR154 conversations imported",
       };
     }
+    // CR160: allowlisted by name like CR154's, its apply named apart.
+    if (argv[1] === "skill-turns") {
+      return {
+        command,
+        engine: "ts",
+        reason: argv.includes("--apply")
+          ? "CR160 conversations skill-turns --apply"
+          : "CR160 conversations skill-turns",
+      };
+    }
     const writeFlag = TS4_LIFECYCLE_WRITE_FLAGS.find((flag) => argv.includes(flag));
     if (writeFlag) {
       return { command, engine: "ts", reason: `DS7.TS4 ${writeFlag} ported to TS` };

package/ts/src/frontDoor/skillTurnsRoute.ts

@@ -0,0 +1,213 @@
+// `mirror conversations skill-turns` (CR160): see the Pi user turns an earlier
+// version stored as a skill's body, and repair them.
+//
+//   conversations skill-turns [--apply] [--mirror-home PATH] [--db-path PATH]
+//
+// A dry run until `--apply`. The dry run names what the repair would change: by
+// skill, how many rows keep their Mirror question and how many go; each
+// conversation it would delete because it leaves it with no user turn, with its
+// message count (A7); how many titles it would rebuild. `--apply` decides first
+// (nothing to repair stops there, with no backup), takes the dated backup and
+// verifies it, and only then repairs, in one transaction that decides again and
+// refuses if anything moved. Every option is declared: a typo is refused before
+// anything opens. Shaped as CR154's `conversations imported remove`.
+//
+// The module that decides what a stored skill turn is, and repairs it, is
+// `#conversation/piSkillTurns.ts`; this file parses, opens, and prints. Nothing
+// here is offered to a model: no MCP tool, no skill.
+
+import { RETENTION_DAYS } from "#backup/zipBackup.ts";
+import {
+  applySkillTurnRepair,
+  planSkillTurnRepair,
+  type SkillTurnRepairPlan,
+  type SkillTurnRepairResult,
+  SkillTurnRepairSetMovedError,
+  skillTurnRepairKey,
+} from "#conversation/piSkillTurns.ts";
+import type { Database, WritableDatabase } from "#db/database.ts";
+import { PROGRAM } from "#util/program.ts";
+import { shellWord } from "#util/shellWord.ts";
+import { parseArgs } from "#util/strictArgs.ts";
+
+const USAGE = `usage: ${PROGRAM} conversations skill-turns [--apply] [--mirror-home PATH] [--db-path PATH]`;
+
+/** How argparse names the program in an error line. */
+const PROG = `${PROGRAM} conversations skill-turns`;
+
+const WHAT_A_SKILL_TURN_IS =
+  "Until CR160, Mirror recorded the skill Pi expanded, instead of what was typed.";
+
+const HOME_OPTIONS = ["--mirror-home", "--db-path"] as const;
+
+export interface SkillTurnsIo {
+  /** The home's database, read-only: the dry run, and the decision before `--apply`. */
+  withReadOnlyDatabase: (read: (db: Database) => number) => number;
+  /** The home's database behind the front door's pre-write backup: `--apply` only. */
+  withLiveWriteDatabase: (write: (db: WritableDatabase, dbPath: string) => number) => number;
+  /** The dated archive; its path, or null on failure. */
+  backup: (dbPath: string) => string | null;
+  verifyBackup: (archivePath: string) => { valid: boolean; note: string | null };
+  stdout?: (line: string) => void;
+  stderr?: (line: string) => void;
+}
+
+export function isSkillTurnsCommand(argv: readonly string[]): boolean {
+  return argv[0] === "conversations" && argv[1] === "skill-turns";
+}
+
+function plural(count: number, word: string): string {
+  return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
+
+function isEmpty(plan: SkillTurnRepairPlan): boolean {
+  return plan.turns.length === 0 && plan.conversationsToRetitle.length === 0;
+}
+
+export function runSkillTurnsRoute(argv: readonly string[], io: SkillTurnsIo): number {
+  const out = io.stdout ?? ((line: string) => process.stdout.write(`${line}\n`));
+  const err = io.stderr ?? ((line: string) => process.stderr.write(`${line}\n`));
+
+  const rest = argv.slice(2);
+  if (rest.includes("-h") || rest.includes("--help")) {
+    out(USAGE);
+    return 0;
+  }
+  const parsed = parseArgs(rest, { flags: ["--apply"], valued: [...HOME_OPTIONS] });
+  if (parsed.error) {
+    err(USAGE);
+    err(`${PROG}: error: ${parsed.error}`);
+    return 2;
+  }
+  if (!parsed.flags.has("--apply")) {
+    // The command that applies this dry run, to the same home, every value quoted.
+    const words = ["conversations", "skill-turns"];
+    for (const option of HOME_OPTIONS) {
+      const value = parsed.values.get(option);
+      if (value !== undefined) words.push(option, value);
+    }
+    words.push("--apply");
+    return dryRun(io, out, [PROGRAM, ...words.map(shellWord)].join(" "));
+  }
+  return apply(io, out, err);
+}
+
+function dryRun(io: SkillTurnsIo, out: (line: string) => void, applyCommand: string): number {
+  return io.withReadOnlyDatabase((db) => {
+    const plan = planSkillTurnRepair(db);
+    if (isEmpty(plan)) {
+      out("No Pi user turns stored as a skill's body in this home.");
+      return 0;
+    }
+    if (plan.turns.length > 0) {
+      const conversations = new Set(plan.turns.map((turn) => turn.conversationId)).size;
+      out(
+        `Pi user turns stored as a skill's body: ${plan.turns.length}, in ${plural(conversations, "conversation")}.`,
+      );
+      out(WHAT_A_SKILL_TURN_IS);
+      out("");
+      out("  question kept  removed  skill");
+      for (const [skill, kept, removed] of bySkill(plan)) {
+        out(`${String(kept).padStart(15)}${String(removed).padStart(9)}  ${skill}`);
+      }
+      out("");
+    }
+    if (plan.conversationsToDelete.length > 0) {
+      out(
+        `Would delete ${plural(plan.conversationsToDelete.length, "conversation")} left with no user turn:`,
+      );
+      for (const item of plan.conversationsToDelete) {
+        out(
+          `  ${item.startedAt.slice(0, 10)}  ${item.id.slice(0, 8)}  ${plural(item.messageCount, "message")}  ${item.title ?? "(untitled)"}`,
+        );
+      }
+    }
+    const retitles = plan.conversationsToRetitle.length;
+    if (retitles > 0) {
+      out(
+        `Would retitle ${plural(retitles, "conversation")} from ${retitles === 1 ? "its" : "their"} first remaining user turn.`,
+      );
+    }
+    out("Replies, summaries, and memories stay.");
+    out("Nothing was changed. To repair them, run:");
+    out(`  ${applyCommand}`);
+    return 0;
+  });
+}
+
+/** By skill: [skill, rows that keep their question, rows that go]; most first, then by name. */
+function bySkill(plan: SkillTurnRepairPlan): [string, number, number][] {
+  const counts = new Map<string, [number, number]>();
+  for (const turn of plan.turns) {
+    const [kept, removed] = counts.get(turn.skill) ?? [0, 0];
+    counts.set(turn.skill, turn.question !== null ? [kept + 1, removed] : [kept, removed + 1]);
+  }
+  return [...counts.entries()]
+    .map(([skill, [kept, removed]]): [string, number, number] => [skill, kept, removed])
+    .sort((a, b) => b[1] + b[2] - (a[1] + a[2]) || a[0].localeCompare(b[0]));
+}
+
+function apply(io: SkillTurnsIo, out: (line: string) => void, err: (line: string) => void): number {
+  // Decide first, read-only: nothing to repair stops here, and takes no backup. A
+  // holder rather than a variable: it is assigned inside a callback.
+  const decided: { key: string | null } = { key: null };
+  const decidedCode = io.withReadOnlyDatabase((db) => {
+    const plan = planSkillTurnRepair(db);
+    if (isEmpty(plan)) {
+      out("Nothing to repair.");
+      return 0;
+    }
+    decided.key = skillTurnRepairKey(plan);
+    return 0;
+  });
+  const expectedKey = decided.key;
+  if (decidedCode !== 0 || expectedKey === null) return decidedCode;
+
+  return io.withLiveWriteDatabase((db, dbPath) => {
+    let archive: string | null;
+    try {
+      archive = io.backup(dbPath);
+    } catch {
+      archive = null;
+    }
+    if (archive === null) {
+      err("The backup failed, so nothing was changed.");
+      return 1;
+    }
+    const verification = io.verifyBackup(archive);
+    if (!verification.valid) {
+      err(
+        `The backup ${archive} did not verify (${verification.note ?? "no reason given"}), so nothing was changed.`,
+      );
+      return 1;
+    }
+    let result: SkillTurnRepairResult;
+    try {
+      result = applySkillTurnRepair(db, expectedKey);
+    } catch (error) {
+      if (error instanceof SkillTurnRepairSetMovedError) {
+        err(
+          "The stored skill turns changed while the backup was taken, so nothing was changed. Run it again.",
+        );
+        return 1;
+      }
+      throw error;
+    }
+    out(`Backup: ${archive} (verified).`);
+    out(
+      `Kept ${plural(result.kept, "Mirror question")}; removed ${plural(result.removed, "skill turn")}.`,
+    );
+    if (result.conversationsDeleted > 0) {
+      out(
+        `Deleted ${plural(result.conversationsDeleted, "conversation")} left with no user turn, ` +
+          `with ${plural(result.messagesDeletedWithConversations, "more message")}.`,
+      );
+      out("Memories and provider-call records that named them were kept, unlinked.");
+    }
+    if (result.conversationsRetitled > 0) {
+      out(`Retitled ${plural(result.conversationsRetitled, "conversation")}.`);
+    }
+    out(`Copies remain in this home's backups until they age out (${RETENTION_DAYS} days).`);
+    return 0;
+  });
+}

package/ts/src/frontDoor/stdinSource.ts

@@ -12,6 +12,11 @@
 // caller uses, and a payload does not belong in argv: argv is what `ps`
 // shows, and what the Gemini CLI hooks (retired by CV21.DS8.US1) put a prompt
 // into is the exception this seam avoids repeating.
+//
+// One exception stands, and is no wider than before: Pi's extension reaches the
+// core through `pi.exec`, which cannot write a child's stdin, so it passes the
+// payload as `--payload` (CR160, `conversationLoggerRoute.ts`). Pi's prompt has
+// travelled in argv since CV9, as `log-user`'s argument.
 
 import { readFileSync } from "node:fs";
 

package/ts/src/mirror/mirrorForm.ts

@@ -13,11 +13,14 @@
 //     $mirror-mind:mm:mirror …     the Codex plugin (TS2 L10)
 //     /mm-mirror …                 Grok (TS4 L5)
 //     $mm-mirror …                 Codex's own skill form
+//     /skill:mm-mirror …           Pi's command, which its menu sends (CR160)
 //
 // Three choices, each made by the runtime, not the person: the sigil (`/` or
 // `$`), whether the plugin's name prefixes the skill, and whether the skill's
 // `name: "mm:mirror"` or its directory `mm-mirror` is used. The grammar is
 // their product, so a runtime that combines them differently is covered too.
+// Pi is the exception: it registers every skill as the command `skill:<name>`
+// (CR159 measured it on Pi 1.4.0), so its one form is spelled out whole.
 //
 // The form must open the prompt and end at whitespace or the end of it: a
 // longer skill name (`/mm-mirrors`) is another skill, and a form quoted in the
@@ -32,7 +35,7 @@ export interface MirrorForm {
   readonly query: string;
 }
 
-const FORM = /^([/$])(mirror-mind:)?mm[:-]mirror(?=\s|$)/;
+const FORM = /^(?:\/skill:mm-mirror|[/$](?:mirror-mind:)?mm[:-]mirror)(?=\s|$)/;
 
 /** The explicit Mirror Mode form at the start of a prompt, or null. */
 export function mirrorForm(prompt: string): MirrorForm | null {