@memnexus-ai/cli 1.7.219 → 1.7.221

package/hooks/capture-hooks.test.sh

@@ -0,0 +1,465 @@
+#!/bin/bash
+# capture-hooks.test.sh — regression suite for the v4.04 error-honesty fixes in
+# the customer-shipped capture hooks (capture-session-end.sh,
+# capture-precompact.sh) and the dev-tools auto-save hook.
+#
+# Run with: bash cli/hooks/capture-hooks.test.sh
+# Exit: 0 = all pass, 1 = any fail.
+#
+# What is under test:
+#   * a FAILED `mx memories create` must leave the debounce watermark alone, so
+#     the segment is retried instead of being discarded forever
+#   * a SUCCESSFUL create must advance the watermark
+#   * the project-hash fallback chain must actually fall back (the old form
+#     piped into awk and therefore tested awk's exit status, never the hasher's)
+#   * with no hasher at all, the hook must skip rather than write a state file
+#     shared by every project
+#   * every hook still exits 0 in all of these cases (fail-open with Claude Code)
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+SESSION_END_HOOK="$SCRIPT_DIR/capture-session-end.sh"
+PRECOMPACT_HOOK="$SCRIPT_DIR/capture-precompact.sh"
+AUTOSAVE_HOOK="$REPO_ROOT/dev-tools/claude-hooks/auto-save-memory.sh"
+
+PASS=0
+FAIL=0
+
+ok() {
+  PASS=$((PASS + 1))
+  echo "  PASS: $1"
+}
+
+nope() {
+  FAIL=$((FAIL + 1))
+  echo "  FAIL: $1"
+  [[ $# -gt 1 ]] && echo "        $2"
+}
+
+assert_eq() { # <expected> <actual> <label>
+  if [[ "$1" == "$2" ]]; then ok "$3"; else nope "$3" "expected [$1], got [$2]"; fi
+}
+
+assert_contains() { # <haystack> <needle> <label>
+  if [[ "$1" == *"$2"* ]]; then ok "$3"; else nope "$3" "missing [$2] in: $1"; fi
+}
+
+# ── Fixtures ────────────────────────────────────────────────────────────────
+
+# A stub `mx` whose exit status is controlled by MX_STUB_EXIT. Every call is
+# appended to MX_STUB_LOG so a test can assert that no create was even
+# attempted (the bounded-retry cap).
+make_stub_bin() { # <dir>
+  local bin="$1"
+  mkdir -p "$bin"
+  cat >"$bin/mx" <<'STUB'
+#!/bin/bash
+[[ -n "${MX_STUB_LOG:-}" ]] && echo "call" >>"$MX_STUB_LOG"
+exit "${MX_STUB_EXIT:-0}"
+STUB
+  chmod +x "$bin/mx"
+}
+
+# A transcript with enough lines (>100) and tool calls (>=5) to clear the
+# hooks' debounce and triviality gates.
+make_transcript() { # <path> <lines>
+  local path="$1" lines="${2:-150}" i
+  : >"$path"
+  for ((i = 0; i < lines; i++)); do
+    printf '%s\n' '{"type":"user","message":{"content":"do the thing"}}' >>"$path"
+    printf '%s\n' '{"type":"assistant","message":{"content":[{"type":"tool_use","name":"Write","input":{"file_path":"/tmp/x.ts"}},{"type":"text","text":"done"}]}}' >>"$path"
+  done
+}
+
+# Run capture-session-end.sh in an isolated HOME/state dir.
+# Echoes the watermark file's contents (empty when absent).
+run_session_end() { # <workdir> <path-override> ; uses MX_STUB_EXIT
+  local work="$1" path_override="$2"
+  local transcript="$work/transcript.jsonl"
+  ( cd "$work" && PATH="$path_override" HOME="$work/home" XDG_RUNTIME_DIR="$work/state" \
+      MX_STUB_LOG="$work/mx-calls.log" \
+      bash "$SESSION_END_HOOK" \
+      <<<"{\"transcript_path\":\"$transcript\",\"session_id\":\"s1\",\"stop_hook_active\":false}" \
+      2>"$work/stderr.txt" )
+  echo "$?" >"$work/exit.txt"
+}
+
+# Contents of the watermark file (empty when absent). The sibling ".fails"
+# counter is excluded — it lives next to the watermark and must not be mistaken
+# for it. Globs, not `ls`: an unmatched glob yields the literal pattern, which
+# the -f test filters out.
+state_file_contents() { # <workdir>
+  local f
+  for f in "$1"/state/.mx-session-capture-*; do
+    [[ -f "$f" ]] || continue
+    [[ "$f" == *.fails ]] && continue
+    cat "$f"
+    return 0
+  done
+  return 0
+}
+
+fail_count_contents() { # <workdir>
+  local f
+  for f in "$1"/state/.mx-session-capture-*.fails; do
+    [[ -f "$f" ]] || continue
+    cat "$f"
+    return 0
+  done
+  return 0
+}
+
+# Space-separated basenames of everything in the state dir — failure diagnostics
+# only. Dotfiles are matched explicitly because the state files are hidden.
+list_state_dir() { # <workdir>
+  local f out=""
+  for f in "$1"/state/* "$1"/state/.[!.]*; do
+    [[ -e "$f" ]] || continue
+    out+="$(basename "$f") "
+  done
+  printf '%s' "$out"
+}
+
+# Number of `mx` invocations recorded by the stub (0 when it was never called).
+count_mx_calls() { # <workdir>
+  local log="$1/mx-calls.log"
+  [[ -f "$log" ]] || { echo 0; return 0; }
+  wc -l <"$log" | tr -d ' '
+}
+
+REAL_PATH="$PATH"
+
+# Build a shadow PATH directory: every executable on the current PATH symlinked
+# in, MINUS the named tools. Used to simulate a machine without md5sum (or
+# without any hasher) while leaving the rest of the environment intact.
+make_shadow_path() { # <dir> <tool-to-omit>...
+  local dir="$1"; shift
+  local omit=" $* "
+  local d f name
+  mkdir -p "$dir"
+  local IFS=:
+  for d in $REAL_PATH; do
+    [[ -d "$d" ]] || continue
+    for f in "$d"/*; do
+      [[ -x "$f" && ! -d "$f" ]] || continue
+      name="$(basename "$f")"
+      [[ "$omit" == *" $name "* ]] && continue
+      [[ -e "$dir/$name" ]] && continue
+      ln -sf "$f" "$dir/$name"
+    done
+  done
+}
+
+
+echo "── capture-session-end.sh ──"
+
+# 1. Failed create → watermark unchanged.
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+mkdir -p "$work/state" "$work/home"
+MX_STUB_EXIT=1 run_session_end "$work" "$work/bin:$REAL_PATH"
+assert_eq "0" "$(cat "$work/exit.txt")" "fail-open: hook exits 0 when create fails"
+assert_eq "" "$(state_file_contents "$work")" "failed create leaves the watermark unwritten"
+assert_contains "$(cat "$work/stderr.txt")" "mx memories create failed" \
+  "failed create writes one stderr diagnostic"
+rm -rf "$work"
+
+# 2. Successful create → watermark advances to the transcript's line count.
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+mkdir -p "$work/state" "$work/home"
+MX_STUB_EXIT=0 run_session_end "$work" "$work/bin:$REAL_PATH"
+assert_eq "0" "$(cat "$work/exit.txt")" "hook exits 0 on success"
+assert_eq "300" "$(state_file_contents "$work")" "successful create advances the watermark"
+rm -rf "$work"
+
+# 3. Retry semantics: a failed run followed by a successful one saves the same
+#    segment (the watermark only moves on the success).
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+mkdir -p "$work/state" "$work/home"
+MX_STUB_EXIT=1 run_session_end "$work" "$work/bin:$REAL_PATH"
+first="$(state_file_contents "$work")"
+MX_STUB_EXIT=0 run_session_end "$work" "$work/bin:$REAL_PATH"
+second="$(state_file_contents "$work")"
+assert_eq "" "$first" "first (failed) run: no watermark"
+assert_eq "300" "$second" "second (successful) run: watermark advances — segment was retried"
+rm -rf "$work"
+
+# 4. The default hasher is sha256sum (cksum was dropped from the chain: a
+#    32-bit CRC collision would make two projects share a state file).
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+mkdir -p "$work/state" "$work/home"
+MX_STUB_EXIT=0 run_session_end "$work" "$work/bin:$REAL_PATH"
+expected_hash=$(printf '%s' "$work" | sha256sum | awk '{print $1}')
+if [[ -f "$work/state/.mx-session-capture-${expected_hash}" ]]; then
+  ok "state file is keyed by the sha256 of the project dir"
+else
+  nope "state file is keyed by the sha256 of the project dir" \
+    "state dir holds: $(list_state_dir "$work")"
+fi
+rm -rf "$work"
+
+# 4b. sha256sum absent → the md5sum fallback engages (the old awk-piped chain
+#     silently produced an EMPTY hash shared by every project).
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+mkdir -p "$work/state" "$work/home"
+make_shadow_path "$work/nosha" sha256sum
+MX_STUB_EXIT=0 run_session_end "$work" "$work/bin:$work/nosha"
+expected_hash=$(printf '%s' "$work" | md5sum | awk '{print $1}')
+if [[ -f "$work/state/.mx-session-capture-${expected_hash}" ]]; then
+  ok "sha256sum absent: md5sum fallback produces the project-specific state file"
+else
+  nope "sha256sum absent: md5sum fallback engages" \
+    "state dir holds: $(list_state_dir "$work")"
+fi
+rm -rf "$work"
+
+# 4c. cksum alone is NOT accepted (32-bit CRC — collisions are constructible).
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+mkdir -p "$work/state" "$work/home"
+make_shadow_path "$work/onlycksum" sha256sum md5sum shasum b2sum
+MX_STUB_EXIT=0 run_session_end "$work" "$work/bin:$work/onlycksum"
+assert_eq "" "$(ls -A "$work/state" 2>/dev/null)" "cksum-only machine: skips rather than using a 32-bit CRC"
+rm -rf "$work"
+
+# 5. No hasher at all → skip with a diagnostic, and never write a shared
+#    (hash-less) state file that would suppress every other project.
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+mkdir -p "$work/state" "$work/home"
+make_shadow_path "$work/nohash" sha256sum md5sum shasum b2sum cksum
+MX_STUB_EXIT=0 run_session_end "$work" "$work/bin:$work/nohash"
+assert_eq "0" "$(cat "$work/exit.txt")" "no hasher: hook still exits 0"
+assert_eq "" "$(ls -A "$work/state" 2>/dev/null)" "no hasher: no shared state file is written"
+assert_contains "$(cat "$work/stderr.txt")" "no usable hash tool" \
+  "no hasher: stderr diagnostic explains the skip"
+rm -rf "$work"
+
+# ── Bounded retry (security review Must Fix) ────────────────────────────────
+# Leaving the watermark in place on failure removed the only bound on retry:
+# LINES_SINCE_SAVE stays >=100 forever, so every turn re-ran the whole
+# extraction and another non-idempotent create. The retry is now capped.
+
+# 6. Five consecutive retryable failures (exit 5): work stops after the cap.
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+mkdir -p "$work/state" "$work/home"
+# Per-run observations, indexed by run number. Arrays rather than eval'd
+# variable names so the assignment is traceable (by shellcheck and by a reader).
+declare -a watermark_after=() calls_after=() stderr_after=()
+for run in 1 2 3 4 5; do
+  MX_STUB_EXIT=5 run_session_end "$work" "$work/bin:$REAL_PATH"
+  watermark_after[run]="$(state_file_contents "$work")"
+  calls_after[run]="$(count_mx_calls "$work")"
+  stderr_after[run]="$(cat "$work/stderr.txt")"
+done
+assert_eq "" "${watermark_after[1]}" "retryable failure 1/3: watermark not advanced"
+assert_eq "" "${watermark_after[2]}" "retryable failure 2/3: watermark not advanced"
+assert_eq "300" "${watermark_after[3]}" "retryable failure 3/3: watermark advanced (cap reached)"
+assert_contains "${stderr_after[2]}" "retry 2/3 next trigger" "retry counter is reported on stderr"
+assert_contains "${stderr_after[3]}" "giving up" "cap is announced on stderr"
+assert_eq "3" "${calls_after[3]}" "3 create attempts by the cap"
+assert_eq "3" "${calls_after[5]}" "runs 4 and 5 attempt no create at all"
+assert_eq "" "$(fail_count_contents "$work")" "fail counter is cleared once the segment is dropped"
+rm -rf "$work"
+
+# 7. Terminal statuses are never retried — the watermark advances immediately.
+#    2 = validation (the request is malformed), 3 = auth, 124 = timeout (the
+#    server may already have persisted the memory; a retry would duplicate it,
+#    and the create is non-idempotent).
+for terminal in 2 3 124; do
+  work=$(mktemp -d)
+  make_stub_bin "$work/bin"
+  make_transcript "$work/transcript.jsonl"
+  mkdir -p "$work/state" "$work/home"
+  MX_STUB_EXIT="$terminal" run_session_end "$work" "$work/bin:$REAL_PATH"
+  assert_eq "300" "$(state_file_contents "$work")" \
+    "terminal exit ${terminal}: watermark advances on the first failure"
+  assert_eq "" "$(fail_count_contents "$work")" "terminal exit ${terminal}: no fail counter written"
+  assert_contains "$(cat "$work/stderr.txt")" "not retryable" \
+    "terminal exit ${terminal}: stderr names it as not retryable"
+  assert_contains "$(cat "$work/stderr.txt")" "exit ${terminal}" \
+    "terminal exit ${terminal}: stderr names the exit code"
+  rm -rf "$work"
+done
+
+# 8. A success after two failures clears the counter, so the next failure
+#    streak starts from 1 rather than tripping the cap immediately.
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+mkdir -p "$work/state" "$work/home"
+MX_STUB_EXIT=5 run_session_end "$work" "$work/bin:$REAL_PATH"
+MX_STUB_EXIT=5 run_session_end "$work" "$work/bin:$REAL_PATH"
+assert_eq "2" "$(fail_count_contents "$work")" "two failures: counter is at 2"
+MX_STUB_EXIT=0 run_session_end "$work" "$work/bin:$REAL_PATH"
+assert_eq "300" "$(state_file_contents "$work")" "success after 2 failures: watermark advances"
+assert_eq "" "$(fail_count_contents "$work")" "success after 2 failures: fail counter cleared"
+rm -rf "$work"
+
+# 8b. The counter is the only bound on the retry. If it cannot be persisted —
+#     the path exists but is not writable — the count silently resets to 0 every
+#     trigger and the cap never trips. Inability to bound must be terminal.
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+mkdir -p "$work/state" "$work/home"
+# Occupy the counter path with a DIRECTORY so the write can never succeed.
+project_hash=$(printf '%s' "$work" | sha256sum | awk '{print $1}')
+mkdir -p "$work/state/.mx-session-capture-${project_hash}.fails"
+MX_STUB_EXIT=5 run_session_end "$work" "$work/bin:$REAL_PATH"
+assert_eq "300" "$(state_file_contents "$work")" \
+  "unwritable counter: watermark advances on the FIRST failure"
+assert_contains "$(cat "$work/stderr.txt")" "cannot persist the retry counter" \
+  "unwritable counter: stderr names the reason"
+calls_after_run1=$(count_mx_calls "$work")
+MX_STUB_EXIT=5 run_session_end "$work" "$work/bin:$REAL_PATH"
+assert_eq "1" "$calls_after_run1" "unwritable counter: run 1 attempted exactly one create"
+assert_eq "1" "$(count_mx_calls "$work")" \
+  "unwritable counter: run 2 attempts no create"
+rm -rf "$work"
+
+echo "── capture-precompact.sh ──"
+
+# 6. Failed create → stderr diagnostic, still exit 0. (This hook has no
+#    watermark; none was invented.)
+work2=$(mktemp -d)
+make_stub_bin "$work2/bin"
+make_transcript "$work2/transcript.jsonl"
+mkdir -p "$work2/home"
+( cd "$work2" && PATH="$work2/bin:$REAL_PATH" HOME="$work2/home" MX_STUB_EXIT=1 \
+    bash "$PRECOMPACT_HOOK" \
+    <<<"{\"transcript_path\":\"$work2/transcript.jsonl\",\"session_id\":\"s1\",\"trigger\":\"auto\"}" \
+    2>"$work2/stderr.txt" >/dev/null )
+status2=$?
+assert_eq "0" "$status2" "precompact: exits 0 when create fails"
+assert_contains "$(cat "$work2/stderr.txt")" "mx memories create failed" \
+  "precompact: failed create writes a stderr diagnostic"
+rm -rf "$work2"
+
+echo "── dev-tools/claude-hooks/auto-save-memory.sh ──"
+
+run_autosave() { # <workdir> ; uses MX_STUB_EXIT
+  local work="$1"
+  ( cd "$work" && PATH="$work/bin:$REAL_PATH" MX_AUTOSAVE_STATE_FILE="$work/state-line" \
+      MX_STUB_LOG="$work/mx-calls.log" \
+      bash "$AUTOSAVE_HOOK" \
+      <<<"{\"transcript_path\":\"$work/transcript.jsonl\",\"stop_hook_active\":false}" \
+      2>"$work/stderr.txt" >/dev/null )
+  echo "$?" >"$work/exit.txt"
+}
+
+# 7. Failed create → the line-number watermark is not recorded, so the turn is
+#    retried instead of being skipped as "already saved".
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+MX_STUB_EXIT=1 run_autosave "$work"
+assert_eq "0" "$(cat "$work/exit.txt")" "auto-save: exits 0 when create fails"
+if [[ -f "$work/state-line" ]]; then
+  nope "auto-save: failed create leaves the watermark unwritten" \
+    "state-line holds: $(cat "$work/state-line")"
+else
+  ok "auto-save: failed create leaves the watermark unwritten"
+fi
+assert_contains "$(cat "$work/stderr.txt")" "mx memories create failed" \
+  "auto-save: failed create writes a stderr diagnostic"
+rm -rf "$work"
+
+# 8. Successful create → the watermark is recorded.
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+MX_STUB_EXIT=0 run_autosave "$work"
+assert_eq "0" "$(cat "$work/exit.txt")" "auto-save: exits 0 on success"
+if [[ -s "$work/state-line" ]]; then
+  ok "auto-save: successful create records the watermark"
+else
+  nope "auto-save: successful create records the watermark" "state-line missing or empty"
+fi
+rm -rf "$work"
+
+# 9. auto-save: the same bounded retry. Five consecutive retryable failures
+#    stop after the cap; terminal statuses advance immediately.
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+for run in 1 2 3 4 5; do
+  MX_STUB_EXIT=5 run_autosave "$work"
+done
+if [[ -s "$work/state-line" ]]; then
+  ok "auto-save: watermark advanced once the retry cap was reached"
+else
+  nope "auto-save: watermark advanced once the retry cap was reached" "state-line missing"
+fi
+assert_eq "3" "$(count_mx_calls "$work")" \
+  "auto-save: 3 create attempts across 5 runs (runs 4-5 attempt none)"
+if [[ -f "$work/state-line.fails" ]]; then
+  nope "auto-save: fail counter cleared after giving up" "counter still present"
+else
+  ok "auto-save: fail counter cleared after giving up"
+fi
+rm -rf "$work"
+
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+MX_STUB_EXIT=124 run_autosave "$work"
+if [[ -s "$work/state-line" ]]; then
+  ok "auto-save: timeout (124) is terminal — watermark advances, no duplicate-minting retry"
+else
+  nope "auto-save: timeout (124) is terminal" "state-line missing"
+fi
+assert_contains "$(cat "$work/stderr.txt")" "not retryable" \
+  "auto-save: timeout diagnostic names it as not retryable"
+rm -rf "$work"
+
+# 9b. auto-save: same unwritable-counter handling.
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+mkdir -p "$work/state-line.fails"
+MX_STUB_EXIT=5 run_autosave "$work"
+if [[ -s "$work/state-line" ]]; then
+  ok "auto-save: unwritable counter advances the watermark on the first failure"
+else
+  nope "auto-save: unwritable counter advances the watermark" "state-line missing"
+fi
+assert_contains "$(cat "$work/stderr.txt")" "cannot persist the retry counter" \
+  "auto-save: unwritable counter names the reason"
+MX_STUB_EXIT=5 run_autosave "$work"
+assert_eq "1" "$(count_mx_calls "$work")" \
+  "auto-save: unwritable counter — run 2 attempts no create"
+rm -rf "$work"
+
+# 10. precompact emits exactly one diagnostic per trigger (it has no watermark;
+#     one line per PreCompact event is inherent and bounded by the event).
+work=$(mktemp -d)
+make_stub_bin "$work/bin"
+make_transcript "$work/transcript.jsonl"
+mkdir -p "$work/home"
+( cd "$work" && PATH="$work/bin:$REAL_PATH" HOME="$work/home" MX_STUB_EXIT=5 \
+    bash "$PRECOMPACT_HOOK" \
+    <<<"{\"transcript_path\":\"$work/transcript.jsonl\",\"session_id\":\"s1\",\"trigger\":\"auto\"}" \
+    2>"$work/stderr.txt" >/dev/null )
+assert_eq "1" "$(grep -c 'mx memories create failed' "$work/stderr.txt")" \
+  "precompact: exactly one diagnostic per trigger"
+rm -rf "$work"
+
+echo ""
+echo "capture-hooks.test.sh: $PASS passed, $FAIL failed"
+[[ "$FAIL" -eq 0 ]] || exit 1
+exit 0

package/hooks/capture-precompact.sh

@@ -209,10 +209,20 @@ elif command -v gtimeout >/dev/null 2>&1; then
   TIMEOUT_CMD="gtimeout 10"
 fi
 
+# Capture the create's exit status instead of swallowing it with `|| true`: a
+# failed save was completely invisible, and this hook has NO watermark, so the
+# context was simply lost at compaction with no signal. Fail-open with Claude
+# Code is unchanged — the hook still always exits 0 and never blocks
+# compaction.
+CREATE_STATUS=0
 $TIMEOUT_CMD mx memories create \
   --conversation-id "NEW" \
   --content "$CONTENT" \
   --topics "auto-captured,precompact" \
-  >/dev/null 2>&1 || true
+  >/dev/null 2>&1 || CREATE_STATUS=$?
+
+if [[ "$CREATE_STATUS" -ne 0 ]]; then
+  echo "capture-precompact: mx memories create failed (exit ${CREATE_STATUS}) — pre-compaction context was NOT saved" >&2
+fi
 
 exit 0

package/hooks/capture-session-end.sh

@@ -55,13 +55,44 @@ if [[ -z "$PROJECT_DIR" || "$PROJECT_DIR" == "." ]]; then
 fi
 PROJECT_NAME=$(basename "$PROJECT_DIR" 2>/dev/null || echo "unknown")
 
-# Hash the project directory path for a unique, collision-free state filename
-PROJECT_HASH=$(echo "$PROJECT_DIR" | md5sum 2>/dev/null | awk '{print $1}' || \
-               echo "$PROJECT_DIR" | sha256sum 2>/dev/null | awk '{print $1}' || \
-               echo "$PROJECT_DIR" | cksum | awk '{print $1}')
+# Hash the project directory path for a unique, collision-free state filename.
+#
+# The previous form piped each hasher into awk, so the `||` chain tested awk's
+# exit status, not the hasher's. awk succeeds on empty input, so the very first
+# branch always "succeeded" and the sha256sum/cksum fallbacks were dead code:
+# on a machine without md5sum, PROJECT_HASH came out EMPTY and every project
+# shared one state file "…-capture-". Test the hasher's own availability.
+#
+# cksum is NOT in the chain: it is a 32-bit CRC, so a colliding project path is
+# constructible. A collision means two projects share a state file and one
+# project's watermark suppresses the other's capture. Ordered strongest first.
+hash_project_dir() {
+  local tool
+  for tool in sha256sum md5sum shasum b2sum; do
+    if command -v "$tool" >/dev/null 2>&1; then
+      printf '%s' "$PROJECT_DIR" | "$tool" 2>/dev/null | awk '{print $1}'
+      return 0
+    fi
+  done
+  # No hasher available. Return success with empty output so the ERR trap does
+  # not fire before the diagnostic below can print.
+  return 0
+}
+PROJECT_HASH=$(hash_project_dir)
+
+# An empty hash must never fall through to a shared state file: one project's
+# watermark would suppress every other project's capture.
+if [[ -z "$PROJECT_HASH" ]]; then
+  echo "capture-session-end: no usable hash tool (sha256sum/md5sum/shasum/b2sum) — skipping capture" >&2
+  exit 0
+fi
+
 STATE_DIR="${XDG_RUNTIME_DIR:-${HOME}/.memnexus/state}"
 mkdir -p "$STATE_DIR" 2>/dev/null
 STATE_FILE="${STATE_DIR}/.mx-session-capture-${PROJECT_HASH}"
+# Consecutive-failure counter for the bounded retry in section 8.
+FAIL_FILE="${STATE_FILE}.fails"
+MAX_CAPTURE_ATTEMPTS=3
 
 # ── 4. Debounce — only save when significant new work has accumulated ─────
 CURRENT_LINES=$(wc -l < "$TRANSCRIPT_PATH" 2>/dev/null || echo "0")
@@ -110,6 +141,7 @@ TOOL_COUNT=$(echo "$SEGMENT" | jq -r '
 # Skip if segment was trivial — update state so we don't recheck same lines
 if [[ "$TOOL_COUNT" -lt 5 && -z "$FILES_MODIFIED" ]]; then
   echo "$CURRENT_LINES" > "$STATE_FILE" 2>/dev/null || true
+  rm -f "$FAIL_FILE" 2>/dev/null || true
   exit 0
 fi
 
@@ -213,13 +245,75 @@ elif command -v gtimeout >/dev/null 2>&1; then
   TIMEOUT_CMD="gtimeout 10"
 fi
 
+# Capture the create's exit status. The `|| true` swallowed it, and the
+# watermark below advanced regardless — so a failed save silently discarded the
+# segment forever. Fail-open with Claude Code is unchanged: this hook still
+# always exits 0 and never blocks the session.
+CREATE_STATUS=0
 $TIMEOUT_CMD mx memories create \
   --conversation-id "NEW" \
   --content "$CONTENT" \
   --topics "auto-captured,session-summary" \
-  >/dev/null 2>&1 || true
+  >/dev/null 2>&1 || CREATE_STATUS=$?
+
+# ── 8. Update debounce state (bounded retry) ─────────────────────────────
+# Advance the watermark ONLY on a successful save, so a failed save is retried
+# rather than silently discarded — but BOUND that retry. Leaving the watermark
+# in place keeps LINES_SINCE_SAVE >= 100 forever, so on a persistent failure
+# every subsequent turn re-runs tail + six jq passes over an ever-growing
+# segment and another 10s-timeout create. The create is non-idempotent
+# (--conversation-id NEW), so a timeout against a slow-but-succeeding API would
+# mint one duplicate memory per turn.
+#
+# Terminal statuses are never retried:
+#   2   validation — the request is malformed; retrying re-sends it unchanged
+#   3   auth       — no credential change happens between turns
+#   124 timeout    — the server MAY have persisted the memory; a retry would
+#                    duplicate it
+# Retryable statuses (4 network, 5 server, anything else) get up to
+# MAX_CAPTURE_ATTEMPTS consecutive tries, then the segment is dropped.
+#
+# Fail-open with Claude Code is unchanged: this hook still always exits 0.
+read_fail_count() {
+  local n=0
+  if [[ -f "$FAIL_FILE" ]]; then
+    n=$(cat "$FAIL_FILE" 2>/dev/null || echo 0)
+  fi
+  [[ "$n" =~ ^[0-9]+$ ]] || n=0
+  echo "$n"
+}
 
-# ── 8. Update debounce state ─────────────────────────────────────────────
-echo "$CURRENT_LINES" > "$STATE_FILE" 2>/dev/null || true
+advance_watermark() {
+  echo "$CURRENT_LINES" > "$STATE_FILE" 2>/dev/null || true
+  rm -f "$FAIL_FILE" 2>/dev/null || true
+}
+
+if [[ "$CREATE_STATUS" -eq 0 ]]; then
+  advance_watermark
+else
+  case "$CREATE_STATUS" in
+    2 | 3 | 124)
+      advance_watermark
+      echo "capture-session-end: mx memories create failed (exit ${CREATE_STATUS}, not retryable) — segment dropped" >&2
+      ;;
+    *)
+      ATTEMPTS=$(( $(read_fail_count) + 1 ))
+      if [[ "$ATTEMPTS" -ge "$MAX_CAPTURE_ATTEMPTS" ]]; then
+        advance_watermark
+        echo "capture-session-end: mx memories create failed (exit ${CREATE_STATUS}) ${ATTEMPTS} times — giving up, segment dropped" >&2
+      elif ! echo "$ATTEMPTS" > "$FAIL_FILE" 2>/dev/null; then
+        # The counter is the only thing bounding the retry. If it cannot be
+        # persisted (path exists but is not writable, read-only state dir), the
+        # count silently resets to 0 on every trigger and the cap never trips —
+        # an unbounded loop of non-idempotent creates. Inability to bound is
+        # treated as terminal.
+        advance_watermark
+        echo "capture-session-end: cannot persist the retry counter — segment dropped" >&2
+      else
+        echo "capture-session-end: mx memories create failed (exit ${CREATE_STATUS}) — segment not saved, retry ${ATTEMPTS}/${MAX_CAPTURE_ATTEMPTS} next trigger" >&2
+      fi
+      ;;
+  esac
+fi
 
 exit 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memnexus-ai/cli",
-  "version": "1.7.219",
+  "version": "1.7.221",
   "description": "Command-line interface for MemNexus Core API",
   "main": "dist/index.js",
   "bin": {
@@ -34,7 +34,7 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@memnexus-ai/typescript-sdk": "^1.60.10",
+    "@memnexus-ai/typescript-sdk": "^1.67.1",
     "@modelcontextprotocol/sdk": "^1.27.1",
     "axios": "^1.13.6",
     "chalk": "^5.3.0",