muse-crew 0.14.0 → 0.14.2

package/lib/test-detached-integrate.sh

@@ -0,0 +1,340 @@
+#!/bin/bash
+# test-detached-integrate.sh — behavioral regression tests for the
+# detached-HEAD Integrate fix (room #21, J3, 2026-09-19).
+#
+# The defect: cmd_integrate ran require_clean_main, whose unconditional
+# `git checkout main` abandoned a detached-HEAD room line (reviewed SHA +
+# crew-init commit). Publish then failed closed on ancestry and the journey
+# parked. The fix: the integration target is the repo's current checkout
+# (branch name, or HEAD when detached); nothing in the lifecycle ever
+# checks out a branch.
+#
+# Fixture A (detached HEAD — the room #21 shape):
+#   reviewed commit A, detached HEAD, crew-init commit B on top, task
+#   branch from B with work commit C. Integrate must:
+#   1. report integration-target = HEAD
+#   2. MERGE with exit 0
+#   3. leave HEAD detached (no checkout happened)
+#   4. keep A (reviewed SHA) and B (crew-init) as ancestors of HEAD —
+#      the exact J3 failure was B being abandoned
+#   5. land C (the task work) as an ancestor of HEAD via a real merge
+#      commit with two parents
+#   6. NOT move the main branch (it still points at A)
+#   7. write integration_target=HEAD in the merge record
+#   8. verify-merge → VERIFIED
+#   9. push-target → PUSH_SKIPPED (detached HEAD has no remote counterpart)
+#
+# Fixture B (branch — the old behavior is preserved):
+#   repo on main with a local bare origin. Integrate merges, reconciles,
+#   and pushes inline; push-target also PUSHEDs to origin.
+#
+# Fixture C (detached HEAD, live-tip verify-merge — 2026-09-19 REVIEW):
+#   verify-merge must check the record against the LIVE HEAD, never the
+#   record's word for the tip: a detached line reset past the merge does
+#   NOT verify; with the branch gone it verifies only when the recorded
+#   commit is an ancestor of the live tip.
+#
+# Fixture D (branch, no remote — 2026-09-19 REVIEW blocker 3):
+#   the old push-target ran `git push origin` with no origin → exit 128
+#   mislabeled PUSH_REJECTED. Now the inline push fails soft with
+#   NO_REMOTE_PUSH and exit 0.
+#
+# Fixture E (staged-base guard — 2026-09-19 REVIEW #10):
+#   CREW_STAGED_BASE naming a non-ancestor fails closed with
+#   STAGED_BASE_MISMATCH before any merge; the true staged base proceeds
+#   with STAGED_BASE_OK.
+#
+# Fixture F (merged-but-unpushed retry recovery — 2026-09-19 REVIEW):
+#   a prior attempt merged but never pushed (lock released to simulate the
+#   crash): re-running integrate takes the lock and pushes instead of
+#   parking on MERGED_EMPTY.
+#
+# Hermetic: scratch dirs under /tmp only, removed at start (and end).
+set -u
+
+REPO_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+LIFECYCLE="$REPO_DIR/lib/worktree-lifecycle.sh"
+
+fail() { echo "FAIL: $1"; exit 1; }
+
+T=/tmp/crew-detached-integrate-test
+rm -rf "$T"
+mkdir -p "$T"
+
+# ---------------- Fixture A: detached HEAD ----------------
+A_DIR="$T/fixture-a"
+mkdir -p "$A_DIR"
+cd "$A_DIR"
+git init -q -b main .
+git config user.email test@test.t
+git config user.name test
+echo reviewed > f.txt
+git add -A
+git commit -qm "reviewed base"
+A_SHA=$(git rev-parse HEAD)
+
+# Detach at the reviewed SHA (clean-room staging pins it), then commit the
+# crew-init stamp on top — the detached line Integrate must not abandon.
+git checkout -q --detach HEAD
+echo crew-init >> f.txt
+git commit -qam "crew-init: stamp provenance"
+B_SHA=$(git rev-parse HEAD)
+git symbolic-ref -q HEAD >/dev/null && fail "fixture A: HEAD should be detached"
+
+export CREW_REPO="$A_DIR"
+export CREW_HOME="$A_DIR/home"
+export CREW_LIB="$REPO_DIR/lib"  # merge-lock.sh lives in the repo's lib, not the scratch crew home
+tid="detached1"
+
+# 1. integration-target resolves to HEAD
+out=$(bash "$LIFECYCLE" integration-target) || fail "integration-target exited non-zero: $out"
+[ "$out" = "HEAD" ] || fail "integration-target: expected HEAD, got: $out"
+
+# prepare + task work
+out=$(bash "$LIFECYCLE" prepare "$tid") || fail "prepare exited non-zero: $out"
+echo task-work >> "$A_DIR/.worktrees/$tid/f.txt"
+(cd "$A_DIR/.worktrees/$tid" && git commit -qam "task work")
+C_SHA=$(cd "$A_DIR/.worktrees/$tid" && git rev-parse HEAD)
+
+# 2. integrate
+out=$(bash "$LIFECYCLE" integrate "$tid" "merge: $tid" 2>&1) || fail "integrate exited non-zero: $out"
+echo "$out" | grep -q '^MERGED:' || fail "integrate: expected MERGED, got: $out"
+echo "$out" | grep -q 'NO_REMOTE_RECONCILE: detached HEAD' || fail "integrate: expected NO_REMOTE_RECONCILE, got: $out"
+
+# 3. HEAD is still detached — no checkout happened
+git symbolic-ref -q HEAD >/dev/null && fail "integrate checked out a branch: HEAD is now attached"
+
+# 4. the detached line survived: reviewed SHA and crew-init are ancestors
+git merge-base --is-ancestor "$A_SHA" HEAD || fail "reviewed SHA $A_SHA is no longer an ancestor of HEAD"
+git merge-base --is-ancestor "$B_SHA" HEAD || fail "crew-init commit $B_SHA was abandoned (the J3 defect)"
+
+# 5. the task work landed via a real merge commit
+git merge-base --is-ancestor "$C_SHA" HEAD || fail "task commit $C_SHA is not an ancestor of HEAD"
+MERGE_SHA=$(git rev-parse HEAD)
+parents=$(git rev-list --parents -n 1 "$MERGE_SHA" | wc -w)
+[ "$parents" -eq 3 ] || fail "expected a 2-parent merge commit, got $parents words in: $(git rev-list --parents -n 1 "$MERGE_SHA")"
+
+# 6. main was not touched
+MAIN_SHA=$(git rev-parse main)
+[ "$MAIN_SHA" = "$A_SHA" ] || fail "main moved during integrate: $MAIN_SHA != reviewed $A_SHA"
+
+# 7. merge record names the target
+rec=$(bash "$LIFECYCLE" merge-record "$tid")
+echo "$rec" | grep -q '^integration_target=HEAD$' || fail "merge record missing integration_target=HEAD: $rec"
+
+# 8. verify-merge
+out=$(bash "$LIFECYCLE" verify-merge "$tid") || fail "verify-merge exited non-zero: $out"
+echo "$out" | grep -q '^VERIFIED:' || fail "verify-merge: expected VERIFIED, got: $out"
+
+# 9. push-target skips loudly on a detached HEAD
+out=$(bash "$LIFECYCLE" push-target "$tid") || fail "push-target exited non-zero: $out"
+echo "$out" | grep -q '^PUSH_SKIPPED: detached HEAD' || fail "push-target: expected PUSH_SKIPPED, got: $out"
+
+echo "fixture A (detached HEAD): all checks passed"
+
+# ---------------- Fixture C: verify-merge checks the record against the LIVE tip ----------------
+# (2026-09-19 REVIEW blockers 1+2: the old verify-merge compared the merge
+# record against itself for target=HEAD — is-ancestor(X, X) is a tautology
+# that certified merges no longer on the line.)
+# Still in fixture A's repo ($A_DIR); task detached1 is merged at $MERGE_SHA.
+cd "$A_DIR"
+export CREW_REPO="$A_DIR"
+export CREW_HOME="$A_DIR/home"
+
+# C1: reset the detached line backward past the merge — the merge is no
+# longer on the line. verify-merge must NOT verify.
+git reset -q --hard "$B_SHA"
+out=$(bash "$LIFECYCLE" verify-merge "$tid" 2>&1) && fail "C1: verify-merge exited 0 for a merge no longer on the line: $out"
+echo "$out" | grep -q '^VERIFIED:' && fail "C1: VERIFIED a reset-away merge: $out"
+echo "C1: verify-merge rejects a detached line reset past the merge"
+
+# C2: restore the merge, remove the worktree, delete the task branch
+# (merge-lease reclaim path). verify-merge must VERIFY from the record —
+# but only because the recorded commit is an ancestor of the LIVE tip.
+git reset -q --hard "$MERGE_SHA"
+BRANCH=$(bash "$LIFECYCLE" resolve-branch "$tid") || fail "C2: resolve-branch failed"
+git worktree remove --force "$A_DIR/.worktrees/$tid" || fail "C2: worktree remove failed"
+git branch -q -D "$BRANCH" || fail "C2: could not delete task branch $BRANCH"
+out=$(bash "$LIFECYCLE" verify-merge "$tid" 2>&1) || fail "C2: verify-merge exited non-zero: $out"
+echo "$out" | grep -q '^VERIFIED:' || fail "C2: expected VERIFIED via record fallback, got: $out"
+echo "$out" | grep -q 'gone but recorded merge commit' || fail "C2: expected the branch-gone record path, got: $out"
+echo "fixture C (live-tip verify-merge): all checks passed"
+
+# ---------------- Fixture B: branch with a local origin ----------------
+B_DIR="$T/fixture-b"
+REMOTE="$T/remote.git"
+mkdir -p "$B_DIR"
+git init -q --bare "$REMOTE"
+cd "$B_DIR"
+git init -q -b main .
+git config user.email test@test.t
+git config user.name test
+echo base > f.txt
+git add -A
+git commit -qm "base"
+git remote add origin "$REMOTE"
+git push -q origin main
+
+export CREW_REPO="$B_DIR"
+export CREW_HOME="$B_DIR/home"
+tid="branch1"
+
+out=$(bash "$LIFECYCLE" integration-target) || fail "B integration-target exited non-zero"
+[ "$out" = "main" ] || fail "B integration-target: expected main, got: $out"
+
+out=$(bash "$LIFECYCLE" prepare "$tid") || fail "B prepare exited non-zero: $out"
+echo task-work >> "$B_DIR/.worktrees/$tid/f.txt"
+(cd "$B_DIR/.worktrees/$tid" && git commit -qam "task work")
+
+out=$(bash "$LIFECYCLE" integrate "$tid" "merge: $tid" 2>&1) || fail "B integrate exited non-zero: $out"
+echo "$out" | grep -q '^MERGED:' || fail "B integrate: expected MERGED, got: $out"
+echo "$out" | grep -q '^RECONCILED: merged origin/main into main' || fail "B integrate: expected RECONCILED, got: $out"
+
+rec=$(bash "$LIFECYCLE" merge-record "$tid")
+echo "$rec" | grep -q '^integration_target=main$' || fail "B merge record missing integration_target=main: $rec"
+
+out=$(bash "$LIFECYCLE" verify-merge "$tid") || fail "B verify-merge exited non-zero: $out"
+echo "$out" | grep -q '^VERIFIED:' || fail "B verify-merge: expected VERIFIED, got: $out"
+
+# push-target pushes the branch to the local origin
+out=$(bash "$LIFECYCLE" push-target "$tid" 2>&1) || fail "B push-target exited non-zero: $out"
+echo "$out" | grep -q '^PUSHED: origin/main' || fail "B push-target: expected PUSHED, got: $out"
+LOCAL_MAIN=$(git rev-parse main)
+REMOTE_MAIN=$(git --git-dir="$REMOTE" rev-parse refs/heads/main)
+[ "$LOCAL_MAIN" = "$REMOTE_MAIN" ] || fail "B origin/main not updated: $REMOTE_MAIN != $LOCAL_MAIN"
+
+echo "fixture B (branch + origin): all checks passed"
+
+# ---------------- Fixture D: branch target, no remote ----------------
+# (2026-09-19 REVIEW blocker 3: push-target ran `git push origin` with no
+# origin → exit 128 mislabeled PUSH_REJECTED. Now: fail-soft NO_REMOTE_PUSH.)
+D_DIR="$T/fixture-d"
+mkdir -p "$D_DIR"
+cd "$D_DIR"
+git init -q -b main .
+git config user.email test@test.t
+git config user.name test
+echo base > f.txt
+git add -A
+git commit -qm "base"
+export CREW_REPO="$D_DIR"
+# CREW_HOME lives OUTSIDE the repo (as in real rooms): the lock files are
+# crew state, and nesting them in the repo would trip the integrate
+# preflight on the retry in fixture F.
+export CREW_HOME="$T/home-d"
+tid="noremote1"
+
+out=$(bash "$LIFECYCLE" prepare "$tid") || fail "D prepare failed: $out"
+echo work >> "$D_DIR/.worktrees/$tid/f.txt"
+(cd "$D_DIR/.worktrees/$tid" && git commit -qam "work")
+
+# integrate pushes inline now: MERGED + NO_REMOTE (reconcile) + NO_REMOTE_PUSH
+out=$(bash "$LIFECYCLE" integrate "$tid" "merge: $tid" 2>&1) || fail "D integrate exited non-zero: $out"
+echo "$out" | grep -q '^MERGED:' || fail "D: expected MERGED, got: $out"
+echo "$out" | grep -q '^NO_REMOTE: no origin/main' || fail "D: expected NO_REMOTE reconcile skip, got: $out"
+echo "$out" | grep -q '^NO_REMOTE_PUSH: no origin remote configured' || fail "D: expected NO_REMOTE_PUSH, got: $out"
+
+# push-target directly (record exists, lock still held from integrate):
+# same fail-soft, exit 0
+out=$(bash "$LIFECYCLE" push-target "$tid" 2>&1) || fail "D push-target exited non-zero: $out"
+echo "$out" | grep -q '^NO_REMOTE_PUSH' || fail "D push-target: expected NO_REMOTE_PUSH, got: $out"
+
+echo "fixture D (branch, no remote): all checks passed"
+
+# ---------------- Fixture E: staged-base guard ----------------
+# (2026-09-19 REVIEW #10: a stray checkout redirecting the line must fail
+# closed at Integrate — before the merge lands on the wrong line.)
+E_DIR="$T/fixture-e"
+mkdir -p "$E_DIR"
+cd "$E_DIR"
+git init -q -b main .
+git config user.email test@test.t
+git config user.name test
+echo reviewed > f.txt
+git add -A
+git commit -qm "reviewed"
+E_BASE=$(git rev-parse HEAD)
+git checkout -q --detach HEAD
+echo init >> f.txt
+git commit -qam "crew-init"
+E_LINE=$(git rev-parse HEAD)
+export CREW_REPO="$E_DIR"
+export CREW_HOME="$E_DIR/home"
+tid="stagedbase1"
+
+out=$(bash "$LIFECYCLE" prepare "$tid") || fail "E prepare failed: $out"
+echo work >> "$E_DIR/.worktrees/$tid/f.txt"
+(cd "$E_DIR/.worktrees/$tid" && git commit -qam "work")
+
+# A base that is NOT an ancestor of the detached line: a sibling commit on
+# main (the shape a stray `git checkout main` leaves behind).
+git checkout -q main
+echo stray >> f.txt
+git commit -qam "stray main commit"
+STRAY_SHA=$(git rev-parse HEAD)
+git checkout -q --detach "$E_LINE"
+
+out=$(CREW_STAGED_BASE="$STRAY_SHA" bash "$LIFECYCLE" integrate "$tid" "merge: $tid" 2>&1) && \
+  fail "E: integrate with a non-ancestor staged base should fail: $out"
+echo "$out" | grep -q '^STAGED_BASE_MISMATCH' || fail "E: expected STAGED_BASE_MISMATCH, got: $out"
+[ "$(git rev-parse HEAD)" = "$E_LINE" ] || fail "E: HEAD moved despite STAGED_BASE_MISMATCH"
+
+# The real staged base is an ancestor — the merge proceeds.
+out=$(CREW_STAGED_BASE="$E_BASE" bash "$LIFECYCLE" integrate "$tid" "merge: $tid" 2>&1) || \
+  fail "E: integrate with the true staged base failed: $out"
+echo "$out" | grep -q '^STAGED_BASE_OK' || fail "E: expected STAGED_BASE_OK, got: $out"
+echo "$out" | grep -q '^MERGED:' || fail "E: expected MERGED, got: $out"
+
+echo "fixture E (staged-base guard): all checks passed"
+
+# ---------------- Fixture F: merged-but-unpushed retry recovery ----------------
+# (2026-09-19 REVIEW: a prior attempt's merge landed but its push never
+# completed — the retry must push instead of parking on MERGED_EMPTY.)
+# Reuse fixture D: task noremote1 is merged (recorded commit == live HEAD)
+# with no origin. Release the lock to simulate the crashed attempt, then
+# re-run integrate: ahead==0 and recorded==live → acquire + push now.
+cd "$D_DIR"
+export CREW_REPO="$D_DIR"
+export CREW_HOME="$T/home-d"
+"$REPO_DIR/lib/merge-lock.sh" release "noremote1" >/dev/null 2>&1 || fail "F: lock release failed"
+out=$(bash "$LIFECYCLE" integrate "noremote1" "merge: noremote1" 2>&1) || \
+  fail "F integrate exited non-zero: $out"
+echo "$out" | grep -q 'recovered: merge landed in a prior attempt' || \
+  fail "F: expected push recovery, got: $out"
+echo "$out" | grep -q '^NO_REMOTE_PUSH' || fail "F: expected NO_REMOTE_PUSH in recovery, got: $out"
+
+# F2: ancestor-based recovery — a prior attempt's push failed AFTER do_push's
+# retry path added a reconcile merge on top of the recorded commit, then
+# failed again. The record names M1 but live HEAD is M2 (M1's descendant).
+# Equality-based recovery would miss this and wrongly report MERGED_EMPTY —
+# a PASS with the push never completed.
+"$REPO_DIR/lib/merge-lock.sh" release "noremote1" >/dev/null 2>&1 || fail "F2: lock release failed"
+git commit -q --allow-empty -m "simulate: do_push retry-reconcile merge" || fail "F2: empty commit failed"
+out=$(bash "$LIFECYCLE" integrate "noremote1" "merge: noremote1" 2>&1) || \
+  fail "F2 integrate exited non-zero: $out"
+echo "$out" | grep -q 'recovered: merge landed in a prior attempt' || \
+  fail "F2: expected ancestor-based push recovery, got: $out"
+echo "$out" | grep -q '^MERGED_EMPTY' && fail "F2: wrongly MERGED_EMPTY while the push never completed: $out"
+
+echo "fixture F (merged-but-unpushed recovery): all checks passed"
+
+# ---------------- Fixture G: push-target after MERGED_EMPTY ----------------
+# (2026-09-19 REVIEW #8: MERGED_EMPTY takes no lock and writes no record —
+# push-target must skip loudly, not report a misleading "lock lost".)
+# Reuse fixture D's repo: a task with no commits ahead merges empty.
+cd "$D_DIR"
+export CREW_REPO="$D_DIR"
+export CREW_HOME="$T/home-d"
+tid="empty1"
+out=$(bash "$LIFECYCLE" prepare "$tid") || fail "G prepare failed: $out"
+# no commits in the worktree — nothing ahead of the target
+out=$(bash "$LIFECYCLE" integrate "$tid" "merge: $tid" 2>&1) || fail "G integrate exited non-zero: $out"
+echo "$out" | grep -q '^MERGED_EMPTY' || fail "G: expected MERGED_EMPTY, got: $out"
+out=$(bash "$LIFECYCLE" push-target "$tid" 2>&1) || fail "G push-target exited non-zero: $out"
+echo "$out" | grep -q 'no merge record' || fail "G: expected nothing-merged skip, got: $out"
+echo "$out" | grep -qi 'lock lost' && fail "G: misleading lock-lost error: $out"
+
+echo "fixture G (push-target after MERGED_EMPTY): all checks passed"
+
+rm -rf "$T"
+echo "PASS: detached-HEAD integrate fixtures"