mirror-mind 0.34.0 → 0.35.0

package/plugins/mirror-mind/mcp_config.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "mirror-mind": {
+      "command": "/bin/sh",
+      "args": [
+        "-c",
+        "mmbin=\"\"; [ -n \"$MIRROR_BIN\" ] && [ -x \"$MIRROR_BIN/mirror\" ] && mmbin=\"$MIRROR_BIN/mirror\"; [ -n \"$mmbin\" ] || mmbin=\"$(command -v mirror 2>/dev/null)\"; for mmdir in \"$HOME/.nvm/current/bin\" /opt/homebrew/bin /usr/local/bin; do [ -n \"$mmbin\" ] && break; [ -x \"$mmdir/mirror\" ] && mmbin=\"$mmdir/mirror\"; done; [ -n \"$mmbin\" ] || { echo \"mirror-mind: mirror not found on PATH; the MCP server cannot start. Install mirror-mind (npm install -g mirror-mind) or set MIRROR_BIN to its bin directory.\" >&2; exit 1; }; mmnode=\"$MIRROR_NODE\"; [ -n \"$mmnode\" ] && [ -x \"$mmnode\" ] || mmnode=\"$(command -v node 2>/dev/null)\"; for mmdir in \"$(dirname \"$mmbin\")\" \"$HOME/.nvm/current/bin\" /opt/homebrew/bin /usr/local/bin; do [ -n \"$mmnode\" ] && break; [ -x \"$mmdir/node\" ] && mmnode=\"$mmdir/node\"; done; [ -n \"$mmnode\" ] || { echo \"mirror-mind: node not found on PATH; the MCP server cannot start. Set MIRROR_NODE.\" >&2; exit 1; }; exec \"$mmnode\" \"$mmbin\" mcp"
+      ]
+    }
+  }
+}

package/plugins/mirror-mind/plugin.json

@@ -0,0 +1,4 @@
+{
+  "name": "mirror-mind",
+  "description": "Mirror Mind — local-first memory and identity for agentic runtimes."
+}

package/plugins/mirror-mind/rules/AGENTS.md

