#!/usr/bin/env bash
# tests/e2e-fix-round-4-5b2-c.sh
# End to end for fix round 4.5b2, part C (plan
# .claude/plans/trekplan-2026-11-03-review-gate-4-5b2-fixes.md, Step 6,
# End-to-end:). On throwaway fixture repos it writes run evidence the way
# /trekexecute Phase 8 does (node lib/review/merge-evidence.mjs write) and
# feeds hooks/scripts/pre-bash-executor.mjs Bash inputs the way Claude Code does:
#   1. `git merge --no-ff feat -m "merge: trekexecute demo"` on main
#      (/trekexecute's own order) asks with feat's Tested by line;
#   2. `git merge --no-ff feat && git merge --no-ff other` asks with the line
#      that says the run evidence is not shown, and no `Tested by: End-to-end`;
#   3. `git merge --cleanup strip --no-ff feat` asks with feat's Tested by line;
#   4. `git merge --no-ff -m "Merge run branch" other` with evidence only for
#      feat asks and never shows feat's evidence;
#   5. a tag named `feat` next to the branch: the writer refuses, and the
#      question shows no run evidence;
#   6. a write from a second worktree whose HEAD lags the branch: the question
#      reads `review not measured`.
# Prints one "ok - <case>" or "FAIL - <case>: <why>" line per case and
# "e2e: ok" at the end, exit 0; else exit 1. Starts nothing but node, git and
# the usual file tools. bash 3.2 compatible, ASCII only, no arrays.

set -u

cd "$(dirname "$0")/.." || { echo "FAIL - setup: cannot cd to the repo root"; exit 1; }
ROOT="$(pwd)"
HOOK="$ROOT/hooks/scripts/pre-bash-executor.mjs"
FILL="$ROOT/lib/review/fill-finding-ids.mjs"
WRITER="$ROOT/lib/review/merge-evidence.mjs"

unset CLAUDE_CODE_SESSION_ID

TMP="$(mktemp -d "${TMPDIR:-/tmp}/e2e-fix-round-4-5b2-c.XXXXXX")" || { echo "FAIL - setup: mktemp"; exit 1; }
trap 'rm -rf "$TMP"' EXIT
TMP="$(cd "$TMP" && pwd -P)" || { echo "FAIL - setup: cannot enter the temp directory"; exit 1; }

export LC_ALL=C
export LANG=C

FAILED=0
pass() { echo "ok - $1"; }
bad() { echo "FAIL - $1"; FAILED=$((FAILED + 1)); }

mkdir -p "$TMP/hooks-none" || { echo "FAIL - setup: cannot make the temp directories"; exit 1; }

# A review_version 1.2 ALLOW review with no findings of <start>..<end>
# (shape copied from tests/e2e-fix-round-4-5b2-b.sh mkreview.mjs).
# node mkreview.mjs <out> <start> <end>
cat > "$TMP/mkreview.mjs" <<'EOF'
import { writeFileSync } from 'node:fs';
const [out, start, end] = process.argv.slice(2);
const json = JSON.stringify({ verdict: 'ALLOW', counts: { BLOCKER: 0, MAJOR: 0, MINOR: 0, SUGGESTION: 0 }, allow_blocked_by: [], findings: [] }, null, 2);
writeFileSync(out, `---
type: trekreview
review_version: "1.2"
task: "t"
slug: e2e
project_dir: .claude/projects/2026-11-03-e2e/
brief_path: .claude/projects/2026-11-03-e2e/brief.md
scope_sha_start: ${start}
scope_sha_end: ${end}
reviewed_files_count: 1
verdict: ALLOW
findings: []
---

# Review: t

## Executive Summary

x

## Coverage

| File | Treatment | Reason |
|------|-----------|--------|
| a.mjs | deep-review | default |

## Declined to Judge

None.

Trimmed: 0

## Remediation Steps

None.

## Remediation Summary

x

\`\`\`json
${json}
\`\`\`
`);
EOF

# jfield <file> <expr>: prints the JS expression <expr> over the parsed JSON
# value `j` read from <file> (empty when it does not parse).
# (Copied from tests/e2e-fix-round-4-5b2-b.sh.)
jfield() {
  node -e '
const fs = require("fs");
let j;
try { j = JSON.parse(fs.readFileSync(process.argv[1], "utf8")); } catch (e) { process.exit(0); }
const v = Function("j", "return (" + process.argv[2] + ");")(j);
process.stdout.write(v === undefined || v === null ? "" : String(v));
' "$1" "$2"
}

