@memnexus-ai/cli 1.7.234 → 1.7.236

package/hooks/capture-hooks.test.sh

@@ -1,465 +0,0 @@
-#!/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