@@ -0,0 +1,189 @@
+# Mirror Mind — Operating Instructions
+
+<!-- This file ships in the mirror-mind package and is read by every runtime:
+     Pi and Codex read it from the project root natively, Claude Code through
+     the @AGENTS.md import in CLAUDE.md, Antigravity as the plugin's rules, and
+     an installed package's Pi session receives it from the extension
+     (CV22.DS10.US3, D13).
+     It holds nothing about this repository; that is CLAUDE.md's part. -->
+
+---
+
+## Mirror Operating Instructions
+
+Applies to all sessions, regardless of project.
+
+### Operating Modes
+
+The mirror operates in four modes, chosen automatically based on context:
+Mirror, Builder, Explorer, and Soul.
+
+Each skill below is named three ways: `/mm-<skill>` in Pi, `$mm-<skill>` in
+Codex, `/mm:<skill>` in Claude Code. A **plugin** install prefixes the plugin's
+name — `/mirror-mind:mm:<skill>` in Claude Code's menu and in Antigravity,
+`$mirror-mind:mm:<skill>` in Codex, `mirror-mind:mm-<skill>` as the skill's own
+name — and the forms below refer to the same skill.
+
+**Mirror Mode** — activate for: life decisions, feelings, business strategy,
+writing, mentoring, health, existential questions, sensemaking, psychological
+tensions, class preparation, product launches, or any topic asking for personal
+reflection or positioning.
+
+How to operate: load the mirror skill (`/mm-mirror`, `$mm-mirror`, or
+`/mm:mirror`). Load identity, route persona, search attachments, answer in first
+person, and record the response.
+
+**Builder Mode** — activate for: code, project structure, YAML editing, bugs,
+implementation, architecture, or any software engineering task.
+
+How to operate: read code, edit files, run commands, propose technical
+solutions, keep docs updated when code changes. For a journey, use `/mm-build
+<slug>` / `$mm-build <slug>` / `/mm:build <slug>` — loads journey context and
+project docs.
+
+**Explorer Mode** — activate for the uncertain middle before construction:
+exploring a possibility space, holding uncertainty before committing to build,
+developing an Exploratory Story, surfacing attractors, proposing small
+experiments, or preparing a Builder handoff.
+
+How to operate: use `/mm-explore <slug>` / `$mm-explore <slug>` / `/mm:explore
+<slug>` to activate Explorer Mode for a journey and resume the active Exploratory
+Story when one exists. Follow `.pi/skills/mm-explore/SKILL.md`: render required
+story surfaces before interpretation, thicken the story as the narrative changes,
+and keep exploration durable. Explorer Mode preserves uncertainty — it does not
+implement. For operational mutation requests, name the `△ EXPLORER → BUILDER
+BOUNDARY` and route them through Builder Mode via an explicit handoff. Deactivate
+with `/mm-explore deactivate`, which returns to Mirror Mode while preserving
+sticky journey context.
+
+**Soul Mode** — activate when the user asks to enter Soul Mode, open Soul Mode,
+or continue an active Soul Mode ritual.
+
+How to operate: use `/mm-soul [slug]` / `$mm-soul [slug]` / `/mm:soul [slug]`
+to render the entry surface. While Soul Mode is active, follow
+`.pi/skills/mm-soul/SKILL.md`: listen to the user's answer as living field,
+withhold Possible Listenings when the material is thin, and when living matter
+appears call the front door's `soul listen ...` (the exact invocation is in the
+skill) to render the Possible Listenings surface at the end of the response. This renderer call is required
+Soul Mode behavior, not optional tool use. Soul Mode must not mutate files,
+implement stories, run implementation commands, package releases, or change
+project state. For operational requests, name the `☾ SOUL → BUILDER BOUNDARY`
+and ask whether to switch to Builder Mode for the same journey.
+
+Builder activation boundary: activating Builder Mode or loading a journey is
+context setup only. After loading the context and required docs, stop and ask
+what work should be done next. Do not edit files, create tests, run
+implementation, start TDD, or mutate project state until the user gives an
+explicit implementation or documentation instruction, such as implement, fix,
+edit, create, run tests, or names a specific story to execute. Context
+activation is not execution consent.
+
+Ariad surface transport invariant: when command output contains marked Ariad
+surface blocks (`<<<ARIAD:...>>>` through `<<<END:...>>>`), preserve every marked
+block verbatim in the assistant response before commentary. Do not summarize,
+translate, reorder, trim, rewrap, re-indent, reformat, or replace marked surfaces
+with prose. This is a general rendering rule for Ariad surfaces, not a
+phase-specific behavior.
+
+**Ambiguity:** if the mode is unclear, ask whether the user wants personal
+reflection or project construction.
+
+**Journey Status** — shortcut within Mirror Mode. Activate when the user asks
+"How are we doing?", "What's the status of X?", or any question about progress
+or roadmap. Dispatch to `/mm-journey` or `/mm-journeys`. When the user asks for
+the journey list in natural language, use `/mm-journeys` and preserve its
+hierarchical rendering without flattening or reformatting it.
+
+**Commits:** use descriptive English commit messages. Explain the WHY, not just
+what was done. Prefer small commits with clear review boundaries.
+
+### Ego-Persona Model
+
+The mirror has one voice: the ego. Personas are specialized lenses activated by
+the ego according to context.
+
+**Automatic routing:** activate a persona when the topic clearly belongs to a
+specialized domain, the depth required exceeds the generic ego repertoire, or
+the user explicitly asks for a persona.
+
+**Routing protocol:** persona routing is data-driven. Each persona in the
+database carries `routing_keywords` and a routing descriptor. At runtime,
+`detectPersona` (`ts/src/persona/detectPersona.ts`) scores the query against
+those keywords. If no persona scores above threshold, the ego answers alone. To
+inspect active routing:
+`mirror detect-persona "<query>"`.
+
+**Signature format:**
+
+When the ego answers alone — no signature.
+
+When a persona is active:
+```text
+◇ persona-name
+
+[first-person answer, unified voice]
+```
+
+When switching personas:
+```text
+◇ product-designer
+
+[analysis...]
+
+◇ therapist
+
+[reflection...]
+```
+
+Rules: `◇` plus persona name on its own line; voice stays first person and unified.
+
+### Hard Constraints
+
+- **Truth:** do not invent data. If uncertain, say so.
+- **Service:** intellectual partner, not task executor. Question, refine, align —
+  do not execute without thinking.
+
+### Available Skills
+
+**Core modes:**
+- `mm-mirror` — activates Mirror Mode — `.pi/skills/mm-mirror/SKILL.md`
+- `mm-build` — activates Builder Mode for a journey — `.pi/skills/mm-build/SKILL.md`
+- `mm-explore` — activates Explorer Mode for a journey — `.pi/skills/mm-explore/SKILL.md`
+- `mm-soul` — activates Soul Mode ritual entry — `.pi/skills/mm-soul/SKILL.md`
+
+**Journeys and tasks:**
+- `mm-journeys` — compact journey list — `.pi/skills/mm-journeys/SKILL.md`
+- `mm-journey` — detailed journey status — `.pi/skills/mm-journey/SKILL.md`
+- `mm-tasks` — task management by journey — `.pi/skills/mm-tasks/SKILL.md`
+- `mm-week` — weekly planning — `.pi/skills/mm-week/SKILL.md`
+
+**Memory and inspection:**
+- `mm-memories` — recorded memories — `.pi/skills/mm-memories/SKILL.md`
+- `mm-conversations` — recent conversations list — `.pi/skills/mm-conversations/SKILL.md`
+- `mm-recall` — load messages from a previous conversation — `.pi/skills/mm-recall/SKILL.md`
+
+**Content:**
+- `mm-journal` — personal journal entry — `.pi/skills/mm-journal/SKILL.md`
+
+**Identity:**
+- `mm-seed` — seed identity YAML files into the database — `.pi/skills/mm-seed/SKILL.md`
+- `mm-identity` — read and update identity in the database — `.pi/skills/mm-identity/SKILL.md`
+
+**Session control:**
+- `mm-mute` — toggle conversation logging — `.pi/skills/mm-mute/SKILL.md`
+- `mm-new` — start a new conversation — `.pi/skills/mm-new/SKILL.md`
+- `mm-discard` — discard the current conversation before quitting — `.pi/skills/mm-discard/SKILL.md`
+
+**Memory cultivation:**
+- `mm-consolidate` — scan memories for patterns and propose consolidation — `.pi/skills/mm-consolidate/SKILL.md`
+- `mm-shadow` — surface and promote shadow-layer observations — `.pi/skills/mm-shadow/SKILL.md`
+
+**Utilities:**
+- `mm-consult` — ask other LLMs through OpenRouter — `.pi/skills/mm-consult/SKILL.md`
+- `mm-backup` — memory database backup — `.pi/skills/mm-backup/SKILL.md`
+- `mm-welcome` — render the state-aware welcome card on demand — `.pi/skills/mm-welcome/SKILL.md`
+- `mm-release-notes` — show Mirror Mind release notes — `.pi/skills/mm-release-notes/SKILL.md`
+- `mm-update` — update the local Mirror runtime — `.pi/skills/mm-update/SKILL.md`
+- `mm-help` — list available commands — `.pi/skills/mm-help/SKILL.md`
+
+Full command reference: [REFERENCE.md](REFERENCE.md)

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

