mirror-mind 0.34.0 → 0.36.0

package/ts/src/runtime/status.ts

@@ -17,10 +17,11 @@
 // the 2026-09-07 decision assigned to CV22.DS10.
 
 import { existsSync, readdirSync, realpathSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { basename, join, resolve } from "node:path";
 import { type Database, openDatabaseReadOnly } from "#db/database.ts";
 import { KNOWN_MIGRATION_IDS } from "#db/schemaState.ts";
 import { ExtensionError } from "#extensions/errors.ts";
+import { readExtensionPlugin } from "#extensions/extensionPlugin.ts";
 import { loadExtensionManifest } from "#extensions/manifest.ts";
 import { inspectMigrationFiles } from "#extensions/migrations.ts";
 import { type DbPathEnv, dbNameForEnv, resolveMirrorHome } from "#frontDoor/dbPath.ts";
@@ -61,6 +62,12 @@ export interface ExtensionHealth {
   unknown_migrations: string[];
 }
 
+export interface ExtensionPluginSummary {
+  name: string;
+  version: string;
+  skills: number;
+}
+
 export interface RuntimeStatusReport {
   version: string;
   /** How the running front door is installed (CV22.DS10.US3 plateau 4; US2 D3). */
@@ -73,6 +80,8 @@ export interface RuntimeStatusReport {
   core_migrations: CoreMigrationHealth;
   extensions: string[];
   extension_health: ExtensionHealth[];
+  /** The home's generated extensions plugin (CV21.DS5.US2), or null when none. */
+  extension_plugin: ExtensionPluginSummary | null;
   clone_role: MarkerValue;
   memory_env: string;
   update_channel: MarkerValue;
@@ -425,6 +434,7 @@ export function buildRuntimeStatus(options: BuildStatusOptions = {}): RuntimeSta
     core_migrations: inspectCoreMigrations(dbPath, dbExists),
     extensions: listInstalledExtensions(mirrorHome),
     extension_health: inspectExtensionHealth(mirrorHome, dbPath, dbExists),
+    extension_plugin: inspectExtensionPlugin(mirrorHome),
     clone_role: cloneRoleFor(install, root),
     memory_env: memoryEnv,
     update_channel: channelForReport(install, root, env, undefined, options.channel ?? null),
@@ -461,6 +471,18 @@ export function renderCoreMigrations(item: CoreMigrationHealth): string {
   return `Core migrations: attention needed (${detail})`;
 }
 
+/** The generated extensions plugin, read from its manifest; absent is null, not an error. */
+export function inspectExtensionPlugin(mirrorHome: string | null): ExtensionPluginSummary | null {
+  if (mirrorHome === null) return null;
+  const previous = readExtensionPlugin(mirrorHome);
+  if (previous === null) return null;
+  return {
+    name: `mirror-ext-${basename(mirrorHome)}`,
+    version: `0.1.${previous.generation}`,
+    skills: Object.keys(previous.files).filter((path) => path.endsWith("/SKILL.md")).length,
+  };
+}
+
 /** Port of `_render_extension_health`. */
 export function renderExtensionHealth(items: readonly ExtensionHealth[]): string[] {
   if (items.length === 0) return ["Extension health: ready (0 checked)"];
@@ -528,6 +550,11 @@ export function renderRuntimeStatus(
     lines.push("Installed extensions: 0");
   }
   lines.push(...renderExtensionHealth(report.extension_health));
+  // Printed only when the home has one, so a report without extensions reads as before.
+  if (report.extension_plugin) {
+    const { name, version, skills } = report.extension_plugin;
+    lines.push(`Extensions plugin: ${name} ${version} (${skills} skill${skills === 1 ? "" : "s"})`);
+  }
   lines.push(...renderCloneRoleLines(report.install, report.clone_role));
   lines.push(`Update channel: ${report.update_channel.value}`);
   if (report.update_channel.note) lines.push(`Update channel note: ${report.update_channel.note}`);

package/ts/src/runtime/update.ts

@@ -29,7 +29,11 @@ import { spawnSync } from "node:child_process";
 import { join } from "node:path";
 import { verifyBackupArchive } from "#runtime/backup.ts";
 import type { InstallKind } from "#runtime/installKind.ts";
-import { codexPluginCacheState, installedPluginVersion } from "#runtime/pluginWiring.ts";
+import {
+  codexPluginCacheState,
+  grokPluginCopyState,
+  installedPluginVersion,
+} from "#runtime/pluginWiring.ts";
 import { cloneStrategy, defaultGitRunner, type GitRunner } from "#runtime/strategies/clone.ts";
 import { defaultNpmRunner, type NpmRunner, packageStrategy } from "#runtime/strategies/package.ts";
 import type { statusAllowsUpdatePreflight } from "#runtime/updateGate.ts";
@@ -39,7 +43,7 @@ import {
   type UpdateResult,
   type UpdateStage,
 } from "#runtime/updatePipeline.ts";
-import { CODEX_PLUGIN_ADD_COMMAND } from "#runtime/wiring.ts";
+import { CODEX_PLUGIN_ADD_COMMAND, grokPluginReinstallCommand } from "#runtime/wiring.ts";
 import { commandOnPath } from "#util/paths.ts";
 import { PROGRAM } from "#util/program.ts";
 import { shellWord } from "#util/shellWord.ts";
@@ -431,15 +435,25 @@ export function postUpdateHints(
         : null;
   const home = env.HOME?.trim() || null;
   const codexHome = env.CODEX_HOME?.trim() || (home ? join(home, ".codex") : null);
-  if (installRoot && codexHome) {
-    const landed = installedPluginVersion(installRoot);
-    if (landed) {
-      const cache = codexPluginCacheState(codexHome, landed);
-      if (cache.state === "behind") {
-        hints.push(
-          `Codex's cached plugin is behind the update (${cache.newestCached} < ${landed}): run \`${CODEX_PLUGIN_ADD_COMMAND}\` to bring it level.`,
-        );
-      }
+  const grokHome = env.GROK_HOME?.trim() || (home ? join(home, ".grok") : null);
+  const landed = installRoot ? installedPluginVersion(installRoot) : null;
+  if (installRoot && codexHome && landed) {
+    const cache = codexPluginCacheState(codexHome, landed);
+    if (cache.state === "behind") {
+      hints.push(
+        `Codex's cached plugin is behind the update (${cache.newestCached} < ${landed}): run \`${CODEX_PLUGIN_ADD_COMMAND}\` to bring it level.`,
+      );
+    }
+  }
+  // CV21.DS10.US1: Grok copies the plugin too, and its update verb leaves a
+  // local-path copy as it is; the level-up is uninstall, then install with
+  // the path init printed.
+  if (installRoot && grokHome && landed) {
+    const copy = grokPluginCopyState(grokHome, landed);
+    if (copy.state === "behind") {
+      hints.push(
+        `Grok's copy of the plugin is behind the update (${copy.newestCopied} < ${landed}): run \`${grokPluginReinstallCommand(installRoot)}\` to bring it level.`,
+      );
     }
   }
 

package/ts/src/runtime/wiring.ts

@@ -17,12 +17,6 @@
 //               server (`claude plugin list` / `details`, 2.1.283). One step.
 //               The Operating Instructions arrive through the plugin's
 //               SessionStart hook (D13).
-//   Gemini CLI  `gemini skills link --consent <dir>` links every skill in the
-//               directory into `~/.gemini/skills/` (0.61.0; a nested directory
-//               symlink is NOT discovered, the user tier is one level deep),
-//               and hooks live in `~/.gemini/settings.json`, absolute paths.
-//               Two steps. The Operating Instructions arrive through the
-//               SessionStart hook (D13).
 //   Codex       `codex plugin marketplace add <root>` reads the package's
 //               `.agents/plugins/marketplace.json`, and `codex plugin add
 //               mirror-mind@mirror-mind` copies the plugin into Codex's cache
@@ -33,11 +27,29 @@
 //               developer message (L4). Until DS4.US1 the two steps were a
 //               skills link and an AGENTS.md link, with sessions run through
 //               the shipped wrapper.
+//   Antigravity `agy plugin install <plugin dir>` stages the plugin with its
+//               agy-native layer in one step (CV21.DS7.US1, agy 1.4.2).
+//   Grok Build  `grok plugin install <plugin dir> --trust` copies the plugin
+//               under `~/.grok/installed-plugins/` and enables it: its skills,
+//               the hooks, and the MCP server, with no prompt left to answer
+//               (CV21.DS10.US1, probed on grok 1.0.62). Then a link under
+//               `~/.grok/rules/` carries the Operating Instructions as a rule
+//               Grok loads in every project (~2.2k tokens by Grok's count):
+//               Grok shows a SessionStart hook's context on screen only and
+//               ignores a prompt hook's (DS12.TS4 L2/L3), so the plugin's
+//               session-start delivery of D13 does not reach its model. Two
+//               steps. The shapes not chosen -- the Claude link alone (skills,
+//               no hooks), a link in `~/.grok/plugins/` (loads nothing until
+//               a config entry is hand-written) -- are in decisions.md.
+//
+// Gemini CLI had an entry here (a skills link, then four hooks merged into
+// `~/.gemini/settings.json` by absolute path) until CV21.DS8.US1 retired the
+// integration; Antigravity is its successor.
 
 import { join } from "node:path";
 import { commandOnPath } from "#util/paths.ts";
 
-export type RuntimeName = "pi" | "claude" | "gemini" | "codex";
+export type RuntimeName = "pi" | "claude" | "codex" | "antigravity" | "grok";
 
 /**
  * The one Codex level-up command (CV21.DS4.TS6). Codex 0.163.0 has no
@@ -48,6 +60,29 @@ export type RuntimeName = "pi" | "claude" | "gemini" | "codex";
  */
 export const CODEX_PLUGIN_ADD_COMMAND = "codex plugin add mirror-mind@mirror-mind";
 
+/** Where the plugin directory lives below an installed package. */
+export function pluginDirectory(root: string): string {
+  return join(root, "plugins/mirror-mind");
+}
+
+/**
+ * The one Grok level-up command (CV21.DS10.US1). Grok copies a local-path
+ * plugin and keys the copy by the path STRING: `grok plugin update` is a
+ * no-op for it (it answers "local symlink, already live" over a real copy,
+ * grok 1.0.62), an install over the same string is refused as already
+ * installed, and a differently spelt string installs a second copy beside
+ * the first. So the level-up is uninstall, then install with the path `init`
+ * printed -- a function of the root, so `diagnose` and `update` cannot spell
+ * it differently (the CR071 lesson at the string level).
+ */
+export function grokPluginReinstallCommand(root: string): string {
+  return `grok plugin uninstall mirror-mind --confirm && ${grokPluginInstallCommand(root)}`;
+}
+
+function grokPluginInstallCommand(root: string): string {
+  return `grok plugin install "${pluginDirectory(root)}" --trust`;
+}
+
 export interface RuntimeWiring {
   /** The runtime, as a person names it. */
   readonly title: string;
@@ -57,24 +92,6 @@ export interface RuntimeWiring {
   readonly steps: readonly ((root: string) => readonly string[])[];
 }
 
-/** Gemini CLI's four hooks, as the user-level settings.json wants them. */
-function geminiHooksSettings(root: string): string {
-  const hook = (event: string, name: string, script: string) =>
-    `    "${event}": [{ "hooks": [{ "name": "mirror-${name}", "type": "command", "command": "${join(root, ".gemini/hooks", script)}", "timeout": 30000 }] }]`;
-  return [
-    "{",
-    '  "hooks": {',
-    [
-      hook("SessionStart", "session-start", "session-start.sh"),
-      hook("BeforeAgent", "log-user", "log-user.sh"),
-      hook("AfterAgent", "log-assistant", "log-assistant.sh"),
-      hook("SessionEnd", "session-end", "session-end.sh"),
-    ].join(",\n"),
-    "  }",
-    "}",
-  ].join("\n");
-}
-
 export const RUNTIME_WIRING: Readonly<Record<RuntimeName, RuntimeWiring>> = {
   pi: {
     title: "Pi",
@@ -85,22 +102,48 @@ export const RUNTIME_WIRING: Readonly<Record<RuntimeName, RuntimeWiring>> = {
     title: "Claude Code",
     command: "claude",
     steps: [
+      // `mkdir -p` first: a home that has never held a personal skill has no
+      // ~/.claude/skills/ yet, and the link alone fails there (CV21.DS5.US2's
+      // route, on the extensions plugin's step; the same line, paid here).
       (root) => [
-        `ln -s "${join(root, "plugins/mirror-mind")}" ~/.claude/skills/mirror-mind`,
+        `mkdir -p ~/.claude/skills && ln -s "${pluginDirectory(root)}" ~/.claude/skills/mirror-mind`,
         "(the plugin loads every session: its skills, the hooks, and the MCP server)",
       ],
     ],
   },
-  gemini: {
-    title: "Gemini CLI",
-    command: "gemini",
+  antigravity: {
+    title: "Antigravity",
+    command: "agy",
     steps: [
-      (root) => [`gemini skills link --consent "${join(root, ".pi/skills")}"`],
+      // CV21.DS7.US1, probed on agy 1.4.2: one command stages the 25 skills
+      // and the agy-native layer (the root plugin.json marker makes agy
+      // treat the directory as a native plugin; without it, install converts
+      // the Claude surfaces and overwrites the layer's hooks file). Per-turn
+      // injection and logging land with DS7's TS2/TS3; this line promises
+      // the install, nothing more.
+      (root) => [`agy plugin install "${root}/plugins/mirror-mind"`],
+    ],
+  },
+  grok: {
+    title: "Grok Build",
+    command: "grok",
+    steps: [
+      // CV21.DS10.US1, probed on grok 1.0.62: one command copies the plugin
+      // and enables it. Consent lives in the line: what --trust activates,
+      // and that Grok asks nothing afterwards (Codex's note says Codex asks
+      // once; Grok's must say it does not).
+      (root) => [
+        grokPluginInstallCommand(root),
+        "(--trust activates the plugin's hooks and MCP server, and Grok does not ask again;",
+        "Grok keeps a copy of the plugin, so after an update `mirror runtime diagnose`",
+        "names the command that brings it level)",
+      ],
+      // The Operating Instructions (D13) as a home-level rule. Grok loads
+      // every *.md under ~/.grok/rules/ in every project, link or file.
       (root) => [
-        "merge into ~/.gemini/settings.json:",
-        ...geminiHooksSettings(root)
-          .split("\n")
-          .map((line) => `  ${line}`),
+        `ln -s "${join(root, "AGENTS.md")}" ~/.grok/rules/mirror-mind.md`,
+        "(the Operating Instructions, loaded as a rule in every Grok session, in",
+        "every project: about 2.2k tokens per session)",
       ],
     ],
   },
@@ -118,7 +161,7 @@ export const RUNTIME_WIRING: Readonly<Record<RuntimeName, RuntimeWiring>> = {
   },
 };
 
-const ORDER: readonly RuntimeName[] = ["pi", "claude", "gemini", "codex"];
+const ORDER: readonly RuntimeName[] = ["pi", "claude", "codex", "antigravity", "grok"];
 
 /** The runtimes whose command is on the PATH, in display order. */
 export function detectRuntimes(
@@ -142,3 +185,74 @@ export function runtimeWiringLines(runtime: RuntimeName, root: string): string[]
   });
   return lines;
 }
+
+// ---------------------------------------------------------------------------
+// The per-home extensions plugin (CV21.DS5.US2). A Mirror home's installed
+// extensions reach the four plugin runtimes as one generated plugin per home,
+// `<home>/runtime/plugin/mirror-ext-<user>/`, in the canonical plugin's format
+// but carrying skills only (DS5.TS1's decision). Each runtime takes it the way
+// it takes the canonical plugin, and the three that copy it (Codex, agy, Grok)
+// need one command per change to bring the copy level — measured in TS1.
+// `mirror init` prints none of this: at init there is no extension. The
+// `extensions` verbs print the step a runtime still needs, and `runtime
+// diagnose` names the reinstall for a stale copy. Printing is not automating.
+
+export interface ExtensionPluginPaths {
+  /** The plugin directory: linked by Claude Code, installed by agy and Grok. */
+  readonly dir: string;
+  /** The marketplace root Codex adds: the plugin's parent, carrying `.agents/plugins/marketplace.json`. */
+  readonly marketplace: string;
+  /** `mirror-ext-<user>`: the plugin's name and its marketplace's. */
+  readonly name: string;
+}
+
+/** The consent line printed under Grok's step: what `--trust` would activate here, which is nothing. */
+export const EXTENSION_PLUGIN_GROK_TRUST_NOTE =
+  "(this plugin carries skills only — no hooks and no MCP server for --trust to activate)";
+
+/** The one-time wiring per runtime; Pi takes extensions through its own catalog and needs none. */
+export function extensionPluginWiringSteps(
+  runtime: RuntimeName,
+  paths: ExtensionPluginPaths,
+): string[] {
+  switch (runtime) {
+    case "claude":
+      // `mkdir -p` first: a home that has never held a personal skill has no
+      // ~/.claude/skills/ yet, and the link alone fails there (measured, US2's route).
+      return [`mkdir -p ~/.claude/skills && ln -s "${paths.dir}" ~/.claude/skills/${paths.name}`];
+    case "codex":
+      return [
+        `codex plugin marketplace add "${paths.marketplace}"`,
+        `codex plugin add ${paths.name}@${paths.name}`,
+      ];
+    case "antigravity":
+      return [`agy plugin install "${paths.dir}"`];
+    case "grok":
+      return [`grok plugin install "${paths.dir}" --trust`];
+    case "pi":
+      return [];
+  }
+}
+
+/**
+ * What brings a runtime's copy level after the plugin changed, measured in
+ * DS5.TS1: Codex re-adds at the same version when the marketplace serves the
+ * live directory; agy installs again; Grok refuses an install over the same
+ * path and must uninstall first. Claude Code links and has no copy.
+ */
+export function extensionPluginReinstallCommand(
+  runtime: RuntimeName,
+  paths: ExtensionPluginPaths,
+): string | null {
+  switch (runtime) {
+    case "claude":
+    case "pi":
+      return null;
+    case "codex":
+      return `codex plugin add ${paths.name}@${paths.name}`;
+    case "antigravity":
+      return `agy plugin install "${paths.dir}"`;
+    case "grok":
+      return `grok plugin uninstall ${paths.name} --confirm && grok plugin install "${paths.dir}" --trust`;
+  }
+}

package/.gemini/hooks/log-assistant.sh

@@ -1,85 +0,0 @@
-#!/usr/bin/env bash
-# Mirror Mind hook wrapper — GENERATED by scripts/generate_hook_wrappers.sh.
-# Edit the generator, never this file: every wrapper shares these bytes and
-# differs only in the hook name and in how it finds the Mirror entry
-# (CV22.DS10.TS5 decision D4; CV22.DS10.US3 decision D5).
-set -uo pipefail
-HOOK="gemini:log-assistant"
-
-# Resolve the tree from THIS FILE, never from the cwd: a runtime spawns hooks
-# from whatever directory the session is in. The tree is a checkout or the
-# installed package; the wrapper's depth to its root is the same in both.
-HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
-REPO_ROOT="$(cd "$HERE/../.." && pwd -P)"
-
-# A hook never fails the user's turn, and never fails in silence: when it
-# cannot do its job it appends ONE line to <mirror home>/hooks.log and exits 0.
-# The home is found the way the core finds it -- MIRROR_HOME, else
-# MIRROR_USER -- from the environment when set there, else from the tree's
-# .env when the wrapper is in a tree, else from the user's config file
-# (~/.config/mirror/env), in the core's order (US3, D3). A GUI launch carries
-# neither variable, and the first wrappers then wrote to a home nobody reads.
-env_file_value() {
-  [ -f "$2" ] || return 0
-  sed -n -E "s/^[[:space:]]*(export[[:space:]]+)?$1[[:space:]]*=[[:space:]]*//p" "$2" \
-    | tail -n 1 | tr -d "\"'\r"
-}
-env_value() {
-  local value=""
-  if [ -n "${!1+set}" ]; then printf '%s' "${!1}"; return; fi
-  [ -z "$REPO_ROOT" ] || value="$(env_file_value "$1" "$REPO_ROOT/.env")"
-  [ -n "$value" ] || value="$(env_file_value "$1" "${XDG_CONFIG_HOME:-$HOME/.config}/mirror/env")"
-  printf '%s' "$value"
-}
-note() {
-  local home user
-  home="$(env_value MIRROR_HOME)"
-  user="$(env_value MIRROR_USER)"
-  if [ -n "$home" ]; then
-    home="${home/#\~/$HOME}"
-  elif [ -n "$user" ]; then
-    home="$HOME/.mirror-minds/$user"
-    [ -d "$home" ] || [ ! -d "$HOME/.mirror/$user" ] || home="$HOME/.mirror/$user"
-  else
-    return 0
-  fi
-  mkdir -p "$home" 2>/dev/null \
-    && printf '%s %s: %s\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$HOOK" "$1" >> "$home/hooks.log" 2>/dev/null
-}
-
-ENTRY="$REPO_ROOT/bin/mirror-hook.js"
-
-# Find Node. /usr/bin/python3 exists on every macOS; node usually lives under
-# nvm or Homebrew and is NOT on the PATH of a GUI-launched runtime. The Python
-# hooks could end in `|| true` because they always found their interpreter;
-# the same silence here would hide a new failure — no logging, no inject, no
-# close tail — that a user would meet weeks later as "Mirror stopped
-# remembering". So an unresolvable Node is RECORDED, never swallowed. The
-# directory the entry was found in is searched first: an npm global bin holds
-# the `node` that installed the package beside `mirror-hook`, while a system
-# `/usr/local/bin/node` can be years older (CI's Ubuntu runner has one).
-NODE="${MIRROR_NODE:-}"
-if [ -z "$NODE" ] || [ ! -x "$NODE" ]; then
-  NODE="$(command -v node 2>/dev/null || true)"
-fi
-for candidate in "$(dirname "$ENTRY")/node" "$HOME/.nvm/current/bin/node" /opt/homebrew/bin/node /usr/local/bin/node; do
-  [ -n "$NODE" ] && break
-  [ -x "$candidate" ] && NODE="$candidate"
-done
-
-if [ -z "$NODE" ]; then
-  note "node not found on PATH; hook skipped. Set MIRROR_NODE."
-  exit 0
-fi
-
-# Not `exec`: the entry exits 0 whatever happens inside it, so a non-zero exit
-# means Node itself could not run the hook -- too old for the loader shim, or
-# it crashed. That used to vanish into a stderr no runtime shows (TS5 handoff
-# review, finding N1). No flags: the entry reads configuration and silences
-# its own warnings (US3, D3).
-"$NODE" "$ENTRY" "$HOOK" "$@"
-status=$?
-if [ "$status" -ne 0 ]; then
-  note "node exited $status before the hook finished ($NODE, $("$NODE" --version 2>/dev/null || echo 'version unknown')); Mirror needs Node 24 or later. Set MIRROR_NODE."
-fi
-exit 0

package/.gemini/hooks/log-user.sh

@@ -1,85 +0,0 @@
-#!/usr/bin/env bash
-# Mirror Mind hook wrapper — GENERATED by scripts/generate_hook_wrappers.sh.
-# Edit the generator, never this file: every wrapper shares these bytes and
-# differs only in the hook name and in how it finds the Mirror entry
-# (CV22.DS10.TS5 decision D4; CV22.DS10.US3 decision D5).
-set -uo pipefail
-HOOK="gemini:log-user"
-
-# Resolve the tree from THIS FILE, never from the cwd: a runtime spawns hooks
-# from whatever directory the session is in. The tree is a checkout or the
-# installed package; the wrapper's depth to its root is the same in both.
-HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
-REPO_ROOT="$(cd "$HERE/../.." && pwd -P)"
-
-# A hook never fails the user's turn, and never fails in silence: when it
-# cannot do its job it appends ONE line to <mirror home>/hooks.log and exits 0.
-# The home is found the way the core finds it -- MIRROR_HOME, else
-# MIRROR_USER -- from the environment when set there, else from the tree's
-# .env when the wrapper is in a tree, else from the user's config file
-# (~/.config/mirror/env), in the core's order (US3, D3). A GUI launch carries
-# neither variable, and the first wrappers then wrote to a home nobody reads.
-env_file_value() {
-  [ -f "$2" ] || return 0
-  sed -n -E "s/^[[:space:]]*(export[[:space:]]+)?$1[[:space:]]*=[[:space:]]*//p" "$2" \
-    | tail -n 1 | tr -d "\"'\r"
-}
-env_value() {
-  local value=""
-  if [ -n "${!1+set}" ]; then printf '%s' "${!1}"; return; fi
-  [ -z "$REPO_ROOT" ] || value="$(env_file_value "$1" "$REPO_ROOT/.env")"
-  [ -n "$value" ] || value="$(env_file_value "$1" "${XDG_CONFIG_HOME:-$HOME/.config}/mirror/env")"
-  printf '%s' "$value"
-}
-note() {
-  local home user
-  home="$(env_value MIRROR_HOME)"
-  user="$(env_value MIRROR_USER)"
-  if [ -n "$home" ]; then
-    home="${home/#\~/$HOME}"
-  elif [ -n "$user" ]; then
-    home="$HOME/.mirror-minds/$user"
-    [ -d "$home" ] || [ ! -d "$HOME/.mirror/$user" ] || home="$HOME/.mirror/$user"
-  else
-    return 0
-  fi
-  mkdir -p "$home" 2>/dev/null \
-    && printf '%s %s: %s\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$HOOK" "$1" >> "$home/hooks.log" 2>/dev/null
-}
-
-ENTRY="$REPO_ROOT/bin/mirror-hook.js"
-
-# Find Node. /usr/bin/python3 exists on every macOS; node usually lives under
-# nvm or Homebrew and is NOT on the PATH of a GUI-launched runtime. The Python
-# hooks could end in `|| true` because they always found their interpreter;
-# the same silence here would hide a new failure — no logging, no inject, no
-# close tail — that a user would meet weeks later as "Mirror stopped
-# remembering". So an unresolvable Node is RECORDED, never swallowed. The
-# directory the entry was found in is searched first: an npm global bin holds
-# the `node` that installed the package beside `mirror-hook`, while a system
-# `/usr/local/bin/node` can be years older (CI's Ubuntu runner has one).
-NODE="${MIRROR_NODE:-}"
-if [ -z "$NODE" ] || [ ! -x "$NODE" ]; then
-  NODE="$(command -v node 2>/dev/null || true)"
-fi
-for candidate in "$(dirname "$ENTRY")/node" "$HOME/.nvm/current/bin/node" /opt/homebrew/bin/node /usr/local/bin/node; do
-  [ -n "$NODE" ] && break
-  [ -x "$candidate" ] && NODE="$candidate"
-done
-
-if [ -z "$NODE" ]; then
-  note "node not found on PATH; hook skipped. Set MIRROR_NODE."
-  exit 0
-fi
-
-# Not `exec`: the entry exits 0 whatever happens inside it, so a non-zero exit
-# means Node itself could not run the hook -- too old for the loader shim, or
-# it crashed. That used to vanish into a stderr no runtime shows (TS5 handoff
-# review, finding N1). No flags: the entry reads configuration and silences
-# its own warnings (US3, D3).
-"$NODE" "$ENTRY" "$HOOK" "$@"
-status=$?
-if [ "$status" -ne 0 ]; then
-  note "node exited $status before the hook finished ($NODE, $("$NODE" --version 2>/dev/null || echo 'version unknown')); Mirror needs Node 24 or later. Set MIRROR_NODE."
-fi
-exit 0

package/.gemini/hooks/session-end.sh

@@ -1,85 +0,0 @@
-#!/usr/bin/env bash
-# Mirror Mind hook wrapper — GENERATED by scripts/generate_hook_wrappers.sh.
-# Edit the generator, never this file: every wrapper shares these bytes and
-# differs only in the hook name and in how it finds the Mirror entry
-# (CV22.DS10.TS5 decision D4; CV22.DS10.US3 decision D5).
-set -uo pipefail
-HOOK="gemini:session-end"
-
-# Resolve the tree from THIS FILE, never from the cwd: a runtime spawns hooks
-# from whatever directory the session is in. The tree is a checkout or the
-# installed package; the wrapper's depth to its root is the same in both.
-HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)"
-REPO_ROOT="$(cd "$HERE/../.." && pwd -P)"
-
-# A hook never fails the user's turn, and never fails in silence: when it
-# cannot do its job it appends ONE line to <mirror home>/hooks.log and exits 0.
-# The home is found the way the core finds it -- MIRROR_HOME, else
-# MIRROR_USER -- from the environment when set there, else from the tree's
-# .env when the wrapper is in a tree, else from the user's config file
-# (~/.config/mirror/env), in the core's order (US3, D3). A GUI launch carries
-# neither variable, and the first wrappers then wrote to a home nobody reads.
-env_file_value() {
-  [ -f "$2" ] || return 0
-  sed -n -E "s/^[[:space:]]*(export[[:space:]]+)?$1[[:space:]]*=[[:space:]]*//p" "$2" \
-    | tail -n 1 | tr -d "\"'\r"
-}
-env_value() {
-  local value=""
-  if [ -n "${!1+set}" ]; then printf '%s' "${!1}"; return; fi
-  [ -z "$REPO_ROOT" ] || value="$(env_file_value "$1" "$REPO_ROOT/.env")"
-  [ -n "$value" ] || value="$(env_file_value "$1" "${XDG_CONFIG_HOME:-$HOME/.config}/mirror/env")"
-  printf '%s' "$value"
-}
-note() {
-  local home user
-  home="$(env_value MIRROR_HOME)"
-  user="$(env_value MIRROR_USER)"
-  if [ -n "$home" ]; then
-    home="${home/#\~/$HOME}"
-  elif [ -n "$user" ]; then
-    home="$HOME/.mirror-minds/$user"
-    [ -d "$home" ] || [ ! -d "$HOME/.mirror/$user" ] || home="$HOME/.mirror/$user"
-  else
-    return 0
-  fi
-  mkdir -p "$home" 2>/dev/null \
-    && printf '%s %s: %s\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$HOOK" "$1" >> "$home/hooks.log" 2>/dev/null
-}
-
-ENTRY="$REPO_ROOT/bin/mirror-hook.js"
-
-# Find Node. /usr/bin/python3 exists on every macOS; node usually lives under
-# nvm or Homebrew and is NOT on the PATH of a GUI-launched runtime. The Python
-# hooks could end in `|| true` because they always found their interpreter;
-# the same silence here would hide a new failure — no logging, no inject, no
-# close tail — that a user would meet weeks later as "Mirror stopped
-# remembering". So an unresolvable Node is RECORDED, never swallowed. The
-# directory the entry was found in is searched first: an npm global bin holds
-# the `node` that installed the package beside `mirror-hook`, while a system
-# `/usr/local/bin/node` can be years older (CI's Ubuntu runner has one).
-NODE="${MIRROR_NODE:-}"
-if [ -z "$NODE" ] || [ ! -x "$NODE" ]; then
-  NODE="$(command -v node 2>/dev/null || true)"
-fi
-for candidate in "$(dirname "$ENTRY")/node" "$HOME/.nvm/current/bin/node" /opt/homebrew/bin/node /usr/local/bin/node; do
-  [ -n "$NODE" ] && break
-  [ -x "$candidate" ] && NODE="$candidate"
-done
-
-if [ -z "$NODE" ]; then
-  note "node not found on PATH; hook skipped. Set MIRROR_NODE."
-  exit 0
-fi
-
-# Not `exec`: the entry exits 0 whatever happens inside it, so a non-zero exit
-# means Node itself could not run the hook -- too old for the loader shim, or
-# it crashed. That used to vanish into a stderr no runtime shows (TS5 handoff
-# review, finding N1). No flags: the entry reads configuration and silences
-# its own warnings (US3, D3).
-"$NODE" "$ENTRY" "$HOOK" "$@"
-status=$?
-if [ "$status" -ne 0 ]; then
-  note "node exited $status before the hook finished ($NODE, $("$NODE" --version 2>/dev/null || echo 'version unknown')); Mirror needs Node 24 or later. Set MIRROR_NODE."
-fi
-exit 0