mirror-mind 0.34.0 → 0.35.0

package/ts/src/hooks/agy.ts

@@ -0,0 +1,229 @@
+// Antigravity hook entries (CV21.DS7.TS2).
+//
+// agy runs the plugin's `hooks.json` handlers with camelCase protojson on
+// stdin and reads JSON from stdout (`injectSteps`; a `systemMessage` step
+// nests its text, an `ephemeralMessage` is a plain string). The contracts
+// are committed bytes in CV21.DS7.US1's `evidence/` (agy 1.4.2).
+//
+// Two handlers:
+//
+//   * `agy:session-start` — turn conversation logging on, the posture every
+//     runtime's session-start shares, and answer `{}`. The Operating
+//     Instructions are NOT delivered here: `rules/AGENTS.md` carries them
+//     (US1), unless TS2's live route shows otherwise — the measured
+//     fallback would add an `injectSteps` `systemMessage` in this handler.
+//
+//   * `agy:pre-invocation` — inject Mirror Mode context once per user turn.
+//     `PreInvocation` fires before EVERY model call (32 times over two
+//     turns, DS12.TS3 L2), with `invocationNum` resetting to 0 at each user
+//     turn; protojson omits zero-valued fields, so an ABSENT invocationNum
+//     is 0. The generated wrapper already gates on this before Node is
+//     spawned; the gate here is defense in depth. The injection is an
+//     `ephemeralMessage` — dropped after the turn — for two reasons: the
+//     adapter re-injects per turn, so a persistent step would accumulate;
+//     and the content is identity and memory, so ephemeral is the
+//     data-minimizing choice against agy's stored trajectory.
+//
+// agy payloads carry no prompt or reply text (L7): there is no `--query`,
+// and the explicit Mirror form reaches the model through the skill (L4),
+// never through these hooks. The quiet session — a `conversationId` no
+// runtime session binds (every session until TS3 lands), or one bound with
+// Mirror Mode off — answers `{}`: Mirror on agy is invisible until invoked.
+//
+// Payload fields stay inert: `conversationId` flows only through array
+// argv, never a shell, and failures recorded in hooks.log are facts, never
+// payload text.
+
+import { readAgyTurns } from "#conversation/agyTranscript.ts";
+import { isCommandTurn } from "#conversation/commandTurn.ts";
+import { logAssistantMessage, logUserMessage } from "#conversation/logger.ts";
+import { resolveDbPath } from "#frontDoor/dbPath.ts";
+import { openLiveWriteDatabase } from "#frontDoor/liveBackup.ts";
+import { decodeMetadata, getRuntimeSession, upsertRuntimeSession } from "#mirror/runtimeSession.ts";
+import { newId, nowIso } from "#util/pyGenerators.ts";
+import { readMirrorState } from "./mirrorState.ts";
+import { noteHookFailure, runFrontDoor, runFrontDoorQuietly } from "./runtime.ts";
+
+/** agy's empty answer, which every path that injects nothing must print. */
+const EMPTY = "{}\n";
+
+interface AgyPayload {
+  readonly conversationId: string;
+  readonly invocationNum: number;
+  readonly transcriptPath: string;
+}
+
+/** The key under which the Stop handler stores its high-water step_index. */
+const HIGH_WATER_KEY = "agy_last_step_index";
+
+/**
+ * Parse agy's camelCase protojson payload. Anything malformed reads as the
+ * empty payload: a hook never fails the turn over stdin it did not write.
+ */
+export function parseAgyPayload(stdin: string): AgyPayload {
+  try {
+    const raw: unknown = JSON.parse(stdin);
+    if (typeof raw !== "object" || raw === null) {
+      return { conversationId: "", invocationNum: 0, transcriptPath: "" };
+    }
+    const record = raw as Record<string, unknown>;
+    return {
+      conversationId: typeof record.conversationId === "string" ? record.conversationId : "",
+      // protojson omits zero-valued fields: absent IS 0.
+      invocationNum: typeof record.invocationNum === "number" ? record.invocationNum : 0,
+      transcriptPath: typeof record.transcriptPath === "string" ? record.transcriptPath : "",
+    };
+  } catch {
+    return { conversationId: "", invocationNum: 0, transcriptPath: "" };
+  }
+}
+
+/**
+ * `SessionStart`: logging on, activate Mirror Mode for the session, answer
+ * the contract.
+ *
+ * Mirror Mode activation (CV21.DS7.US4 scope change). agy's `PreInvocation`
+ * carries no prompt text (DS12.TS3 L7), so the injection hook cannot detect
+ * the Mirror form to self-activate, and the `/mirror-mind:mm:*` skill runs
+ * `mirror load` as an agent command that cannot bind the agy session id. So
+ * SessionStart — the one hook that carries the `conversationId` at the start
+ * of the session — sets `mirror_active`, and the per-turn `PreInvocation`
+ * injection (built in TS2, gated on that flag) fires from then on. This
+ * matches Gemini CLI's always-on per-turn injection, the runtime Antigravity
+ * replaces; a session that never ran SessionStart stays quiet, which the
+ * negative probe pins.
+ */
+export async function agySessionStart(stdin: string): Promise<number> {
+  await runFrontDoorQuietly("agy:session-start", ["conversation-logger", "session-start"]);
+
+  const conversationId = parseAgyPayload(stdin).conversationId;
+  if (conversationId) {
+    try {
+      const dbPath = resolveDbPath([], process.env);
+      const db = openLiveWriteDatabase(dbPath);
+      try {
+        upsertRuntimeSession(
+          db,
+          conversationId,
+          { interface: "antigravity", mirrorActive: true },
+          nowIso(),
+        );
+      } finally {
+        db.close();
+      }
+    } catch (error) {
+      noteHookFailure("agy:session-start", error instanceof Error ? error.message : String(error));
+    }
+  }
+
+  process.stdout.write(EMPTY);
+  return 0;
+}
+
+/**
+ * `Stop`: fires at the end of each user turn (agy has no SessionEnd hook).
+ * Read the transcript, append the turns past the stored high-water
+ * `step_index` as `antigravity`, and leave the conversation open — session
+ * maintenance closes it as a stale orphan, the path Codex uses (Shape A).
+ *
+ * A re-fired Stop, or a grown transcript whose turns are all logged, adds
+ * nothing: the high-water mark is the idempotency key. A skill turn is
+ * skipped, the one-home rule. Any failure is recorded in hooks.log, never
+ * fails the turn, and the handler always answers agy's contract.
+ */
+export async function agyStop(stdin: string): Promise<number> {
+  const payload = parseAgyPayload(stdin);
+  if (!payload.conversationId || !payload.transcriptPath) {
+    process.stdout.write(EMPTY);
+    return 0;
+  }
+
+  const turns = readAgyTurns(payload.transcriptPath);
+  if (turns.length === 0) {
+    process.stdout.write(EMPTY);
+    return 0;
+  }
+
+  let dbPath: string;
+  try {
+    dbPath = resolveDbPath([], process.env);
+  } catch {
+    process.stdout.write(EMPTY);
+    return 0;
+  }
+
+  try {
+    const db = openLiveWriteDatabase(dbPath);
+    try {
+      const sessionId = payload.conversationId;
+      const existing = getRuntimeSession(db, sessionId);
+      const stored = decodeMetadata(existing?.metadata ?? null);
+      const highWater =
+        typeof stored[HIGH_WATER_KEY] === "number" ? (stored[HIGH_WATER_KEY] as number) : -1;
+      const deps = { newId, nowIso };
+      const options = { interface: "antigravity" };
+
+      let newHighWater = highWater;
+      for (const turn of turns) {
+        if (turn.lastStepIndex <= highWater) continue;
+        if (!isCommandTurn(turn.userText)) {
+          logUserMessage(db, sessionId, turn.userText, options, deps);
+          logAssistantMessage(db, sessionId, turn.replyText, options, deps);
+        }
+        if (turn.lastStepIndex > newHighWater) newHighWater = turn.lastStepIndex;
+      }
+
+      if (newHighWater !== highWater) {
+        const current = getRuntimeSession(db, sessionId);
+        const metadata = decodeMetadata(current?.metadata ?? null);
+        metadata[HIGH_WATER_KEY] = newHighWater;
+        upsertRuntimeSession(db, sessionId, { metadata: JSON.stringify(metadata) }, nowIso());
+      }
+    } finally {
+      db.close();
+    }
+  } catch (error) {
+    noteHookFailure("agy:stop", error instanceof Error ? error.message : String(error));
+  }
+
+  process.stdout.write(EMPTY);
+  return 0;
+}
+
+/** `PreInvocation`: one ephemeral context step per user turn, when owed. */
+export async function agyPreInvocation(stdin: string): Promise<number> {
+  const payload = parseAgyPayload(stdin);
+
+  // Defense in depth behind the wrapper's shell gate: only the turn's first
+  // invocation injects; the other ~30 answer instantly.
+  if (payload.invocationNum !== 0 || !payload.conversationId) {
+    process.stdout.write(EMPTY);
+    return 0;
+  }
+
+  let dbPath: string;
+  try {
+    dbPath = resolveDbPath([], process.env);
+  } catch {
+    process.stdout.write(EMPTY);
+    return 0;
+  }
+
+  // The quiet session: unbound, or bound with Mirror Mode off.
+  const state = readMirrorState(dbPath, payload.conversationId);
+  if (!state.active) {
+    process.stdout.write(EMPTY);
+    return 0;
+  }
+
+  const argv = ["mirror", "load", "--context-only", "--session-id", payload.conversationId];
+  if (state.persona) argv.push("--persona", state.persona);
+  if (state.journey) argv.push("--journey", state.journey);
+
+  const result = await runFrontDoor(argv);
+  const context = result.stdout.trim() ? result.stdout : "";
+  process.stdout.write(
+    context ? `${JSON.stringify({ injectSteps: [{ ephemeralMessage: context }] })}\n` : EMPTY,
+  );
+  return 0;
+}

