mirror-mind 0.36.2 → 0.37.0

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

@@ -5,11 +5,31 @@
  *
  * 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
- *                        chain so the turn starts at once (CV9.E2.S32)
- * - agent_end          → log assistant response, after the chain settles
- * - session_shutdown   → close conversation (after the chain settles) + backup
+ *                        process (CV9.E2.S32); maintenance detached; the session
+ *                        named in the environment (`MIRROR_SESSION_ID`, CV9.DS8.US5)
+ * - input              → what the person typed, kept for the run it starts (CR160)
+ * - before_agent_start → the turn to the one doorman (`mirror doorman`), AWAITED:
+ *                        its block, when there is one, is the run's message, so
+ *                        Mirror's context is before the model on this turn
+ *                        (CV9.DS8.US5); then the turn to the core's prompt rule
+ *                        (`user-prompt`), with a turn id minted for it, NOT
+ *                        awaited: queued on the per-session chain behind the
+ *                        doorman, so the turn starts at once (CV9.E2.S32)
+ * - 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_compact    → the folder left the transcript: `mirror doorman --forget`,
+ *                        so the next ordinary turn is delivered whole (CV9.DS8.US5)
+ * - session_shutdown   → close conversation (after the chain settles) + backup;
+ *                        the session's name cleared from the environment
+ *
+ * The session's name (CV9.DS8.US5, from TS1's P2 measurement on Pi 1.4.0): at
+ * `session_start` this extension sets `MIRROR_SESSION_ID` in Pi's OWN process
+ * environment, which every later `pi.exec` and every bash command the model runs
+ * inherits. So a `mirror mirror load` the model runs by itself on an unprompted
+ * personal question, and a `mirror build load` on a mode switch, name THIS
+ * session's row instead of guessing one -- and the doorman, which reads that row,
+ * takes the next turn. Named-session behaviors that were dormant on Pi while no
+ * session was named wake with it (`mirror log`, journey binding, the mode stamps).
  *
  * All heavy logic lives in the TypeScript core, reached through the `mirror`
  * bin that ships beside this file (`bin/mirror.js`). This extension is a thin
@@ -35,6 +55,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(/\/$/, "");
@@ -199,26 +220,48 @@ type MirrorStatusContext = {
 };
 
 /**
- * One registration per Pi process. Pi can reach this file twice -- as the
- * project's `.pi/extensions/` inside the checkout and as a personal package
- * installed from `npm root -g`, which `npm link` makes the same file under
- * two paths -- and two registrations would log every turn twice. The guard is
- * process-scoped, not module-scoped, because two paths are two module
- * instances (CV22.DS10.US3 plateau 2, the quality-assurance finding).
+ * One extension, reached twice. Pi can reach this file as the project's
+ * `.pi/extensions/` inside the checkout AND as a personal package installed
+ * from `npm root -g`, which `npm link` makes the same file under two paths:
+ * two module instances in one process (CV22.DS10.US3 plateau 2). Which of
+ * them Pi keeps is Pi's: 1.4.0 dedupes the two by their real path and keeps
+ * the one it loaded second; an older Pi kept both. A "register once per
+ * process" guard chose the first -- and on 1.4.0 that was the instance Pi
+ * dropped, so the checkout's Pi had no handlers at all (found by CV9.DS8.US5's
+ * live walk). So every instance registers, and the guard is on the EVENT: the
+ * handled set is process-scoped, and the first instance to see an event
+ * object handles it, the other returns. Pi hands every registration the same
+ * event object (its documented in-place mutation of `systemPromptOptions`
+ * depends on it), which is what makes the set a guard.
  */