@@ -10,7 +10,7 @@ Activates Builder Mode for a specific journey. Loads identity context and projec
 
 ## Usage
 
-Pi and Gemini CLI:
+Pi:
 
 ```
 /mm-build <journey-slug>

package/ts/src/conversation/agyTranscript.ts

@@ -0,0 +1,105 @@
+// The agy transcript reader (CV21.DS7.TS3).
+//
+// Antigravity's hook payloads carry no prompt or reply text (DS12.TS3 L7),
+// so logging reads the JSONL transcript agy writes. The step shapes are
+// probed from real agy 1.4.2 transcripts (the US1/TS2/TS3 probe discipline;
+// evidence/transcript-shape-20261018.md):
+//
+//   * a user turn is a `USER_INPUT` step (`source: USER_EXPLICIT`) whose
+//     content string wraps the request in `<USER_REQUEST>…</USER_REQUEST>`,
+//     followed by `<ADDITIONAL_METADATA>…`;
+//   * the model's answer is the `PLANNER_RESPONSE` step(s) (`source: MODEL`).
+//     MOST of these are EMPTY — intermediate tool steps — so the reply is
+//     the non-empty response text in the turn, not every PLANNER_RESPONSE.
+//     (The plan guessed `AGENT_MESSAGE`; the probe corrected both the type
+//     and the emptiness.)
+//
+// A turn runs from one `USER_INPUT` to just before the next. `step_index` is
+// a monotonic per-conversation ordinal; `lastStepIndex` is the turn's
+// high-water mark, which the Stop handler stores so a re-fired Stop logs
+// nothing new.
+
+import { parseJsonl } from "#conversation/transcriptBackfill.ts";
+
+export interface AgyTurn {
+  readonly userText: string;
+  readonly replyText: string;
+  /** The highest step_index this turn logged: the idempotency high-water mark. */
+  readonly lastStepIndex: number;
+}
+
+function stringField(entry: unknown, key: string): string {
+  if (typeof entry !== "object" || entry === null) return "";
+  const value = (entry as Record<string, unknown>)[key];
+  return typeof value === "string" ? value : "";
+}
+
+function numberField(entry: unknown, key: string): number {
+  if (typeof entry !== "object" || entry === null) return -1;
+  const value = (entry as Record<string, unknown>)[key];
+  return typeof value === "number" ? value : -1;
+}
+
+const USER_REQUEST = /<USER_REQUEST>\s*([\s\S]*?)\s*<\/USER_REQUEST>/;
+
+/** The request body agy wraps the user's words in, or the whole string. */
+export function extractUserRequest(content: string): string {
+  const match = USER_REQUEST.exec(content);
+  return (match ? match[1] : content).trim();
+}
+
+/**
+ * Join the turn's non-empty reply parts into one string, the same rule the
+ * Claude reader's `assistantText` uses (trimmed, blank-line separated).
+ * Shared so "how parts become one reply" lives in one place.
+ */
+export function joinReplyParts(parts: readonly string[]): string {
+  return parts
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0)
+    .join("\n\n");
+}
+
+/**
+ * The transcript's completed turns, in order. Each pairs the user's request
+ * with the model's reply and carries the turn's high-water `step_index`.
+ * A turn with no reply text yet (the model has not answered) is omitted:
+ * the Stop handler logs it on the Stop that follows the answer.
+ */
+export function readAgyTurns(transcriptPath: string): AgyTurn[] {
+  let entries: unknown[];
+  try {
+    entries = parseJsonl(transcriptPath);
+  } catch {
+    return [];
+  }
+
+  const turns: AgyTurn[] = [];
+  let userText: string | null = null;
+  let replyParts: string[] = [];
+  let lastStepIndex = -1;
+
+  const flush = () => {
+    if (userText === null) return;
+    const replyText = joinReplyParts(replyParts);
+    if (replyText) turns.push({ userText, replyText, lastStepIndex });
+    userText = null;
+    replyParts = [];
+  };
+
+  for (const entry of entries) {
+    const type = stringField(entry, "type");
+    if (type === "USER_INPUT") {
+      flush();
+      userText = extractUserRequest(stringField(entry, "content"));
+      lastStepIndex = numberField(entry, "step_index");
+    } else if (type === "PLANNER_RESPONSE" && userText !== null) {
+      const content = stringField(entry, "content").trim();
+      const stepIndex = numberField(entry, "step_index");
+      if (stepIndex > lastStepIndex) lastStepIndex = stepIndex;
+      if (content) replyParts.push(content);
+    }
+  }
+  flush();
+  return turns;
+}

package/ts/src/conversation/commandTurn.ts

@@ -29,7 +29,7 @@
 // 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, the Gemini hook); the Pi
+// 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.
 
 const SKILL_SEGMENT = "[a-z][a-z0-9_-]*";

package/ts/src/conversation/deferredCloseTail.ts

@@ -5,8 +5,8 @@
 // (extraction, then title/summary/tags). Some runtimes give a SessionEnd hook
 // less time than one model call: Codex runs it synchronously under a 1 s
 // default (DS12.TS2 L2; DS2's live `/hooks` table), Grok under 1.5 s
-// (DS12.TS4). Pi and Gemini CLI already close without extraction at exit and
-// let the next session start extract (`session-end-pi`). On a runtime that
+// (DS12.TS4). Pi already closes without extraction at exit and
+// lets the next session start extract (`session-end-pi`). On a runtime that
 // bounds the hook, the shared Claude-family `session-end` does the same, and a
 // little more: it also skips the metadata finalization, and flags the
 // conversation so the next start's maintenance finishes it.

package/ts/src/conversation/logger.ts

@@ -417,7 +417,7 @@ export async function switchConversation(
  * Python `end_session`: close the bound conversation and deactivate.
  *
  * The session is deactivated BEFORE the tail, not after (CV21.DS4.TS2). A tail
- * cut by the runtime's bound (Codex 1 s, Grok 1.5 s, Gemini CLI 30 s) or a
+ * cut by the runtime's bound (Codex 1 s, Grok 1.5 s) or a
  * background hook that dies used to leave the session `active = 1`: the row
  * `guessRuntimeSessionId` reads as "the session", which is how another
  * runtime's agent wrote into a Codex conversation (DS12.TS2 L9).

package/ts/src/conversation/runtimePolicy.ts

@@ -40,11 +40,20 @@ export function sessionEndRunsLlmTail(interfaceName: string | null | undefined):
  *                (DS2). The session is still re-measured by the next story that
  *                depends on it.
  *
+ *   antigravity  1.4.2: agy exposes no SessionEnd hook at all (its contracts
+ *                are SessionStart, PreTool, PostTool, PreInvocation,
+ *                PostInvocation, Stop; CV21.DS7.TS2 probe). Stop fires at each
+ *                turn's end, never at session end, so nothing closes the
+ *                conversation at TUI exit — the same situation as Codex, reached
+ *                by a different absence. The agy Stop handler logs each turn and
+ *                leaves the conversation open (CV21.DS7.TS3); the orphan close
+ *                is what ends it, and the next SessionStart sweeps it.
+ *
  * For such a runtime, an open conversation idle past the orphan threshold is an
  * orphan even while its session is active, and the close deactivates the session
  * (`closeStaleOrphans`). Every other runtime's session ends with its TUI, and an
  * active session there means a person who may still be typing.
  */
 export function sessionOutlivesTui(interfaceName: string | null | undefined): boolean {
-  return interfaceName === "codex";
+  return interfaceName === "codex" || interfaceName === "antigravity";
 }

package/ts/src/docs/docsLint.ts

@@ -49,6 +49,14 @@ const FIXTURE_DIR_NAME = "fixtures";
 // itself has no `index.md`, by design. Not a broken link.
 const TEMPLATE_DIR_MARKER = "/roadmap/templates/";
 
+// Generated byte copies of a root document, each held equal to its source by
+// a guard (`claudePlugin.ts`: the plugin's `rules/AGENTS.md` is `AGENTS.md`'s
+// bytes, CV21.DS7.US1). Their links are the source's links, authored at the
+// repo root, so they resolve there -- a root-relative `REFERENCE.md` can never
+// exist under `rules/`, and skipping the file would hide a link the source
+// itself cannot resolve.
+const ROOT_COPIES = new Set(["plugins/mirror-mind/rules/AGENTS.md"]);
+
 export interface BrokenLink {
   readonly sourceFile: string;
   readonly line: number;
@@ -115,6 +123,11 @@ function isTemplatePlaceholder(sourceFile: string, targetPath: string): boolean
   return toPosix(sourceFile).includes(TEMPLATE_DIR_MARKER) && targetPath === "index.md";
 }
 
+/** The directory a file's relative links resolve from: its own, or the root for a root copy. */
+function linkBase(sourceFile: string, repoRoot: string): string {
+  return ROOT_COPIES.has(toPosix(relative(repoRoot, sourceFile))) ? repoRoot : dirname(sourceFile);
+}
+
 /** True for a `fixtures` directory nested under a `test`/`tests` one. */
 function isTestFixturePath(path: string): boolean {
   const parts = toPosix(path).split("/");
@@ -185,7 +198,7 @@ export function checkFile(sourceFile: string, repoRoot: string): BrokenLink[] {
     const anchorPart = hashIndex === -1 ? "" : link.slice(hashIndex + 1);
     if (isTemplatePlaceholder(sourceFile, pathPart)) continue;
 
-    const target = normalize(join(dirname(sourceFile), pathPart));
+    const target = normalize(join(linkBase(sourceFile, repoRoot), pathPart));
     if (!existsSync(target)) {
       problems.push({
         sourceFile: relSource,

package/ts/src/frontDoor/stdinSource.ts

@@ -10,8 +10,8 @@
 // A one-shot handoff rather than an argument because the hooks run the front
 // door in-process (`runFrontDoor`), through the same `main(argv)` every other
 // caller uses, and a payload does not belong in argv: argv is what `ps`
-// shows, and what the Gemini hooks already put a prompt into is the exception
-// this seam avoids repeating.
+// shows, and what the Gemini CLI hooks (retired by CV21.DS8.US1) put a prompt
+// into is the exception this seam avoids repeating.
 
 import { readFileSync } from "node:fs";
 

package/ts/src/guards/claudePlugin.ts

@@ -178,6 +178,71 @@ export function marketplaceJson(): string {
   return `${JSON.stringify(buildMarketplace(), null, 2)}\n`;
 }
 
+// --- the agy-native layer (CV21.DS7.US1) -------------------------------------
+//
+// Antigravity treats a directory as a NATIVE plugin only when a root
+// `plugin.json` marks it (or `.antigravity-plugin/`/`.gemini-plugin/`).
+// Without the marker, `agy plugin install` converts the Claude surfaces as an
+// extension and OVERWRITES a shipped root `hooks.json` with Claude's — the
+// probe on agy 1.4.2 showed both behaviors (evidence in the US1 story
+// package). With the marker, validation passes, our root `hooks.json`
+// survives staging, `mcpServers: 1 processed`, and the 25 skills ride along.
+//
+// The layer is four generated files at agy's documented paths: the marker,
+// the hooks skeleton (TS2 adds injection, TS3 adds logging), the MCP map
+// (DERIVED from the manifest's entry — one locator, every carrier), and
+// `rules/AGENTS.md` (agy merges `rules/` into the active rule set; the guard
+// comparing committed to generated bytes is the sync with `AGENTS.md`).
+
+/** The native-plugin marker. Claude Code and Codex read `.claude-plugin/`. */
+export function buildAgyPluginMarker(): Record<string, unknown> {
+  return { name: PLUGIN_NAME, description: PLUGIN_DESCRIPTION };
+}
+
+export function agyPluginMarkerJson(): string {
+  return `${JSON.stringify(buildAgyPluginMarker(), null, 2)}\n`;
+}
+
+/**
+ * The named hook with its handlers (CV21.DS7.TS2). Commands are relative:
+ * agy sets a handler's cwd to the directory holding `hooks.json`, and the
+ * wrappers live beside it in `agy/` (generated agy-form; the pre-invocation
+ * wrapper gates on stdin before Node is ever resolved, because
+ * `PreInvocation` fires before every model call and blocks the agent loop).
+ * Timeouts are explicit and small: the fast path is shell-instant, the slow
+ * path is one `mirror load`, and a hang here freezes the agent — which a
+ * user reads as "Antigravity broke", not "Mirror hung". `Stop` is TS3's.
+ */
+export function buildAgyHooks(): Record<string, unknown> {
+  return {
+    [PLUGIN_NAME]: {
+      enabled: true,
+      SessionStart: [{ type: "command", command: "agy/session-start.sh", timeout: 60 }],
+      PreInvocation: [{ type: "command", command: "agy/pre-invocation.sh", timeout: 15 }],
+      // CV21.DS7.TS3: Stop fires at each turn's end (agy has no SessionEnd);
+      // the handler reads the transcript and logs the turn as antigravity.
+      Stop: [{ type: "command", command: "agy/stop.sh", timeout: 30 }],
+    },
+  };
+}
+
+export function agyHooksJson(): string {
+  return `${JSON.stringify(buildAgyHooks(), null, 2)}\n`;
+}
+
+/** agy's `mcp_config.json`: the same `mcpServers` map the manifest carries. */
+export function buildAgyMcpConfig(): Record<string, unknown> {
+  return {
+    mcpServers: {
+      [PLUGIN_NAME]: { command: MCP_ENTRY.command, args: [...MCP_ENTRY.args] },
+    },
+  };
+}
+
+export function agyMcpConfigJson(): string {
+  return `${JSON.stringify(buildAgyMcpConfig(), null, 2)}\n`;
+}
+
 /**
  * The skill markdown file, matching `skill.md` case-insensitively.
  *
@@ -269,6 +334,15 @@ export function planGeneratedFiles(repoRoot: string): GeneratedFile[] {
       content: manifestJson(version),
     },
     { relativePath: MARKETPLACE_PATH, content: marketplaceJson() },
+    // The agy-native layer (CV21.DS7.US1).
+    { relativePath: join(PLUGIN_DIR, "plugin.json"), content: agyPluginMarkerJson() },
+    { relativePath: join(PLUGIN_DIR, "hooks.json"), content: agyHooksJson() },
+    { relativePath: join(PLUGIN_DIR, "mcp_config.json"), content: agyMcpConfigJson() },
+    {
+      relativePath: join(PLUGIN_DIR, "rules", "AGENTS.md"),
+      content: readFileSync(join(repoRoot, "AGENTS.md"), "utf8"),
+      source: "AGENTS.md",
+    },
     ...claudeCopies.values(),
     ...[...pluginSkills].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)).map(([, file]) => file),
   ];

package/ts/src/guards/packContents.ts

@@ -26,7 +26,6 @@ export const ALLOWED_PREFIXES: readonly string[] = [
   ".pi/extensions/",
   ".pi/skills/",
   ".claude/hooks/",
-  ".gemini/hooks/",
   "plugins/mirror-mind/",
 ];
 
@@ -56,8 +55,10 @@ export const REQUIRED_FILES: readonly string[] = [
   ".pi/extensions/mirror-logger.ts",
   ".pi/skills/mm-mirror/SKILL.md",
   ".claude/hooks/session-start.sh",
-  ".gemini/hooks/session-start.sh",
   "plugins/mirror-mind/hooks/hooks.json",
+  // CV21.DS7.US1: the agy-native layer's hooks file. A tarball cannot ship
+  // the skills without the layer Antigravity runs them beside.
+  "plugins/mirror-mind/hooks.json",
   ".agents/plugins/marketplace.json",
 ];
 

package/ts/src/guards/piSourcedSkills.ts

@@ -1,7 +1,7 @@
 // Skills with one body in every runtime (CR102).
 //
 // Most Mirror skills have two authored bodies. `.pi/skills/` serves Pi, and
-// through the `.agents/skills/` links Codex and Gemini CLI too. `.claude/skills/`
+// through the `.agents/skills/` links Codex too. `.claude/skills/`
 // serves Claude Code, and `claudePlugin.ts` copies it into the plugin. CR071
 // kept the two apart on purpose: Usage sections, example language, and in
 // `mm-soul` and `mm-mirror` whole lines that are true for one runtime only.

package/ts/src/guards/retiredSurfaces.ts

@@ -514,6 +514,37 @@ export const RETIRED: readonly RetiredSurface[] = [
     residueScope: ["ts/src/", "ts/scripts/"],
     exemptions: {},
   },
+  {
+    surfaceId: "gemini-cli",
+    story: "CV21.DS8.US1",
+    // The Gemini CLI integration: four generated wrappers under `.gemini/hooks`,
+    // the `gemini:*` hook family behind them, the two `mirror init` steps, and
+    // the Gemini smoke. Retired once DS7.US4 measured Antigravity at L4 on agy
+    // 1.4.2 -- a Gemini CLI user loses nothing by moving. `.gemini/` is an
+    // absent path and not merely an unallowed one because `mirror init` told
+    // users to write absolute paths into that directory into their
+    // `~/.gemini/settings.json`: a standing instruction to execute whatever a
+    // later release might ship there. This row is what keeps that from
+    // happening.
+    absentPaths: [".gemini/", "ts/src/hooks/gemini.ts", "scripts/smoke_gemini_cli.sh"],
+    // File and route names, never vocabulary: "gemini" is a living word (the
+    // extraction and consult models, Antigravity's own `~/.gemini/` home, the
+    // `gemini_cli` label on conversations already logged). The row landed in
+    // two steps: US1 carried the names only code and CI used, and
+    // CV21.DS8.US2 added the doc-facing ones when it cleared the runtime-facing
+    // docs, so no exemption was ever staged. Not `.gemini/settings.json` and
+    // not `~/.gemini`: that directory is Antigravity's home too, and the
+    // cutoff note names the file a Gemini CLI user edits.
+    forbiddenPatterns: [
+      "smoke_gemini_cli",
+      "geminiHooksSettings",
+      "hooks/gemini\\.ts",
+      "\\.gemini/hooks",
+      "gemini:(session-start|session-end|log-user|log-assistant)",
+      "gemini skills link",
+    ],
+    exemptions: {},
+  },
 ];
 
 export interface SurfaceProblem {