mirror-mind 0.39.3 → 0.39.5

package/.claude/hooks/log-assistant-reply.sh

@@ -31,8 +31,13 @@ env_value() {
   [ -n "$value" ] || value="$(env_file_value "$1" "${XDG_CONFIG_HOME:-$HOME/.config}/mirror/env")"
   printf '%s' "$value"
 }
+# `note <line> daily` writes at most once a day (UTC): for a setting to fix
+# rather than a hook that failed, so the line stays inside diagnose's seven-day
+# window while the setting stays wrong, without one per hook per turn (CR192).
+# The log is read into a variable, not piped to `grep -q`: under pipefail, a
+# reader that stops early can fail the pipeline and the line be written twice.
 note() {
-  local home user
+  local home user seen today
   home="$(env_value MIRROR_HOME)"
   user="$(env_value MIRROR_USER)"
   if [ -n "$home" ]; then
@@ -43,6 +48,11 @@ note() {
   else
     return 0
   fi
+  if [ "${2:-}" = daily ]; then
+    today="$(date -u +%Y-%m-%d)"
+    seen="$(grep -F -- ": $1" "$home/hooks.log" 2>/dev/null)"
+    case "$seen" in "$today"T*|*$'\n'"$today"T*) return 0 ;; esac
+  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
 }
@@ -58,10 +68,32 @@ ENTRY="$REPO_ROOT/bin/mirror-hook.js"
 # 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)"