package/ts/src/hooks/main.ts

@@ -4,7 +4,8 @@
 //
 // CV22.DS10.TS5 plateau 1, decision D4. Twelve shell scripts across four
 // runtimes each spawned the interpreter one to five times per event. They now
-// run one Node process and name which hook they are:
+// run one Node process and name which hook they are (the Gemini CLI family,
+// `gemini:*`, retired with CV21.DS8.US1; Antigravity is its successor):
 //
 //     node ts/src/hooks/main.ts claude:inject
 //
@@ -35,13 +36,8 @@
 
 import { pathToFileURL } from "node:url";
 import { loadConfiguration, silenceExperimentalWarnings } from "#runtime/config.ts";
+import { agyPreInvocation, agySessionStart, agyStop } from "./agy.ts";
 import { claudeHook } from "./claude.ts";
-import {
-  geminiLogAssistant,
-  geminiLogUser,
-  geminiSessionEnd,
-  geminiSessionStart,
-} from "./gemini.ts";
 import { readStdin } from "./payload.ts";
 import { noteHookFailure } from "./runtime.ts";
 
@@ -51,16 +47,16 @@ async function dispatch(name: string): Promise<number> {
   switch (runtime) {
     case "claude":
       return claudeHook(hook ?? "");
-    case "gemini":
+    case "agy":
+      // The Antigravity plugin's handlers (CV21.DS7.TS2), called through the
+      // generated agy-form wrappers in `plugins/mirror-mind/agy/`.
       switch (hook) {
-        case "log-user":
-          return geminiLogUser(readStdin());
-        case "log-assistant":
-          return geminiLogAssistant(readStdin());
-        case "session-end":
-          return geminiSessionEnd(readStdin());
         case "session-start":
-          return geminiSessionStart();
+          return agySessionStart(readStdin());
+        case "pre-invocation":
+          return agyPreInvocation(readStdin());
+        case "stop":
+          return agyStop(readStdin());
         default:
           break;
       }

package/ts/src/hooks/payload.ts

@@ -1,8 +1,8 @@
 // Reading a runtime's hook payload from stdin.
 //
 // Replaces the Python hook module `extract_prompt` (25 lines) and the four
-// inline interpreter one-liners the Claude and Gemini hooks used to parse the
-// same JSON. None of them was a command, so none was in
+// inline interpreter one-liners the Claude and Gemini CLI hooks used to parse
+// the same JSON (the Gemini CLI hooks retired with CV21.DS8.US1). None of them was a command, so none was in
 // DS7's denominator of 29 -- which is why TS5's inventory had to find them by
 // reading the hooks rather than by counting commands.
 //
@@ -23,17 +23,11 @@ export interface HookPayload {
   readonly prompt: string;
   /** The runtime's session id (`session_id`, or Grok's `sessionId`), or "". */
   readonly sessionId: string;
-  /** The assistant's response text (Gemini's `prompt_response`), or "". */
-  readonly response: string;
-  /** Everything else, for hooks that need a field these three do not cover. */
+  /** Everything else, for hooks that need a field these two do not cover. */
   readonly raw: HookPayloadObject;
 }
 
-const EMPTY: HookPayload = { prompt: "", sessionId: "", response: "", raw: {} };
-
-function text(value: unknown): string {
-  return typeof value === "string" ? value : "";
-}
+const EMPTY: HookPayload = { prompt: "", sessionId: "", raw: {} };
 
 /**
  * Parse a hook payload. Never throws: an unparseable payload is empty.
@@ -47,11 +41,10 @@ export function parseHookPayload(input: string): HookPayload {
   return {
     prompt: promptOf(raw),
     sessionId: sessionIdOf(raw),
-    // Gemini's AfterAgent payload names it `prompt_response`, and that is the
-    // field the Python hook read. The first port read three guessed names
-    // instead and dropped every Gemini assistant turn in silence until
-    // `smoke_gemini_cli.sh` caught it (CV22.DS10.TS5 plateau 3).
-    response: text(raw.prompt_response),
+    // A `response` field read Gemini CLI's `prompt_response` here until
+    // CV21.DS8.US1; no living runtime hands the reply to a hook payload by
+    // name (Claude-family hooks read the transcript, agy's Stop reads its
+    // JSONL), so the field went with its only reader.
     raw,
   };
 }

package/ts/src/hooks/runtime.ts

@@ -61,11 +61,11 @@ export function noteHookFailure(hook: string, reason: string, env = process.env)
  * The Operating Instructions a SessionStart hook should hand its runtime, or
  * null when the project already carries this same file.
  *
- * CV22.DS10.US3, decision D13. An installed package reaches Claude Code and
- * Gemini CLI through hooks, skills, and an MCP server; none of those reads a
- * CLAUDE.md or GEMINI.md, so a session wired to the package would answer
- * `/mm-mirror` and still route no mode, sign no persona, and hold no Builder
- * boundary. Both runtimes read SessionStart's
+ * CV22.DS10.US3, decision D13. An installed package reaches Claude Code (and
+ * reached Gemini CLI, until CV21.DS8.US1) through hooks, skills, and an MCP
+ * server; none of those reads a CLAUDE.md, so a session wired to the package
+ * would answer `/mm-mirror` and still route no mode, sign no persona, and hold
+ * no Builder boundary. The runtime reads SessionStart's
  * `hookSpecificOutput.additionalContext`, so the session-start hook returns
  * `AGENTS.md` from the tree THIS code runs from -- the instructions always
  * match the core they ship with -- unless the project the session opened in
@@ -92,8 +92,9 @@ export function operatingInstructionsFor(
 }
 
 /**
- * The SessionStart answer both runtimes read: context as JSON, or `nothing`
- * -- what each runtime's hook printed before D13 (Gemini `{}`, Claude none).
+ * The SessionStart answer the runtime reads: context as JSON, or `nothing`
+ * -- what the runtime's hook printed before D13 (Claude none; Gemini CLI's
+ * `{}`, until CV21.DS8.US1 retired it).
  */
 export function sessionStartOutput(instructions: string | null, nothing = ""): string {
   if (instructions === null) return nothing;
@@ -148,9 +149,9 @@ export async function runFrontDoor(
 /**
  * The command a failure line may name: the family and its subcommand, never
  * the arguments. Arguments are where hooks put what the user said and what the
- * model answered -- the Gemini logger passes the prompt and the response as
- * argv -- and the first version of the failure line printed all of them (TS5
- * handoff review, finding P1).
+ * model answered -- the Gemini CLI logger, retired by CV21.DS8.US1, passed the
+ * prompt and the response as argv -- and the first version of the failure
+ * line printed all of them (TS5 handoff review, finding P1).
  */
 function commandName(argv: readonly string[]): string {
   return argv.slice(0, 2).join(" ");

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,17 @@
 //               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
@@ -57,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",
@@ -91,17 +73,17 @@ 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: {
@@ -118,7 +100,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"];
 
 /** 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