mirror-mind 0.33.4 → 0.35.0

package/ts/src/runtime/pluginWiring.ts

@@ -0,0 +1,135 @@
+// The plugin wiring readers (CV21.DS4.TS6).
+//
+// Two runtimes hold the plugin outside the install tree. Codex copies it into
+// a versioned cache (`$CODEX_HOME/plugins/cache/mirror-mind/mirror-mind/
+// <version>`; CV21.DS4.US1), so an npm update changes the install but not
+// that copy — the one wiring that goes stale. Claude Code links the plugin in
+// place (`~/.claude/skills/mirror-mind`), so its failure mode is a dangling
+// link, not a stale copy.
+//
+// Both readers take their roots as ARGUMENTS, always. The defaulting —
+// `$CODEX_HOME` else `~/.codex`, and the Claude home — happens once, at the
+// diagnose entry, from the env the caller already carries, never in here.
+// That is the CR123/128/137/142 lesson: a maintainer's machine has a real
+// ~/.codex and a real ~/.claude, and a reader that consults the environment
+// makes every fixture test machine-dependent exactly where maintainers work.
+//
+// Nothing here runs `codex` or mutates anything: Mirror reads directories and
+// prints a command for the person to run. On the installed Codex 0.163.0,
+// `codex plugin` has no update verb (add, list, marketplace, remove), so the
+// level-up command is the re-add — `CODEX_PLUGIN_ADD_COMMAND`, the same
+// constant `mirror init`'s wiring lines print (the CR071 lesson at the
+// string level).
+
+import { lstatSync, readdirSync, readFileSync, readlinkSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { compareSemver, parseSemver } from "#util/semver.ts";
+
+/** Where Codex keeps its copy, below a Codex home. */
+export const CODEX_PLUGIN_CACHE_SEGMENTS: readonly string[] = [
+  "plugins",
+  "cache",
+  "mirror-mind",
+  "mirror-mind",
+];
+
+export interface CodexCacheState {
+  /** `absent` covers no cache and a cache with no version-named entry. */
+  state: "absent" | "current" | "behind" | "ahead";
+  cachePath: string;
+  /** The newest version-named entry, by semver — never a string sort. */
+  newestCached: string | null;
+}
+
+/**
+ * Read the Codex plugin cache below `codexHome`, read-only. Entries whose
+ * names do not parse as versions (a partial download, an editor's leavings)
+ * are ignored; a cache holding only those claims nothing and reads as absent.
+ *
+ * `ahead` is a state, not a finding: `runtime update` refuses downgrades but
+ * `npm install -g mirror-mind@old` does not ask, and the person who
+ * downgraded on purpose needs no Codex advice from the older tree.
+ */
+export function codexPluginCacheState(
+  codexHome: string,
+  installedVersion: string,
+): CodexCacheState {
+  const cachePath = join(codexHome, ...CODEX_PLUGIN_CACHE_SEGMENTS);
+  let entries: string[];
+  try {
+    entries = readdirSync(cachePath);
+  } catch {
+    return { state: "absent", cachePath, newestCached: null };
+  }
+  let newest: string | null = null;
+  for (const entry of entries) {
+    if (parseSemver(entry)[0] < 0) continue;
+    try {
+      if (!statSync(join(cachePath, entry)).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    if (newest === null || compareSemver(entry, newest) > 0) newest = entry;
+  }
+  if (newest === null) return { state: "absent", cachePath, newestCached: null };
+  const order = compareSemver(newest, installedVersion);
+  const state = order < 0 ? "behind" : order > 0 ? "ahead" : "current";
+  return { state, cachePath, newestCached: newest };
+}
+
+export interface ClaudeLinkState {
+  /** `healthy` means the target reads — including a plain directory copy. */
+  state: "absent" | "healthy" | "dangling";
+  linkPath: string;
+  /** The link's own target when it is a symlink, else null. */
+  target: string | null;
+}
+
+/**
+ * Read the Claude Code wiring below `claudeHome`. Healthy means the target
+ * reads; a link that resolves to *another* install tree is deliberately
+ * healthy too (TS6's documented silence) — chasing where it points is a
+ * one-line amendment here if that case ever bites.
+ */
+export function claudePluginLinkState(claudeHome: string): ClaudeLinkState {
+  const linkPath = join(claudeHome, "skills", "mirror-mind");
+  let isLink = false;
+  try {
+    isLink = lstatSync(linkPath).isSymbolicLink();
+  } catch {
+    return { state: "absent", linkPath, target: null };
+  }
+  const target = isLink ? readlinkSync(linkPath) : null;
+  try {
+    statSync(linkPath);
+  } catch {
+    return { state: "dangling", linkPath, target };
+  }
+  return { state: "healthy", linkPath, target };
+}
+
+/**
+ * The install tree's own plugin version, from the generated manifest.
+ * `plugins/mirror-mind/.claude-plugin/plugin.json` is written by
+ * `claudePlugin.ts` from `packageVersion()`, and the guard holds the
+ * committed manifest equal to the generated one — the file is the authority,
+ * not an assumption. Reading it FROM DISK is also what makes a post-update
+ * hint honest: the process that ran the update is the old version's code,
+ * but the tree it reads has already landed the new one.
+ */
+export function installedPluginVersion(installRoot: string): string | null {
+  try {
+    const raw = readFileSync(
+      join(installRoot, "plugins", "mirror-mind", ".claude-plugin", "plugin.json"),
+      "utf8",
+    );
+    const parsed: unknown = JSON.parse(raw);
+    const version =
+      typeof parsed === "object" && parsed !== null
+        ? (parsed as Record<string, unknown>).version
+        : undefined;
+    return typeof version === "string" && version !== "" ? version : null;
+  } catch {
+    return null;
+  }
+}

package/ts/src/runtime/update.ts

@@ -26,8 +26,10 @@
 // chosen once, below; no step asks which lane it is in.
 
 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 { 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";
@@ -37,6 +39,7 @@ import {
   type UpdateResult,
   type UpdateStage,
 } from "#runtime/updatePipeline.ts";
+import { CODEX_PLUGIN_ADD_COMMAND } from "#runtime/wiring.ts";
 import { commandOnPath } from "#util/paths.ts";
 import { PROGRAM } from "#util/program.ts";
 import { shellWord } from "#util/shellWord.ts";
@@ -405,12 +408,42 @@ export function postUpdateHints(
   env: NodeJS.ProcessEnv,
   canExecute?: (path: string) => boolean,
 ): string[] {
-  if (install.kind !== "clone" || !result.success) return [];
-  if (commandOnPath(PROGRAM, env, canExecute) !== null) return [];
-  // A command the person will paste: the path is one shell word (CR104).
-  return [
-    `\`${PROGRAM}\` is not on the PATH: run \`npm link\` once in ${shellWord(install.repository)}, so the skills can call it.`,
-  ];
+  if (!result.success) return [];
+  const hints: string[] = [];
+
+  if (install.kind === "clone" && commandOnPath(PROGRAM, env, canExecute) === null) {
+    // A command the person will paste: the path is one shell word (CR104).
+    hints.push(
+      `\`${PROGRAM}\` is not on the PATH: run \`npm link\` once in ${shellWord(install.repository)}, so the skills can call it.`,
+    );
+  }
+
+  // CV21.DS4.TS6: Codex runs the plugin copy it cached at install, so the
+  // update that just landed did not reach it. The version authority is the
+  // LANDED version, read from the just-updated tree's plugin.json -- this
+  // process is the old version's code, and its own constant would read a
+  // just-staled cache as current.
+  const installRoot =
+    install.kind === "clone"
+      ? install.repository
+      : install.kind === "package"
+        ? install.root
+        : 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.`,
+        );
+      }
+    }
+  }
+
+  return hints;
 }
 
 function firstLine(text: string): string {

package/ts/src/runtime/wiring.ts

@@ -17,22 +17,36 @@
 //               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/skills/<dir>` is discovered recursively, and
-//               `~/.codex/AGENTS.md` is the global instructions file
-//               (`codex debug prompt-input`, 0.157.0). Two steps, and the
-//               session is run through the shipped wrapper, since Codex has
-//               no hooks this integration uses.
+//   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
+//               with its skills, hooks, and MCP server (0.162.1, CV21.DS12.TS2
+//               static 5-7; CV21.DS4.US1). Two steps. Codex asks once, at the
+//               next session, to trust the plugin's hooks (L1); the Operating
+//               Instructions then arrive through its SessionStart hook as a
+//               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).
+//
+// 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";
+
+/**
+ * The one Codex level-up command (CV21.DS4.TS6). Codex 0.163.0 has no
+ * plugin-update verb, so re-adding is how a cached plugin reaches the
+ * installed version. One constant so the wiring line `mirror init` prints
+ * and the recommendation `runtime diagnose` prints cannot disagree (the
+ * CR071 lesson at the string level).
+ */
+export const CODEX_PLUGIN_ADD_COMMAND = "codex plugin add mirror-mind@mirror-mind";
 
 export interface RuntimeWiring {
   /** The runtime, as a person names it. */
@@ -43,24 +57,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",
@@ -77,34 +73,34 @@ export const RUNTIME_WIRING: Readonly<Record<RuntimeName, RuntimeWiring>> = {
       ],
     ],
   },
-  gemini: {
-    title: "Gemini CLI",
-    command: "gemini",
+  antigravity: {
+    title: "Antigravity",
+    command: "agy",
     steps: [
-      (root) => [`gemini skills link --consent "${join(root, ".pi/skills")}"`],
-      (root) => [
-        "merge into ~/.gemini/settings.json:",
-        ...geminiHooksSettings(root)
-          .split("\n")
-          .map((line) => `  ${line}`),
-      ],
+      // 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"`],
     ],
   },
   codex: {
     title: "Codex",
     command: "codex",
     steps: [
-      (root) => [`ln -s "${join(root, ".pi/skills")}" ~/.codex/skills/mirror-mind`],
-      (root) => [
-        `ln -s "${join(root, "AGENTS.md")}" ~/.codex/AGENTS.md`,
-        "(or append that file to the ~/.codex/AGENTS.md you already have)",
-        `then start Codex through "${join(root, "scripts/codex-mirror.sh")}" instead of codex`,
+      (root) => [`codex plugin marketplace add "${root}"`],
+      () => [
+        CODEX_PLUGIN_ADD_COMMAND,
+        "(Codex asks once, at the next session, to trust the plugin's hooks; the plugin",
+        "then loads every session: its skills, the hooks, and the MCP server)",
       ],
     ],
   },
 };
 
-const ORDER: readonly RuntimeName[] = ["pi", "claude", "gemini", "codex"];
+const ORDER: readonly RuntimeName[] = ["pi", "claude", "codex", "antigravity"];
 
 /** The runtimes whose command is on the PATH, in display order. */
 export function detectRuntimes(

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