# mkrepo <dir>: a git repo on main (a.mjs) with two branches one commit ahead
# each, feat (b.mjs) and other (c.mjs), checked out on main. Sets MAIN_SHA,
# FEAT and OTHER.
mkrepo() {
  r="$1"
  mkdir -p "$r" || return 1
  git -C "$r" init -q -b main || return 1
  printf '[user]\n\tname = Test\n\temail = test@example.invalid\n[commit]\n\tgpgsign = false\n[core]\n\thooksPath = "%s"\n' "$TMP/hooks-none" >> "$r/.git/config"
  printf 'export const a = 1;\n' > "$r/a.mjs"
  git -C "$r" add a.mjs && git -C "$r" commit -q -m 'chore: start' || return 1
  MAIN_SHA="$(git -C "$r" rev-parse HEAD)"
  git -C "$r" checkout -q -b feat || return 1
  printf 'export const b = 1;\n' > "$r/b.mjs"
  git -C "$r" add b.mjs && git -C "$r" commit -q -m 'feat: the work' || return 1
  FEAT="$(git -C "$r" rev-parse HEAD)"
  git -C "$r" checkout -q main || return 1
  git -C "$r" checkout -q -b other || return 1
  printf 'export const c = 1;\n' > "$r/c.mjs"
  git -C "$r" add c.mjs && git -C "$r" commit -q -m 'feat: the other work' || return 1
  OTHER="$(git -C "$r" rev-parse HEAD)"
  git -C "$r" checkout -q main || return 1
}

# mkproject <dir> <start> <end>: a run's artifacts (plan, progress, ALLOW
# review of <start>..<end>) outside the repo.
mkproject() {
  mkdir -p "$1" || return 1
  printf '# Plan\n\n### Step 1: End to end\n\n- **End-to-end:** `/bin/bash tests/e2e-demo.sh` -> expected: `e2e: ok`, exit 0.\n\n## Doors\n\n- two-way: a revert restores the old parser\n' > "$1/plan.md"
  printf '{"schema_version": "1", "status": "completed", "end_to_end": "verified", "plan_verification": {"status": "passed", "summary": {"total": 3, "passed": 3, "failed": 0, "blocked": 0, "unrunnable": 0}}}\n' > "$1/progress.json"
  node "$TMP/mkreview.mjs" "$1/review.md" "$2" "$3" && node "$FILL" "$1/review.md" > /dev/null
}

# writeev <repo> <branch> <project> <out>: the writer's CLI run from <repo>;
# prints its exit status.
writeev() {
  node "$WRITER" write --repo "$1" --branch "$2" --project "$3" --json > "$4" 2>&1
  echo $?
}

# record <repo> <branch> <sha> <label>: check out <branch> (HEAD at the
# reviewed commit, as Phase 8 runs), write its evidence, back to main.
# Returns 1 with the reason in WHY when the file is not written.
record() {
  WHY=""
  mkproject "$TMP/$4-project" "$MAIN_SHA" "$3" || { WHY="could not write the project"; return 1; }
  git -C "$1" checkout -q "$2" || { WHY="checkout $2"; return 1; }
  rc="$(writeev "$1" "$2" "$TMP/$4-project" "$TMP/$4-ev.out")"
  git -C "$1" checkout -q main || { WHY="checkout main"; return 1; }
  if [ "$rc" -ne 0 ] || [ "$(jfield "$TMP/$4-ev.out" 'j.written')" != true ] || [ ! -f "$1/.git/voyage/merge-evidence/$3.json" ]; then
    WHY="the writer exited $rc: $(cat "$TMP/$4-ev.out")"
    return 1
  fi
  return 0
}

# askhook <repo> <command> <label>: the guard on a Bash call in <repo>; sets
# DECISION and REASON (and HOOK_RC).
askhook() {
  node -e 'process.stdout.write(JSON.stringify({ hook_event_name: "PreToolUse", tool_name: "Bash", cwd: process.argv[1], tool_input: { command: process.argv[2] } }));' "$1" "$2" \
    | node "$HOOK" > "$TMP/$3-hook.out" 2> "$TMP/$3-hook.err"
  HOOK_RC=$?
  DECISION="$(jfield "$TMP/$3-hook.out" 'j.hookSpecificOutput.permissionDecision')"
  REASON="$(jfield "$TMP/$3-hook.out" 'j.hookSpecificOutput.permissionDecisionReason')"
}

# tested <sha>: the Tested by line the writer's evidence gives for <sha>.
tested() {
  printf 'Tested by: End-to-end `/bin/bash tests/e2e-demo.sh` exit 0; Verification 3/3; review ALLOW at %s.' "$(printf '%s' "$1" | cut -c1-8)"
}