+#
+# MIRROR_NODE is used only as an absolute path to an executable file, as every
+# reader uses it (CR192): a relative one would resolve against the project the
+# runtime spawned this hook from. Anything else is noted with its reason, in
+# the Pi extension's words, once a day, and the search goes on without it.
+# "Absolute" is the MCP locator's pattern too, and it classifies exactly as
+# path.win32.isAbsolute: under Git Bash the Windows installer writes
+# C:\Program Files\nodejs\node.exe (PR #47).
+NODE=""
+if [ -n "${MIRROR_NODE:-}" ]; then
+  refused=""
+  case "$MIRROR_NODE" in
+    /*|\\*|[A-Za-z]:[\\/]*)
+      if [ -d "$MIRROR_NODE" ]; then refused="a directory"
+      elif [ ! -e "$MIRROR_NODE" ]; then refused="missing"
+      elif [ ! -f "$MIRROR_NODE" ] || [ ! -x "$MIRROR_NODE" ]; then refused="not executable"
+      else NODE="$MIRROR_NODE"
+      fi
+      ;;
+    *) refused="relative" ;;
+  esac
+  if [ -n "$refused" ]; then
+    note "MIRROR_NODE=${MIRROR_NODE//[$'\r\n']/} is $refused; searching the PATH and the usual places instead" daily
+  fi
 fi
+[ -n "$NODE" ] || NODE="$(command -v node 2>/dev/null || true)"
 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"

package/.claude/hooks/log-session-end.sh

@@ -31,8 +31,13 @@ env_value() {
   [ -n "$value" ] || value="$(env_file_value "$1" "${XDG_CONFIG_HOME:-$HOME/.config}/mirror/env")"
   printf '%s' "$value"
 }
+# `note <line> daily` writes at most once a day (UTC): for a setting to fix
+# rather than a hook that failed, so the line stays inside diagnose's seven-day
+# window while the setting stays wrong, without one per hook per turn (CR192).
+# The log is read into a variable, not piped to `grep -q`: under pipefail, a
+# reader that stops early can fail the pipeline and the line be written twice.
 note() {
-  local home user
+  local home user seen today
   home="$(env_value MIRROR_HOME)"
   user="$(env_value MIRROR_USER)"
   if [ -n "$home" ]; then
@@ -43,6 +48,11 @@ note() {
   else
     return 0
   fi
+  if [ "${2:-}" = daily ]; then
+    today="$(date -u +%Y-%m-%d)"
+    seen="$(grep -F -- ": $1" "$home/hooks.log" 2>/dev/null)"
+    case "$seen" in "$today"T*|*$'\n'"$today"T*) return 0 ;; esac
+  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
 }
@@ -58,10 +68,32 @@ ENTRY="$REPO_ROOT/bin/mirror-hook.js"
 # 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)"
+#
+# MIRROR_NODE is used only as an absolute path to an executable file, as every
+# reader uses it (CR192): a relative one would resolve against the project the
+# runtime spawned this hook from. Anything else is noted with its reason, in
+# the Pi extension's words, once a day, and the search goes on without it.
+# "Absolute" is the MCP locator's pattern too, and it classifies exactly as
+# path.win32.isAbsolute: under Git Bash the Windows installer writes
+# C:\Program Files\nodejs\node.exe (PR #47).
+NODE=""
+if [ -n "${MIRROR_NODE:-}" ]; then
+  refused=""
+  case "$MIRROR_NODE" in
+    /*|\\*|[A-Za-z]:[\\/]*)
+      if [ -d "$MIRROR_NODE" ]; then refused="a directory"
+      elif [ ! -e "$MIRROR_NODE" ]; then refused="missing"
+      elif [ ! -f "$MIRROR_NODE" ] || [ ! -x "$MIRROR_NODE" ]; then refused="not executable"
+      else NODE="$MIRROR_NODE"
+      fi
+      ;;
+    *) refused="relative" ;;
+  esac
+  if [ -n "$refused" ]; then
+    note "MIRROR_NODE=${MIRROR_NODE//[$'\r\n']/} is $refused; searching the PATH and the usual places instead" daily
+  fi
 fi
+[ -n "$NODE" ] || NODE="$(command -v node 2>/dev/null || true)"
 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"

package/.claude/hooks/log-user-prompt.sh

@@ -31,8 +31,13 @@ env_value() {
   [ -n "$value" ] || value="$(env_file_value "$1" "${XDG_CONFIG_HOME:-$HOME/.config}/mirror/env")"
   printf '%s' "$value"
 }
+# `note <line> daily` writes at most once a day (UTC): for a setting to fix
+# rather than a hook that failed, so the line stays inside diagnose's seven-day
+# window while the setting stays wrong, without one per hook per turn (CR192).
+# The log is read into a variable, not piped to `grep -q`: under pipefail, a
+# reader that stops early can fail the pipeline and the line be written twice.
 note() {
-  local home user
+  local home user seen today
   home="$(env_value MIRROR_HOME)"
   user="$(env_value MIRROR_USER)"
   if [ -n "$home" ]; then
@@ -43,6 +48,11 @@ note() {
   else
     return 0
   fi
+  if [ "${2:-}" = daily ]; then
+    today="$(date -u +%Y-%m-%d)"
+    seen="$(grep -F -- ": $1" "$home/hooks.log" 2>/dev/null)"
+    case "$seen" in "$today"T*|*$'\n'"$today"T*) return 0 ;; esac
+  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
 }
@@ -58,10 +68,32 @@ ENTRY="$REPO_ROOT/bin/mirror-hook.js"
 # 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)"
+#
+# MIRROR_NODE is used only as an absolute path to an executable file, as every
+# reader uses it (CR192): a relative one would resolve against the project the
+# runtime spawned this hook from. Anything else is noted with its reason, in
+# the Pi extension's words, once a day, and the search goes on without it.
+# "Absolute" is the MCP locator's pattern too, and it classifies exactly as
+# path.win32.isAbsolute: under Git Bash the Windows installer writes
+# C:\Program Files\nodejs\node.exe (PR #47).
+NODE=""
+if [ -n "${MIRROR_NODE:-}" ]; then
+  refused=""
+  case "$MIRROR_NODE" in
+    /*|\\*|[A-Za-z]:[\\/]*)
+      if [ -d "$MIRROR_NODE" ]; then refused="a directory"
+      elif [ ! -e "$MIRROR_NODE" ]; then refused="missing"
+      elif [ ! -f "$MIRROR_NODE" ] || [ ! -x "$MIRROR_NODE" ]; then refused="not executable"
+      else NODE="$MIRROR_NODE"
+      fi
+      ;;
+    *) refused="relative" ;;
+  esac
+  if [ -n "$refused" ]; then
+    note "MIRROR_NODE=${MIRROR_NODE//[$'\r\n']/} is $refused; searching the PATH and the usual places instead" daily
+  fi
 fi
+[ -n "$NODE" ] || NODE="$(command -v node 2>/dev/null || true)"
 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"

package/.claude/hooks/mirror-inject.sh

@@ -31,8 +31,13 @@ env_value() {
   [ -n "$value" ] || value="$(env_file_value "$1" "${XDG_CONFIG_HOME:-$HOME/.config}/mirror/env")"
   printf '%s' "$value"
 }
+# `note <line> daily` writes at most once a day (UTC): for a setting to fix
+# rather than a hook that failed, so the line stays inside diagnose's seven-day
+# window while the setting stays wrong, without one per hook per turn (CR192).
+# The log is read into a variable, not piped to `grep -q`: under pipefail, a
+# reader that stops early can fail the pipeline and the line be written twice.
 note() {
-  local home user
+  local home user seen today
   home="$(env_value MIRROR_HOME)"
   user="$(env_value MIRROR_USER)"
   if [ -n "$home" ]; then
@@ -43,6 +48,11 @@ note() {
   else
     return 0
   fi
+  if [ "${2:-}" = daily ]; then
+    today="$(date -u +%Y-%m-%d)"
+    seen="$(grep -F -- ": $1" "$home/hooks.log" 2>/dev/null)"
+    case "$seen" in "$today"T*|*$'\n'"$today"T*) return 0 ;; esac
+  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
 }
@@ -58,10 +68,32 @@ ENTRY="$REPO_ROOT/bin/mirror-hook.js"
 # 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)"
+#
+# MIRROR_NODE is used only as an absolute path to an executable file, as every
+# reader uses it (CR192): a relative one would resolve against the project the
+# runtime spawned this hook from. Anything else is noted with its reason, in
+# the Pi extension's words, once a day, and the search goes on without it.
+# "Absolute" is the MCP locator's pattern too, and it classifies exactly as
+# path.win32.isAbsolute: under Git Bash the Windows installer writes
+# C:\Program Files\nodejs\node.exe (PR #47).
+NODE=""
+if [ -n "${MIRROR_NODE:-}" ]; then
+  refused=""
+  case "$MIRROR_NODE" in
+    /*|\\*|[A-Za-z]:[\\/]*)
+      if [ -d "$MIRROR_NODE" ]; then refused="a directory"
+      elif [ ! -e "$MIRROR_NODE" ]; then refused="missing"
+      elif [ ! -f "$MIRROR_NODE" ] || [ ! -x "$MIRROR_NODE" ]; then refused="not executable"
+      else NODE="$MIRROR_NODE"
+      fi
+      ;;
+    *) refused="relative" ;;
+  esac
+  if [ -n "$refused" ]; then
+    note "MIRROR_NODE=${MIRROR_NODE//[$'\r\n']/} is $refused; searching the PATH and the usual places instead" daily
+  fi
 fi
+[ -n "$NODE" ] || NODE="$(command -v node 2>/dev/null || true)"
 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"

package/.claude/hooks/session-start.sh

@@ -31,8 +31,13 @@ env_value() {
   [ -n "$value" ] || value="$(env_file_value "$1" "${XDG_CONFIG_HOME:-$HOME/.config}/mirror/env")"
   printf '%s' "$value"
 }
+# `note <line> daily` writes at most once a day (UTC): for a setting to fix
+# rather than a hook that failed, so the line stays inside diagnose's seven-day
+# window while the setting stays wrong, without one per hook per turn (CR192).
+# The log is read into a variable, not piped to `grep -q`: under pipefail, a
+# reader that stops early can fail the pipeline and the line be written twice.
 note() {
-  local home user
+  local home user seen today
   home="$(env_value MIRROR_HOME)"
   user="$(env_value MIRROR_USER)"
   if [ -n "$home" ]; then
@@ -43,6 +48,11 @@ note() {
   else
     return 0
   fi
+  if [ "${2:-}" = daily ]; then
+    today="$(date -u +%Y-%m-%d)"
+    seen="$(grep -F -- ": $1" "$home/hooks.log" 2>/dev/null)"
+    case "$seen" in "$today"T*|*$'\n'"$today"T*) return 0 ;; esac
+  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
 }
@@ -58,10 +68,32 @@ ENTRY="$REPO_ROOT/bin/mirror-hook.js"
 # 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)"
+#
+# MIRROR_NODE is used only as an absolute path to an executable file, as every
+# reader uses it (CR192): a relative one would resolve against the project the
+# runtime spawned this hook from. Anything else is noted with its reason, in
+# the Pi extension's words, once a day, and the search goes on without it.
+# "Absolute" is the MCP locator's pattern too, and it classifies exactly as
+# path.win32.isAbsolute: under Git Bash the Windows installer writes
+# C:\Program Files\nodejs\node.exe (PR #47).
+NODE=""
+if [ -n "${MIRROR_NODE:-}" ]; then
+  refused=""
+  case "$MIRROR_NODE" in
+    /*|\\*|[A-Za-z]:[\\/]*)
+      if [ -d "$MIRROR_NODE" ]; then refused="a directory"
+      elif [ ! -e "$MIRROR_NODE" ]; then refused="missing"
+      elif [ ! -f "$MIRROR_NODE" ] || [ ! -x "$MIRROR_NODE" ]; then refused="not executable"
+      else NODE="$MIRROR_NODE"
+      fi
+      ;;
+    *) refused="relative" ;;
+  esac
+  if [ -n "$refused" ]; then
+    note "MIRROR_NODE=${MIRROR_NODE//[$'\r\n']/} is $refused; searching the PATH and the usual places instead" daily
+  fi
 fi
+[ -n "$NODE" ] || NODE="$(command -v node 2>/dev/null || true)"
 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"

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

@@ -235,7 +235,7 @@ export interface NodeResolution {
  * then `NODE_CANDIDATES`. Not `process.execPath`: Pi may run on a Node older
  * than the core needs. On Windows the PATH is the last place looked.
  *
- * A relative `MIRROR_NODE` is refused here, though the wrappers accept one: it
+ * A relative `MIRROR_NODE` is refused, as every reader refuses one (CR192): it
  * would resolve against whatever project Pi was opened in.
  *
  * The absolute candidates make "nothing anywhere" a fact about the host, so

package/docs/releases/index.md

@@ -12,6 +12,8 @@ Future release notes should use the structure defined in [Release Notes](../proc
 
 ## Releases
 
+- [v0.39.5 — The Node You Named, or Why Not](v0.39.5.md) — patch release of CR192, from PR #47's thread (@rodrigoimmaginario): the hook wrappers, the plugin's MCP entry, and `runtime diagnose` use `MIRROR_NODE` only as an absolute path to an executable file, as the Pi extension does; a relative value is never run, and a refused one is named with its reason, once a day in `hooks.log` and on the MCP entry's stderr; the Windows installer's drive-letter path counts as absolute, in CI under Git Bash and on the installer. No migration.
+- [v0.39.4 — The Reply Finds Its Prompt](v0.39.4.md) — patch release of PR #51 (@alannascimento1), CR166 and CR196: on Claude Code, a prompt typed while a turn runs and a journey entered in plain words no longer lose the reply; `nothing_waiting` in `hooks.log` means a lost reply again. No schema change, no migration.
 - [v0.39.3 — Windows Gets Its Hooks](v0.39.3.md) — patch release of PR #53, PR #50, and PR #54 (@rodrigoimmaginario): the plugin's hook wrappers and MCP locator run the package's own bin when npm's global entry is a shell shim, so Claude Code hooks and the MCP server work on a Windows package install; `runtime diagnose` no longer counts its own verdict as a front-door error (CR139); the docs point a Windows reader to the installer in its own repository. No migration.
 - [v0.39.2 — Input, Read the Platform's Way](v0.39.2.md) — patch release of PR #49 and PR #48 (@rodrigoimmaginario), CR194, and CR193: `runtime diagnose` stops warning every Windows install about Node; a PowerShell byte-order mark is not stored; stdin is decoded by its mark, UTF-8 or UTF-16, and `identity set` and `journey update` gain `--file`, the route around PowerShell 5.1's ASCII pipe; `package-lock.json` names the package at its version, and the release doctor checks it. No migration.
 - [v0.39.1 — Pi Finds Its Node, or Says So](v0.39.1.md) — patch release of PR #47 (@rodrigoimmaginario) and CR191: a Pi opened where `node` is not on the PATH no longer exits; the Pi extension resolves Node where the hook wrappers look, so a global install needs nothing configured; when no Node resolves, one warning names the fix and `runtime diagnose` reports the `hooks.log` line. No migration.

package/docs/releases/v0.39.2.md

@@ -89,11 +89,18 @@ Validated on 2026-11-03 against a scratch copy of the maintainer's database: UTF
 with a mark, and UTF-16LE as PowerShell 5.1 writes it, through `--file` and through stdin;
 the refusals writing nothing; the one-liner pipe unchanged.
 
+**Post-release Windows validation, 2026-11-03.** Rodrigo Immaginario ran v0.39.2 through
+npm's `mirror.ps1` shim on Windows PowerShell 5.1.26100. `--file` preserved both unmarked
+UTF-8 and UTF-16LE. The measurement also corrected the pipe documentation: for an
+editor-saved unmarked UTF-8 file, UTF-8 `$OutputEncoding` is not enough because
+`Get-Content` has already decoded the file through the ANSI code page. The complete pipe
+route is `Get-Content -Encoding UTF8` plus UTF-8 `$OutputEncoding`. Evidence:
+[PR #49](https://github.com/mirror-mind-ai/mirror/pull/49#issuecomment-6610137363).
+
 ## Conscious Exclusions
 
-- Windows PowerShell 5.1 itself was not run: there is no Windows machine on the maintainer's
-  side. The decoder's cases are pinned byte for byte; a measurement on the OS is asked of
-  the reporter.
+- At publication, Windows PowerShell 5.1 itself had not been run on the maintainer's side;
+  the post-release validation above closed that measurement gap.
 - Detecting text the ASCII pipe damaged: not possible without guessing.
 - The hook wrappers and the MCP locator still accept a relative `MIRROR_NODE`
   ([CR192](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr192-the-hook-wrappers-and-the-mcp-locator-accept-a-relative-mirror-node.md),

package/docs/releases/v0.39.4.md

@@ -0,0 +1,81 @@
+---
+digest: >
+  v0.39.4 is a patch release of one pull request by Alan Nascimento, his first here. On
+  Claude Code, two ordinary situations made the Stop hook drop a real reply: a prompt typed
+  while a turn was still running, whose prompt hook fires at queue time under the running
+  turn's id, and a journey entered in plain words, whose Builder load switches the
+  conversation mid-turn. Both replies are now logged beside their prompts, and
+  `nothing_waiting` in `hooks.log` means what it says again. No schema change, no
+  migration, and no model or prompt change.
+---
+
+# v0.39.4 — The Reply Finds Its Prompt
+
+**Date:** 2026-11-03
+
+## Highlights
+
+- **A prompt typed while a turn runs keeps its reply**
+  ([PR #51](https://github.com/mirror-mind-ai/mirror/pull/51), by @alannascimento1;
+  [CR196](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr196-a-prompt-typed-while-a-turn-runs-loses-its-reply-on-claude-code.md)).
+  Claude Code fires the prompt hook when such a prompt enters its queue, with the running
+  turn's id; the prompt later runs under an id no hook sent, and its Stop found nothing
+  waiting. The prompt is now recorded as queued during the running turn, the running turn's
+  reply stays with its own question, and the Stop of the turn the queued prompt ran as
+  claims it. Never for a command turn, and never a prompt an ordinary one has since
+  followed.
+- **Entering a journey in plain words keeps the turn together**
+  ([CR166](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr166-a-plain-language-journey-switch-strands-its-turn.md)).
+  "I want to enter journey X" logs the prompt in one conversation; the model's `build load`
+  closes it and binds the journey's; the Stop paired in the new, empty one. A hook prompt
+  still owed its reply now moves with the switch. A prompt logged by hand stays where it
+  was, so `mm-new` and the logger CLI behave as before. Pi gets this half too: its prompts
+  carry turn ids.
+- **`nothing_waiting` means a lost reply again.** On one host, 20 of 22 such lines in a
+  week were these two cases; `runtime diagnose`'s `hook_failures_recorded` was mostly
+  counting them.
+- No schema change (`queued_in_turn` is one more optional key in the `metadata` JSON
+  column `turn_id` already lives in), no migration, and no model or prompt change.
+
+## Where We Started
+
+Alan Nascimento opened PR #51 on 2026-10-30 with the session transcript that shows the
+mechanism, Claude Code's own `queue-operation` record between the prompt hook and the
+Stop, and a week of `hooks.log` counted by cause. The journey-switch half had been in the
+backlog as CR166 since 2026-10-24, unassigned; the queued-prompt half no record described.
+The review, through four lenses, had nothing to amend: the reply rule gains one branch
+between "by turn id" and "by position", each new path bounded by an explicit guard, and
+ten tests of which five fail without the change.
+
+## What Changed
+
+All in `ts/src/conversation/logger.ts`. `promptMetadata` records a second prompt under a
+turn still owed its reply as `queued_in_turn`. `handleStopHook`, for a turn id with no
+prompt of its own, claims the oldest unclaimed queued prompt that no ordinary prompt has
+followed, and logs the reply as paired by `queued_prompt`. `switchConversation` moves the
+old conversation's last row to the new one when it is a hook prompt with no reply after
+it. The reply rule's docblock names the new branch.
+
+## Conscious Exclusions
+
+Both named by the author and recorded in CR166 and CR196:
+
+- In the queued case the running turn's reply is still written after the queued prompt,
+  because the prompt hook fires at queue time: the rows pair by `turn_id`, but a reader
+  ordering by `created_at` sees `Q1, Q2, A1, A2`. Rewriting `created_at` would make it lie
+  about when the prompt was typed.
+- The waiting prompt moves after the old conversation's close-time extraction, which
+  therefore still saw it. Moving it earlier would mean starting the new conversation
+  before closing the old.
+- The two `nothing_waiting` lines in the week that match neither pattern.
+
+## Upgrading
+
+```bash
+mirror runtime update
+```
+
+## Next Horizon
+
+Moacir Moda's PR #27; CR190, CR192, and CR195 in RS010's backlog. CV24 continues on its
+branch.

package/docs/releases/v0.39.5.md

@@ -0,0 +1,146 @@
+---
+digest: >
+  v0.39.5 is a patch release of one Change Request, CR192, from PR #47's thread with
+  Rodrigo Immaginario. The hook wrappers, the plugin's MCP entry, and `runtime diagnose`
+  now use `MIRROR_NODE` only when it is an absolute path to an executable file, the rule
+  the Pi extension has followed since v0.39.1. A relative value could make a hook run a
+  file from the project the runtime was opened in, and a value that no longer pointed at
+  Node was dropped without a word. Now neither is used, and the hooks and the MCP entry
+  name the refused value with its reason. The Windows installer's drive-letter path counts
+  as absolute, proven in CI under Git Bash and on the installer itself. No schema change,
+  no migration, and no model or prompt change.
+---
+
+# v0.39.5 — The Node You Named, or Why Not
+
+**Date:** 2026-11-05
+
+## Highlights
+
+- **A relative `MIRROR_NODE` is never run**
+  ([CR192](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr192-the-hook-wrappers-and-the-mcp-locator-accept-a-relative-mirror-node.md)).
+  A runtime starts its hooks and its MCP server from the project it was opened in, and the
+  hook wrappers and the MCP entry kept any `MIRROR_NODE` that passed `[ -x ]` there: with
+  `MIRROR_NODE=bin/node`, the project's own `bin/node` ran on every hook. Every reader now
+  follows the Pi extension's rule: an absolute path to an executable file, or nothing.
+- **A value that is not used is named, with its reason.** A value that named no usable
+  Node used to be dropped without a word. Now the hook wrappers write
+  `MIRROR_NODE=bin/node is relative; searching the PATH and the usual places instead` to
+  `<mirror home>/hooks.log`, once a UTC day for the same value, and the MCP entry writes
+  the same message to its stderr. The reasons are the Pi extension's: `relative`,
+  `a directory`, `missing`, and `not executable`. The search then goes on through the
+  PATH and the usual places, as before.
+- **The Windows installer's form counts as absolute.** Under Git Bash the installer's
+  `MIRROR_NODE` is a drive-letter path with backslashes, and a POSIX-only test would have
+  refused it on every Windows hook; @rodrigoimmaginario named that trap before the plan
+  was written. One shell pattern now classifies exactly as Node's `path.win32.isAbsolute`:
+  `C:\…`, `C:/…`, and `\\server\share\…` are absolute, and a drive-relative `C:node.exe`
+  is refused as `relative`.
+- **Proven on Windows twice.** The Windows CI job runs a real wrapper under Git Bash, with
+  a Node under `Program Files\nodejs` named in its Windows form. And before this tag,
+  Rodrigo ran the installer against `main`: its `MIRROR_NODE`, under a user folder with a
+  space and accents, ran the hooks and the MCP server with no refusal line, and
+  `C:node.exe` gave exactly one.
+- No schema change, no migration, and no model or prompt change.
+
+## Where We Started
+
+v0.39.1 made the Pi extension strict about `MIRROR_NODE`
+([CR191](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr191-the-pi-extension-cannot-find-node-where-the-hook-wrappers-can.md)):
+an absolute path to an executable file, or a warning with the reason and a search without
+it. The rest of the family was not strict. The hook wrappers and the plugin's MCP locator
+kept any value that passed `[ -x ]`, a test a relative path passes against the project a
+hook was started in; a value that failed it was dropped, and whoever had set it to pin a
+Node learned nothing. `REFERENCE.md` described one trust class for every reader, and only
+one reader held to it. CR191's debt review left the family's rule as its own decision,
+captured as CR192 on 2026-11-02.
+
+On PR #47 the next day, Rodrigo Immaginario named the trap in the obvious fix: under Git
+Bash the Windows installer's `MIRROR_NODE` is a drive-letter path, it passes `[ -x ]`
+today, and a `/*` test for "absolute" would refuse it, so every hook on a Windows install
+would log a refusal. He also asked that PR #53, which changed the same generator, locator,
+and tests, merge first. It did, in v0.39.3, and the plan started from its blocks.
+
+## What Changed
+
+**One rule, one pattern.** For the shell readers, "absolute" is one `case` pattern,
+`/*|\\*|[A-Za-z]:[\\/]*`, which matched `path.win32.isAbsolute` on 15 values in bash,
+dash, ksh, `/bin/sh`, and zsh as `sh`. `scripts/generate_hook_wrappers.sh` gives it, with
+the logging helpers and the Node search, to all three wrapper forms as shared fragments,
+and the 13 wrappers are regenerated. The MCP locator in `ts/src/guards/claudePlugin.ts`
+carries the same text as `ABSOLUTE_PATH_CASE`, and a test fails if the two drift. The Node
+readers keep their platform's `path.isAbsolute`, so on Windows every reader draws the same
+line.
+
+**A refusal that cannot forge a line.** Line breaks are removed from a value before it is
+logged: in review, a value with a line break in it wrote a second `hooks.log` line, as
+`claude:stop`, that `runtime diagnose` counted. The locator prints with `printf`, because
+dash's `echo` turns the `\n` of a Windows path into a newline, and names `$MIRROR_NODE`
+once, because Grok pastes a set variable's value into the MCP arguments it loads.
+
+**`runtime diagnose`.** Its Node check counts `MIRROR_NODE` only under the rule, through
+`isExecutableFile()`, which the front door's runtime route now shares. It adds no finding
+of its own: the hooks' refusal line reaches it as `hook_failures_recorded`, for seven
+days.
+
+**Tests and CI.** `mirrorNodeRule.test.ts` holds the pattern equal across the three
+wrapper forms and the locator, runs the classification table through bash and, where
+installed, dash, and runs a real wrapper with a Node under `Program Files/nodejs` and
+with `C:node.exe`; the Windows job runs it under Git Bash. `hooks.test.ts` and
+`mcpEntry.test.ts` cover each reason, a planted `bin/node` that never runs, the daily
+rule across two fixed days, a forged line break, and a server that starts past a
+relative value.
+
+**Docs.** The rule is stated once, in full, in the
+[configuration reference](../reference/configuration.md#hook-node-resolution);
+`REFERENCE.md`'s row points there. Troubleshooting shows the refusal line and the fix, and
+says `runtime diagnose` keeps counting old lines for seven days after the fix.
+
+Validated by the Navigator in a scratch home: two runs of the plugin's prompt hook with
+`MIRROR_NODE=bin/node` wrote one line,
+
+```text
+2026-11-04T21:40:16Z claude:user-prompt: MIRROR_NODE=bin/node is relative; searching the PATH and the usual places instead
+```
+
+the project's `bin/node` never ran, the prompt was logged, and `runtime diagnose`
+reported `hook_failures_recorded`. CI passed on every job, the Git Bash step included,
+and Rodrigo's installer run, 21 of 21 on the installer's contract, was the gate before
+the tag.
+
+**Also in this release.** Troubleshooting's PowerShell 5.1 section, from Rodrigo's PR #49
+run: `Get-Content` decodes an editor-saved UTF-8 file without a mark through the ANSI code
+page before the pipe runs, so a UTF-8 `$OutputEncoding` alone does not save it. The pipe
+route now adds `Get-Content -Encoding UTF8`, and `--file` stays the safe one.
+
+## Conscious Exclusions
+
+- `MIRROR_BIN` keeps its behavior: a relative value is still honored, and one that names
+  nothing is still dropped without a word.
+  [CR197](../project/refinement/rs010-cv22-oracle-and-port-hygiene/cr197-the-hook-wrappers-and-the-mcp-locator-accept-a-relative-mirror-bin.md)
+  (captured) would give it this rule, keeping accepted the forward-slash `C:/…` form a
+  Windows machine sets for the Claude Code forwarders.
+- `runtime diagnose` does not name a refused value. It counts the hooks' line under
+  `hook_failures_recorded`, and the value and its reason are in `hooks.log`; Rodrigo
+  suggests saying it in diagnose too. A finding of its own was left out at planning.
+- Whitespace: the Pi extension trims the value and the shell readers do not, so
+  ` /opt/node` is accepted by Pi and refused as `relative` by the hooks. Nothing writes
+  such a value.
+- Converting MSYS `/c/…` values, and rotating `hooks.log`.
+- Where Codex and Antigravity show an MCP server's stderr is not verified; the docs say
+  only what each CLI's own help shows.
+
+## Upgrading
+
+```bash
+mirror runtime update
+```
+
+If you set `MIRROR_NODE` by hand, make it the absolute path of the `node` binary: a
+relative one is now refused, with one line a day in `hooks.log`.
+
+## Next Horizon
+
+CR197, which would bring `MIRROR_BIN` under this rule with its pattern; Rodrigo's
+suggestion that `runtime diagnose` name a refused value, not yet decided; and the open
+RS010 backlog.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mirror-mind",
-  "version": "0.39.3",
+  "version": "0.39.5",
   "description": "Mirror Mind: a local-first memory and identity framework for agentic AI runtimes (Pi, Claude Code, Codex, Antigravity)",
   "license": "MIT",
   "repository": {

package/plugins/mirror-mind/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "mirror-mind",
-  "version": "0.39.3",
+  "version": "0.39.5",
   "description": "Mirror Mind — local-first memory and identity for agentic runtimes.",
   "author": {
     "name": "Mirror Mind"
@@ -10,7 +10,7 @@
       "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; }; mmjs=\"$(dirname \"$mmbin\")/node_modules/mirror-mind/bin/mirror.js\"; [ -f \"$mmjs\" ] && mmbin=\"$mmjs\"; 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"
+        "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; }; mmjs=\"$(dirname \"$mmbin\")/node_modules/mirror-mind/bin/mirror.js\"; [ -f \"$mmjs\" ] && mmbin=\"$mmjs\"; mmnode=\"$MIRROR_NODE\"; mmwhy=\"\"; [ -n \"$mmnode\" ] && case \"$mmnode\" in /*|\\\\*|[A-Za-z]:[\\\\/]*) if [ -d \"$mmnode\" ]; then mmwhy=\"a directory\"; elif [ ! -e \"$mmnode\" ]; then mmwhy=\"missing\"; elif [ ! -f \"$mmnode\" ] || [ ! -x \"$mmnode\" ]; then mmwhy=\"not executable\"; fi ;; *) mmwhy=\"relative\" ;; esac; [ -n \"$mmwhy\" ] && { printf 'mirror-mind: MIRROR_NODE=%s is %s; searching the PATH and the usual places instead\\n' \"$(printf '%s' \"$mmnode\" | tr -d '\\r\\n')\" \"$mmwhy\" >&2; mmnode=\"\"; }; [ -n \"$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"
       ]
     }
   }