-const LOADED_KEY = "__mirrorLoggerRegistered";
+const HANDLED_KEY = "__mirrorLoggerHandledEvents";
 
 export default function (pi: ExtensionAPI) {
 	const globals = globalThis as Record<string, unknown>;
-	if (globals[LOADED_KEY]) {
-		try {
-			appendFileSync(LOG_FILE, `${new Date().toISOString()} [INFO] second registration skipped: ${import.meta.url}\n`);
-		} catch {
-			// never block Pi
+	const handled = (globals[HANDLED_KEY] ??= new Map<string, WeakSet<object>>()) as Map<
+		string,
+		WeakSet<object>
+	>;
+	/**
+	 * The handler, run by the first registration an event reaches. `slot` names
+	 * the handler, not the event: this file registers two handlers on
+	 * `before_agent_start`, and each must see the event once.
+	 */
+	function once<E, C, R>(slot: string, handler: (event: E, ctx: C) => R): (event: E, ctx: C) => R | undefined {
+		let seen = handled.get(slot);
+		if (!seen) {
+			seen = new WeakSet<object>();
+			handled.set(slot, seen);
 		}
-		return;
+		const set = seen;
+		return (event, ctx) => {
+			if (event !== null && typeof event === "object") {
+				if (set.has(event)) return undefined;
+				set.add(event);
+			}
+			return handler(event, ctx);
+		};
 	}
-	globals[LOADED_KEY] = import.meta.url;
 
 	// --- Helpers ---
 
@@ -347,19 +390,118 @@ export default function (pi: ExtensionAPI) {
 	 */
 	const pendingUserLog = new Map<string, Promise<void>>();
 
-	function enqueueUserLog(sessionId: string, args: string[]): void {
+	/**
+	 * One front-door process on the session's chain: spawned when the link
+	 * before it has exited, its stdout returned to the caller. A failure settles
+	 * the chain all the same and reads as empty stdout (`runMirror` swallows).
+	 */
+	function runOnChain(sessionId: string, args: string[]): Promise<string> {
 		const prior = pendingUserLog.get(sessionId) ?? Promise.resolve();
-		const next = prior.then(() => runMirror(args)).then(
-			() => undefined,
-			() => undefined,
+		const stdout = prior.then(() => runMirror(args));
+		pendingUserLog.set(
+			sessionId,
+			stdout.then(
+				() => undefined,
+				() => undefined,
+			),
 		);
-		pendingUserLog.set(sessionId, next);
+		return stdout.then(
+			(out) => out,
+			() => "",
+		);
+	}
+
+	function enqueueUserLog(sessionId: string, args: string[]): void {
+		void runOnChain(sessionId, args);
+	}
+
+	/**
+	 * CV9.DS8.US5: the turn through the one doorman. `mirror doorman` decides
+	 * nothing, the full folder, or a delta from the prompt and the session's
+	 * state (`ts/src/mirror/doorman.ts`, DS8's policy); this extension decides
+	 * nothing itself and carries the answer. Awaited: the turn cannot start
+	 * before the block exists. Outside Mirror Mode the doorman reads and exits
+	 * with nothing -- one process, no snapshot, no embedding, no context (0.21 s
+	 * on a 61 MB home, measured 2026-10-25).
+	 *
+	 * On the chain AHEAD of the `user-prompt` logger: the logger's first-turn
+	 * upsert rebuilds the whole `runtime_sessions` row from what it read, and
+	 * overlapping the doorman's full load it would write back `mirror_active = 0`
+	 * and a null persona. The doorman's process has exited before the logger's is
+	 * spawned, so it does not race. The prompt is truncated as the payload is:
+	 * the explicit form is at its start, routing and the embedding do not need
+	 * the tail, and an untruncated paste would fail the exec on ARG_MAX --
+	 * silently, and the skill would load twice.
+	 */
+	function deliverMirrorContext(sessionId: string, prompt: string): Promise<string> {
+		return runOnChain(sessionId, [
+			"mirror",
+			"doorman",
+			"--prompt",
+			truncate(prompt),
+			"--session-id",
+			sessionId,
+		]);
 	}
 
 	async function settleUserLog(sessionId: string): Promise<void> {
 		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;
@@ -478,13 +620,16 @@ export default function (pi: ExtensionAPI) {
 
 	// --- dynamic resources → installed external Pi skills ---
 
-	pi.on("resources_discover", async () => {
-		const skillPaths = getInstalledPiSkillPaths();
-		if (skillPaths.length > 0) {
-			log("INFO", `resources_discover: loaded ${skillPaths.length} installed Pi external skill(s)`);
-		}
-		return { skillPaths };
-	});
+	pi.on(
+		"resources_discover",
+		once("resources_discover", async () => {
+			const skillPaths = getInstalledPiSkillPaths();
+			if (skillPaths.length > 0) {
+				log("INFO", `resources_discover: loaded ${skillPaths.length} installed Pi external skill(s)`);
+			}
+			return { skillPaths };
+		}),
+	);
 
 	// --- 0. the Operating Instructions, for a session Pi did not open in the tree ---
 	//
@@ -495,7 +640,7 @@ export default function (pi: ExtensionAPI) {
 	// a Mirror session (CV22.DS10.US3 D13). So the extension appends the file
 	// it ships with, unless Pi already loaded that very file.
 
-	pi.on("before_agent_start", async (event) => {
+	pi.on("before_agent_start", once("operating_instructions", async (event) => {
 		const files = event.systemPromptOptions.contextFiles;
 		if (files.some((file) => _isOurAgentsFile(file.path))) return;
 		let content: string;
@@ -508,7 +653,7 @@ export default function (pi: ExtensionAPI) {
 		if (files.some((file) => file.content === content)) return;
 		files.push({ path: AGENTS_FILE, content });
 		log("INFO", `operating instructions appended from ${AGENTS_FILE}`);
-	});
+	}));
 
 	// --- 1. session_start → unmute + welcome + status line in one process ---
 	//
@@ -517,8 +662,14 @@ export default function (pi: ExtensionAPI) {
 	// the composite runs them in one process, write first. Maintenance stays
 	// detached. Fires on startup, reload, new, resume, and fork alike.
 
-	pi.on("session_start", async (_event, ctx) => {
+	pi.on("session_start", once("session_start", async (_event, ctx) => {
 		log("INFO", "session_start fired");
+		// The session's name, for the model's own `mirror` commands (CV9.DS8.US5;
+		// see the header). Fires again on `/new`, `/resume`, and `/fork`, with the
+		// new file; the shutdown before it cleared the old one.
+		const namedSession = ctx.sessionManager.getSessionFile();
+		if (namedSession) process.env.MIRROR_SESSION_ID = namedSession;
+		else delete process.env.MIRROR_SESSION_ID;
 		if (ctx.hasUI) {
 			ctx.ui.setStatus("mirror", "◇ Mirror · starting… maintenance will continue in background");
 		}
@@ -556,37 +707,76 @@ export default function (pi: ExtensionAPI) {
 			setMirrorStatus(ctx, (envelope?.statusLine ?? "").trim());
 		}
 		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", once("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", once("prompt", 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;
+
+		// The doorman first, awaited (CV9.DS8.US5): Mirror's context before the
+		// model, on the turn that asks for it.
+		const block = await deliverMirrorContext(sessionId, prompt);
+
+		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 ---
+		if (!block) return;
+		log("INFO", `mirror-context (turn ${turnId}): ${block.length} chars delivered`);
+		// Pi adds it to this run after the user message and hands it to the model
+		// as a user-role message; its first line says the runtime, not the person,
+		// is speaking, and the `mm-mirror` skill reads that line as delivery (TS3).
+		// Not displayed: the person sees the mirror's reply, not the plumbing.
+		return { message: { customType: "mirror-context", content: block, display: false } };
+	}));
+
+	// --- 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) => {
+	pi.on("agent_end", once("agent_end", async (event, ctx) => {
 		const sessionId = ctx.sessionManager.getSessionFile() ?? null;
 		if (!sessionId) return;
 
@@ -610,30 +800,69 @@ 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);
+	}));
 
-		const combined = assistantTexts.join("\n\n---\n\n");
-		const content = truncate(combined);
+	// --- 5. agent_settled → the prompt's whole reply to `stop` ---
 
-		// The user message's process has exited before this one is spawned.
+	// `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> | undefined,
+	) => void;
+
+	onEvent("agent_settled", once("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 ---
+	// --- 5b. session_compact → the folder left the transcript (CV9.DS8.US5) ---
+	//
+	// A delta's premise is that the identity layers sit in the transcript. Pi
+	// compacts on its own (threshold, overflow) and on `/compact`; after that
+	// the folder is a summary. The core is told, on the chain and not awaited;
+	// the next ordinary turn in Mirror Mode is full again, routed from its prompt.
+
+	pi.on(
+		"session_compact",
+		once("session_compact", async (_event, ctx) => {
+			const sessionId = ctx.sessionManager.getSessionFile() ?? null;
+			if (!sessionId) return;
+			log("INFO", "session_compact: the doorman forgets what the transcript held");
+			enqueueUserLog(sessionId, ["mirror", "doorman", "--forget", "--session-id", sessionId]);
+		}),
+	);
+
+	// --- 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.
 
-	pi.on("session_shutdown", async (_event, ctx) => {
+	pi.on("session_shutdown", once("session_shutdown", async (_event, ctx) => {
 		const sessionId = ctx.sessionManager.getSessionFile() ?? null;
+		// Nothing inherits a stale name between sessions (CV9.DS8.US5).
+		delete process.env.MIRROR_SESSION_ID;
 
 		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]);
@@ -642,5 +871,5 @@ export default function (pi: ExtensionAPI) {
 
 		// The dated zip backup answers from TypeScript (CV22.DS7.TS1).
 		await runMirror(["backup", "--silent"]);
-	});
+	}));
 }

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/.pi/skills/mm-mirror/SKILL.md

@@ -12,8 +12,18 @@ determines when to activate it; this skill defines how.
 ---
 
 > ⛔ **HARD CONSTRAINT**
-> Never produce a Mirror Mode response without first running `mirror mirror load`.
-> No exceptions. Load first. Always.
+> 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 (the hook or the extension) 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: load first. Always.
 
 ---
 
@@ -31,8 +41,10 @@ determines when to activate it; this skill defines how.
 
 ## 1. Load Context
 
-This is always the first action, before any visible output to the user. For a
-pure mode-switch request such as `volte para o modo mirror`, use the full switch
+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. For a pure
+mode-switch request such as `volte para o modo mirror`, use the full switch
 request as the query.
 
 ```bash
@@ -68,6 +80,12 @@ from scratch unless the command failed to render it; copy the rendered surface
 from the command output. Treat it as part of the visible mode change, separate
 from the answer itself.
 
+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.
+
 Mirror Mode surface should orient the user around:
 
 - identity
@@ -76,8 +94,9 @@ Mirror Mode surface should orient the user around:
 - persona routing examples (`when the topic asks: persona_1, persona_2, persona_3 and N more available`)
 - available lenses: `◌ Mirror Mode`, `■ Builder Mode`, `△ Explorer Mode`, `☾ Soul Mode`
 
-Activated personas use `✦ Persona:`. Do not reuse the Mirror identity symbol
-`◇` for personas.
+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. Answer
 

package/README.md

@@ -60,8 +60,8 @@ This is not a chatbot with memory. This is a mirror — and yours.
 
 ## How It Works
 
-Local-first. SQLite. Five supported runtimes: Pi, Claude Code, Codex,
-Antigravity, Grok Build. One TypeScript core, run by Node.js. Jungian architecture: Self, Ego,
+Local-first. SQLite. [Five supported runtimes](docs/product/specs/runtime-interface/index.md#parity-matrix):
+Pi, Claude Code, Codex, Antigravity, Grok Build. One TypeScript core, run by Node.js. Jungian architecture: Self, Ego,
 Personas, Shadow.
 Context-activated modes — Mirror, Builder, Explorer, and Soul. The identity lives
 in your machine, not a server.
@@ -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.37.0 — The Mirror Stays in the Conversation](v0.37.0.md) — minor release closing CV9.DS8 and, with CV21.DS11, CV21: on Pi, Claude Code, Codex, and Antigravity one doorman in the core puts Mirror's context before the model on every turn of Mirror Mode, all of it on the turn Mirror Mode starts and then the persona and memories each question calls for; an explicit turn loads once; one signature, `◇ persona-name`; Pi reaches L4, measured live. One parity matrix in the runtime interface contract, sourced and held by a test. Codex, Antigravity, and Grok Build need their plugin copy brought level. Migration 018, applied on its own.
+- [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.