UNDONE='Undone by: `git revert -m 1 <merge>` (two-way).'
NOT_SHOWN="Tested by: not shown (this command merges 2 branches into main; merge one at a time to see each run's evidence).
Undone by: not shown."
NO_EVIDENCE='Tested by: no run evidence.
Undone by: no run evidence.'

# The shared fixture of cases 1-3: evidence for both feat and other.
R="$TMP/both"
BOTH_OK=1
if ! mkrepo "$R"; then
  BOTH_OK=0
  BOTH_WHY="setup"
elif ! record "$R" feat "$FEAT" both-feat; then
  BOTH_OK=0
  BOTH_WHY="feat: $WHY"
elif ! record "$R" other "$OTHER" both-other; then
  BOTH_OK=0
  BOTH_WHY="other: $WHY"
fi
BOTH_FEAT="$FEAT"
BOTH_OTHER="$OTHER"

case_order() {
  name="the trekexecute merge order shows feat's Tested by line"
  if [ "$BOTH_OK" -ne 1 ]; then bad "$name: $BOTH_WHY"; return; fi
  askhook "$R" 'git merge --no-ff feat -m "merge: trekexecute demo"' order
  want="$(tested "$BOTH_FEAT")
$UNDONE"
  if [ "$HOOK_RC" -ne 0 ] || [ "$DECISION" != ask ]; then
    bad "$name: the guard exited $HOOK_RC with decision [$DECISION]: $(cat "$TMP/order-hook.out" "$TMP/order-hook.err")"
    return
  fi
  case "$REASON" in
    *"$want") pass "$name" ;;
    *) bad "$name: the reason does not end with [$want]: $REASON" ;;
  esac
}

case_two() {
  name="two merges in one command say the run evidence is not shown"
  if [ "$BOTH_OK" -ne 1 ]; then bad "$name: $BOTH_WHY"; return; fi
  askhook "$R" 'git merge --no-ff feat && git merge --no-ff other' two
  if [ "$HOOK_RC" -ne 0 ] || [ "$DECISION" != ask ]; then
    bad "$name: the guard exited $HOOK_RC with decision [$DECISION]: $(cat "$TMP/two-hook.out" "$TMP/two-hook.err")"
    return
  fi
  case "$REASON" in
    *'Tested by: End-to-end'*) bad "$name: a Tested by: End-to-end line is shown: $REASON"; return ;;
  esac
  case "$REASON" in
    *"$NOT_SHOWN"*) pass "$name" ;;
    *) bad "$name: no not-shown line [$NOT_SHOWN] in: $REASON" ;;
  esac
}

case_cleanup() {
  name="git merge --cleanup strip shows feat's Tested by line"
  if [ "$BOTH_OK" -ne 1 ]; then bad "$name: $BOTH_WHY"; return; fi
  askhook "$R" 'git merge --cleanup strip --no-ff feat' cleanup
  want="$(tested "$BOTH_FEAT")
$UNDONE"
  if [ "$HOOK_RC" -ne 0 ] || [ "$DECISION" != ask ]; then
    bad "$name: the guard exited $HOOK_RC with decision [$DECISION]: $(cat "$TMP/cleanup-hook.out" "$TMP/cleanup-hook.err")"
    return
  fi
  case "$REASON" in
    *"$want"*) pass "$name" ;;
    *) bad "$name: no [$want] in: $REASON" ;;
  esac
}

case_message() {
  name="a quoted -m before another branch never shows feat's evidence"
  R4="$TMP/message"
  mkrepo "$R4" || { bad "$name: setup"; return; }
  record "$R4" feat "$FEAT" message-feat || { bad "$name: $WHY"; return; }
  if [ -e "$R4/.git/voyage/merge-evidence/$OTHER.json" ]; then bad "$name: Control: other has evidence"; return; fi
  askhook "$R4" 'git merge --no-ff -m "Merge run branch" other' message
  if [ "$HOOK_RC" -ne 0 ] || [ "$DECISION" != ask ]; then
    bad "$name: the guard exited $HOOK_RC with decision [$DECISION]: $(cat "$TMP/message-hook.out" "$TMP/message-hook.err")"
    return
  fi
  case "$REASON" in
    *"$(tested "$FEAT")"*) bad "$name: feat's Tested by line is shown: $REASON" ;;
    *'Tested by: End-to-end'*) bad "$name: a Tested by: End-to-end line is shown, other has no evidence: $REASON" ;;
    *'Tested by:'*) pass "$name" ;;
    *) bad "$name: no Tested by line at all: $REASON" ;;
  esac
}

case_tag() {
  name="a tag named feat: the writer refuses and the question shows no run evidence"
  R5="$TMP/tag"
  mkrepo "$R5" || { bad "$name: setup"; return; }
  # Evidence written while the name was a branch only.
  record "$R5" feat "$FEAT" tag-feat || { bad "$name: Control: $WHY"; return; }
  git -C "$R5" update-ref refs/tags/feat "$MAIN_SHA" || { bad "$name: update-ref"; return; }
  git -C "$R5" checkout -q feat 2> "$TMP/tag-checkout.err" || { bad "$name: checkout feat: $(cat "$TMP/tag-checkout.err")"; return; }
  rc="$(writeev "$R5" feat "$TMP/tag-feat-project" "$TMP/tag-ev2.out")"
  git -C "$R5" checkout -q main || { bad "$name: checkout main"; return; }
  written="$(jfield "$TMP/tag-ev2.out" 'j.written')"
  why="$(jfield "$TMP/tag-ev2.out" 'j.reason')"
  case "$why" in
    *'branch name feat is ambiguous'*) ;;
    *) bad "$name: the writer exited $rc, written [$written]: $(cat "$TMP/tag-ev2.out")"; return ;;
  esac
  if [ "$rc" -ne 1 ] || [ "$written" != false ]; then
    bad "$name: the writer exited $rc, written [$written]: $(cat "$TMP/tag-ev2.out")"
    return
  fi
  askhook "$R5" 'git merge --no-ff feat' tag
  if [ "$HOOK_RC" -ne 0 ] || [ "$DECISION" != ask ]; then
    bad "$name: the guard exited $HOOK_RC with decision [$DECISION]: $(cat "$TMP/tag-hook.out" "$TMP/tag-hook.err")"
    return
  fi
  case "$REASON" in
    *'Tested by: End-to-end'*) bad "$name: a Tested by: End-to-end line is shown: $REASON" ;;
    *"$NO_EVIDENCE"*) pass "$name" ;;
    *) bad "$name: no [$NO_EVIDENCE] in: $REASON" ;;
  esac
}

case_worktree() {
  name="a write from a worktree whose HEAD lags the branch reads review not measured"
  R6="$TMP/wt"
  mkrepo "$R6" || { bad "$name: setup"; return; }
  REVIEWED="$FEAT"
  mkproject "$TMP/wt-project" "$MAIN_SHA" "$REVIEWED" || { bad "$name: could not write the project"; return; }
  git -C "$R6" worktree add -q --detach "$TMP/wt-second" "$REVIEWED" || { bad "$name: worktree add"; return; }
  # The branch moves on in the first worktree.
  git -C "$R6" checkout -q feat || { bad "$name: checkout feat"; return; }
  printf 'export const b = 2;\n' > "$R6/b.mjs"
  git -C "$R6" add b.mjs && git -C "$R6" commit -q -m 'feat: more' || { bad "$name: commit"; return; }
  HEAD2="$(git -C "$R6" rev-parse HEAD)"
  git -C "$R6" checkout -q main || { bad "$name: checkout main"; return; }
  if [ "$(git -C "$TMP/wt-second" rev-parse HEAD)" != "$REVIEWED" ] || [ "$HEAD2" = "$REVIEWED" ]; then
    bad "$name: Control: the second worktree's HEAD does not lag the branch"
    return
  fi
  rc="$(writeev "$TMP/wt-second" feat "$TMP/wt-project" "$TMP/wt-ev.out")"
  if [ "$rc" -ne 0 ] || [ "$(jfield "$TMP/wt-ev.out" 'j.written')" != true ] || [ ! -f "$R6/.git/voyage/merge-evidence/$HEAD2.json" ]; then
    bad "$name: the writer exited $rc: $(cat "$TMP/wt-ev.out")"
    return
  fi
  askhook "$R6" 'git merge --no-ff feat' wt
  sha8="$(printf '%s' "$REVIEWED" | cut -c1-8)"
  if [ "$HOOK_RC" -ne 0 ] || [ "$DECISION" != ask ]; then
    bad "$name: the guard exited $HOOK_RC with decision [$DECISION]: $(cat "$TMP/wt-hook.out" "$TMP/wt-hook.err")"
    return
  fi
  case "$REASON" in
    *'review ALLOW'*) bad "$name: a review verdict is shown: $REASON" ;;
    *"review not measured at $sha8."*) pass "$name" ;;
    *) bad "$name: no [review not measured at $sha8.] in: $REASON" ;;
  esac
}

case_order
case_two
case_cleanup
case_message
case_tag
case_worktree

if [ "$FAILED" -ne 0 ]; then
  echo "e2e: $FAILED case(s) failed"
  exit 1
fi
echo "e2e: ok"
exit 0