@mmerterden/multi-agent-pipeline 12.7.0 → 12.9.0

package/pipeline/scripts/smoke-phase-tracker.sh

@@ -1,324 +0,0 @@
-#!/usr/bin/env bash
-# smoke-phase-tracker.sh  -  contract check for phase-tracker.sh.
-#
-# Verifies state file shape, status transitions, sub-phase add/update,
-# enum enforcement, render output structure, and that the .tracker-current
-# pointer redirects subsequent invocations.
-
-set -uo pipefail
-
-HERE="$(cd "$(dirname "$0")" && pwd)"
-ROOT="$(cd "$HERE/../.." && pwd)"
-SCRIPT="$ROOT/pipeline/scripts/phase-tracker.sh"
-
-# Use a sandbox HOME so init writes into a temp tree, not the real one.
-SANDBOX_HOME="$(mktemp -d -t multi-agent-tracker-XXXX)"
-trap 'rm -rf "$SANDBOX_HOME"' EXIT
-export HOME="$SANDBOX_HOME"
-
-PASS=0
-FAIL=0
-pass() { PASS=$((PASS+1)); echo "  ✓ $1"; }
-fail() { FAIL=$((FAIL+1)); echo "  ✗ $1"; }
-
-need() { command -v "$1" >/dev/null 2>&1 || { echo "error: $1 is required" >&2; exit 127; }; }
-need jq
-
-run_plain() {
-  TERM=dumb "$SCRIPT" "$@" 2>/tmp/tracker-err
-}
-run_plain_status() {
-  local rc=0
-  TERM=dumb "$SCRIPT" "$@" >/dev/null 2>/tmp/tracker-err || rc=$?
-  echo "$rc"
-}
-
-STATE_FILE="$SANDBOX_HOME/.claude/logs/multi-agent/TASK-1/tracker-state.json"
-
-echo "→ 1. init creates state file with empty phases"
-run_plain init TASK-1 >/dev/null
-[ -f "$STATE_FILE" ] && pass "state file created at expected path" || fail "state file not at $STATE_FILE"
-PHASES=$(jq '.phases | length' "$STATE_FILE")
-[ "$PHASES" = "0" ] && pass "starts with empty phases array" || fail "expected 0 phases, got $PHASES"
-TASK_ID=$(jq -r '.task_id' "$STATE_FILE")
-[ "$TASK_ID" = "TASK-1" ] && pass "task_id persisted" || fail "task_id wrong: $TASK_ID"
-
-echo ""
-echo "→ 2. .tracker-current pointer is written"
-POINTER="$SANDBOX_HOME/.claude/logs/multi-agent/.tracker-current"
-[ -f "$POINTER" ] && pass "pointer file exists" || fail "pointer not created"
-[ "$(cat "$POINTER")" = "$STATE_FILE" ] && pass "pointer points at correct state file" || fail "pointer wrong"
-
-echo ""
-echo "→ 3. add appends pending phases"
-run_plain add 0 "Init" >/dev/null
-run_plain add 1 "Analysis" >/dev/null
-run_plain add 2 "Planning" >/dev/null
-PHASES=$(jq '.phases | length' "$STATE_FILE")
-[ "$PHASES" = "3" ] && pass "3 phases registered" || fail "expected 3, got $PHASES"
-P0_STATUS=$(jq -r '.phases[0].status' "$STATE_FILE")
-[ "$P0_STATUS" = "pending" ] && pass "new phase defaults to pending" || fail "expected pending, got $P0_STATUS"
-
-echo ""
-echo "→ 4. update transitions status"
-run_plain update 0 in_progress >/dev/null
-[ "$(jq -r '.phases[0].status' "$STATE_FILE")" = "in_progress" ] && pass "pending → in_progress" || fail "transition failed"
-run_plain update 0 completed >/dev/null
-[ "$(jq -r '.phases[0].status' "$STATE_FILE")" = "completed" ] && pass "in_progress → completed" || fail "transition failed"
-
-echo ""
-echo "→ 5. status enum enforcement"
-RC=$(run_plain_status update 0 nonsense)
-[ "$RC" = "64" ] && pass "bogus status rejected (exit 64)" || fail "bogus status accepted (rc=$RC)"
-
-echo ""
-echo "→ 6. sub adds and updates a sub-phase"
-run_plain sub 1 1 "Stack detection" completed >/dev/null
-run_plain sub 1 2 "Codebase scan" in_progress >/dev/null
-SUBS=$(jq '.phases[1].subs | length' "$STATE_FILE")
-[ "$SUBS" = "2" ] && pass "two subs added under phase 1" || fail "expected 2 subs, got $SUBS"
-S2_STATUS=$(jq -r '.phases[1].subs[1].status' "$STATE_FILE")
-[ "$S2_STATUS" = "in_progress" ] && pass "sub 1.2 is in_progress" || fail "wrong status: $S2_STATUS"
-# Update existing sub (same id, change status)
-run_plain sub 1 2 "Codebase scan" completed >/dev/null
-S2_STATUS=$(jq -r '.phases[1].subs[1].status' "$STATE_FILE")
-[ "$S2_STATUS" = "completed" ] && pass "existing sub updated in place (no duplicate)" || fail "in-place update failed"
-SUBS=$(jq '.phases[1].subs | length' "$STATE_FILE")
-[ "$SUBS" = "2" ] && pass "still 2 subs (no duplication)" || fail "duplicate created (got $SUBS)"
-
-echo ""
-echo "→ 7. render output contains the title and box borders"
-OUT=$(run_plain render)
-echo "$OUT" | grep -q "Pipeline: TASK-1" && pass "render shows task title" || fail "title missing"
-echo "$OUT" | grep -q '╭─' && pass "top border present" || fail "top border missing"
-echo "$OUT" | grep -q '╰──' && pass "bottom border present" || fail "bottom border missing"
-
-echo ""
-echo "→ 8. plain mode strips ANSI"
-if echo "$OUT" | grep -q $'\033\['; then
-  fail "ANSI escapes leaked into TERM=dumb output"
-else
-  pass "no ANSI under TERM=dumb"
-fi
-
-echo ""
-echo "→ 9. unknown action → exit 64"
-RC=$(run_plain_status flarfle)
-[ "$RC" = "64" ] && pass "unknown action rejected" || fail "unknown action got rc=$RC"
-
-echo ""
-echo "→ 10. update stamps started_at on first in_progress (v5.4.0)"
-run_plain init BAR-1 >/dev/null
-run_plain add 0 "Init" >/dev/null
-run_plain update 0 in_progress >/dev/null
-STATE_B1="$HOME/.claude/logs/multi-agent/BAR-1/tracker-state.json"
-STARTED=$(jq -r '.phases[0].started_at // ""' "$STATE_B1")
-[ -n "$STARTED" ] && pass "started_at stamped: $STARTED" || fail "started_at not stamped"
-
-echo ""
-echo "→ 11. update stamps completed_at on terminal status (completed/failed/skipped)"
-run_plain update 0 completed >/dev/null
-COMPLETED=$(jq -r '.phases[0].completed_at // ""' "$STATE_B1")
-[ -n "$COMPLETED" ] && pass "completed status stamps completed_at" || fail "completed did not stamp"
-
-run_plain add 1 "FailPhase" >/dev/null
-run_plain update 1 in_progress >/dev/null
-run_plain update 1 failed >/dev/null
-[ "$(jq -r '.phases[1].completed_at // ""' "$STATE_B1")" != "" ] && pass "failed stamps completed_at" || fail "failed did not stamp"
-
-run_plain add 2 "SkipPhase" >/dev/null
-run_plain update 2 skipped >/dev/null
-[ "$(jq -r '.phases[2].completed_at // ""' "$STATE_B1")" != "" ] && pass "skipped stamps completed_at" || fail "skipped did not stamp"
-
-echo ""
-echo "→ 12. started_at idempotent on repeat in_progress (v5.4.0)"
-run_plain init BAR-2 >/dev/null
-run_plain add 0 "X" >/dev/null
-run_plain update 0 in_progress >/dev/null
-STATE_B2="$HOME/.claude/logs/multi-agent/BAR-2/tracker-state.json"
-FIRST_TS=$(jq -r '.phases[0].started_at' "$STATE_B2")
-sleep 1
-run_plain update 0 in_progress >/dev/null
-SECOND_TS=$(jq -r '.phases[0].started_at' "$STATE_B2")
-[ "$FIRST_TS" = "$SECOND_TS" ] && pass "started_at preserved on repeat update" || fail "started_at changed: $FIRST_TS → $SECOND_TS"
-
-echo ""
-echo "→ 13. render draws 16-char progress bar + elapsed labels (v5.4.0)"
-run_plain init BAR-3 >/dev/null
-for p in 0:Init 1:Dev 2:Commit; do
-  run_plain add "${p%%:*}" "${p#*:}" >/dev/null
-done
-STATE_B3="$HOME/.claude/logs/multi-agent/BAR-3/tracker-state.json"
-NOW_S=$(date +%s)
-mk_ts() { date -u -r "$1" +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null || date -u -d "@$1" +"%Y-%m-%dT%H:%M:%SZ"; }
-jq \
-  --arg s0 "$(mk_ts $((NOW_S - 300)))" --arg e0 "$(mk_ts $((NOW_S - 295)))" \
-  --arg s1 "$(mk_ts $((NOW_S - 280)))" --arg e1 "$(mk_ts $((NOW_S - 120)))" \
-  --arg s2 "$(mk_ts $((NOW_S - 60)))"  --arg e2 "$(mk_ts $((NOW_S - 58)))" \
-  '.phases |= map(
-    if .id=="0" then .status="completed"|.started_at=$s0|.completed_at=$e0
-    elif .id=="1" then .status="completed"|.started_at=$s1|.completed_at=$e1
-    elif .id=="2" then .status="completed"|.started_at=$s2|.completed_at=$e2
-    else . end)' "$STATE_B3" > "$STATE_B3.new" && mv "$STATE_B3.new" "$STATE_B3"
-OUT_BAR=$(run_plain render)
-echo "$OUT_BAR" | grep -q "5s" && pass "elapsed formatted as '5s'" || fail "'5s' missing in render"
-echo "$OUT_BAR" | grep -qE "2m 40s|160s" && pass "elapsed formatted as '2m 40s' (160s)" || fail "2m-range elapsed missing"
-# v8.1.0: progress bar removed; elapsed label is the only timing visualization.
-
-echo ""
-echo "→ 14. graceful fallback on old state without timestamps (v5.4.0)"
-mkdir -p "$HOME/.claude/logs/multi-agent/OLD-SCHEMA"
-cat > "$HOME/.claude/logs/multi-agent/OLD-SCHEMA/tracker-state.json" <<'JSON'
-{"task_id":"OLD-SCHEMA","started_at":"","phases":[
-  {"id":"0","name":"Init","status":"completed","subs":[]},
-  {"id":"1","name":"Dev","status":"in_progress","subs":[]}
-]}
-JSON
-echo "$HOME/.claude/logs/multi-agent/OLD-SCHEMA/tracker-state.json" > "$HOME/.claude/logs/multi-agent/.tracker-current"
-OUT_OLD=$(TERM=dumb "$SCRIPT" render 2>&1)
-OLD_RC=$?
-[ "$OLD_RC" -eq 0 ] && pass "render exits 0 on old-schema state" || fail "render exit=$OLD_RC on old state"
-echo "$OUT_OLD" | grep -q "Phase 0" && pass "renders Phase 0 from old state" || fail "Phase 0 missing"
-# v8.1.0: progress bar removed entirely; old-schema state should still render text.
-
-echo ""
-echo "→ 15. tokens action accumulates per phase (v5.5.0)"
-run_plain init TOK-1 >/dev/null
-run_plain add 0 "Init" >/dev/null
-run_plain tokens 0 100 50 >/dev/null
-run_plain tokens 0 200 75 >/dev/null
-STATE_T1="$HOME/.claude/logs/multi-agent/TOK-1/tracker-state.json"
-TIN=$(jq -r '.phases[0].tokens_in // 0' "$STATE_T1")
-TOUT=$(jq -r '.phases[0].tokens_out // 0' "$STATE_T1")
-[ "$TIN" = "300" ] && pass "tokens_in accumulated (100+200=300)" || fail "tokens_in=$TIN expected 300"
-[ "$TOUT" = "125" ] && pass "tokens_out accumulated (50+75=125)" || fail "tokens_out=$TOUT expected 125"
-
-echo ""
-echo "→ 16. tokens validates non-negative integers (v5.5.0)"
-RC=$(run_plain_status tokens 0 foo 10)
-[ "$RC" = "64" ] && pass "non-integer rejected (exit 64)" || fail "non-integer got rc=$RC"
-RC=$(run_plain_status tokens 0 -5 10)
-[ "$RC" = "64" ] && pass "negative rejected (exit 64)" || fail "negative got rc=$RC"
-
-echo ""
-echo "→ 17. render shows token label per phase + total footer (v5.5.0)"
-run_plain init TOK-2 >/dev/null
-run_plain add 0 "Init" >/dev/null
-run_plain add 1 "Dev" >/dev/null
-run_plain tokens 0 180 50 >/dev/null       # 230 → "230"
-run_plain tokens 1 14500 4200 >/dev/null    # 18700 → "18.7k"
-OUT_TOK=$(run_plain render)
-echo "$OUT_TOK" | grep -qE "230 tok" && pass "raw count '230 tok' rendered" || fail "'230 tok' missing"
-echo "$OUT_TOK" | grep -qE "18\.7k tok" && pass "k-formatted '18.7k tok' rendered" || fail "'18.7k tok' missing"
-echo "$OUT_TOK" | grep -qE "Total.*18\.9k tok" && pass "Total footer '18.9k tok' rendered" || fail "Total footer missing (expected 18.9k)"
-
-echo ""
-echo "→ 18. pending phases without tokens render no label (v5.5.0)"
-run_plain init TOK-3 >/dev/null
-run_plain add 0 "Empty" >/dev/null
-OUT_NOP=$(run_plain render)
-# Should NOT contain " tok" string since no tokens recorded
-if echo "$OUT_NOP" | grep -qE "tok"; then
-  fail "phase without tokens should not show 'tok' label"
-else
-  pass "phase without tokens: no 'tok' label"
-fi
-# No "Total" footer when total is 0
-if echo "$OUT_NOP" | grep -q "Total"; then
-  fail "no-token tracker should not show Total footer"
-else
-  pass "no-token tracker: no Total footer"
-fi
-
-echo ""
-echo "→ 19. tokens action re-renders live (v5.6.0)"
-run_plain init TOK-LIVE >/dev/null
-run_plain add 0 "Init" >/dev/null
-run_plain update 0 in_progress >/dev/null
-# Without TRACKER_QUIET the tokens call MUST emit a render to stdout
-LIVE_OUT=$(run_plain tokens 0 500 250)
-echo "$LIVE_OUT" | grep -qE "750 tok" && pass "tokens action re-renders with new total (750 tok)" || fail "tokens did not re-render (out: $LIVE_OUT)"
-# With TRACKER_QUIET=1 the tokens call must NOT emit a render
-QUIET_OUT=$(TRACKER_QUIET=1 run_plain tokens 0 100 50)
-if [ -n "$QUIET_OUT" ]; then
-  fail "TRACKER_QUIET=1 should suppress render (got: $QUIET_OUT)"
-else
-  pass "TRACKER_QUIET=1 suppresses re-render"
-fi
-# State still updated under TRACKER_QUIET (accumulation must still happen)
-STATE_LIVE="$HOME/.claude/logs/multi-agent/TOK-LIVE/tracker-state.json"
-TIN_LIVE=$(jq -r '.phases[0].tokens_in // 0' "$STATE_LIVE")
-[ "$TIN_LIVE" = "600" ] && pass "TRACKER_QUIET still accumulates state (500+100=600)" || fail "quiet mode broke accumulation (got $TIN_LIVE)"
-
-echo ""
-echo "→ 20. now action: quiet, truncating current-action line"
-run_plain init NOW-1 >/dev/null
-run_plain add 3 "Dev" >/dev/null
-run_plain update 3 in_progress >/dev/null
-NOW_OUT=$(run_plain now 3 "editing TopBarView.swift")
-if [ -n "$NOW_OUT" ]; then
-  fail "now must not render (got: $NOW_OUT)"
-else
-  pass "now is quiet (no stdout)"
-fi
-STATE_NOW="$HOME/.claude/logs/multi-agent/NOW-1/tracker-state.json"
-NOW_VAL=$(jq -r '.phases[0].meta.Now' "$STATE_NOW")
-[ "$NOW_VAL" = "editing TopBarView.swift" ] && pass "now stored in meta.Now" || fail "meta.Now wrong: $NOW_VAL"
-run_plain now 3 "this is a deliberately very long current action description that exceeds sixty characters"
-NOW_LEN=$(jq -r '.phases[0].meta.Now | length' "$STATE_NOW")
-[ "$NOW_LEN" = "60" ] && pass "now truncates to 60 chars" || fail "expected 60 chars, got $NOW_LEN"
-RENDER_NOW=$(run_plain render)
-echo "$RENDER_NOW" | grep -q "Now:" && pass "render shows Now: line for active phase" || fail "render missing Now: line"
-
-echo ""
-echo "→ 21. add is idempotent (continuation contract)"
-run_plain tokens 3 1000 200 >/dev/null
-run_plain add 3 "DevRenamed" >/dev/null
-CNT=$(jq '.phases | length' "$STATE_NOW")
-[ "$CNT" = "1" ] && pass "duplicate add does not append" || fail "expected 1 phase, got $CNT"
-NAME3=$(jq -r '.phases[0].name' "$STATE_NOW")
-[ "$NAME3" = "Dev" ] && pass "duplicate add preserves original name" || fail "name overwritten: $NAME3"
-TIN3=$(jq -r '.phases[0].tokens_in' "$STATE_NOW")
-[ "$TIN3" = "1000" ] && pass "duplicate add preserves token history" || fail "tokens lost: $TIN3"
-
-echo ""
-echo "→ 22. cost action prices via cost-table.json"
-run_plain init COST-1 >/dev/null
-run_plain add 3 "Dev" >/dev/null
-run_plain update 3 in_progress >/dev/null
-TRACKER_QUIET=1 run_plain model 3 opus >/dev/null
-TRACKER_QUIET=1 run_plain tokens 3 100000 20000 >/dev/null
-# opus: 0.1*5 + 0.02*25 = 0.5 + 0.5 = 1.00
-COST3=$(run_plain cost 3)
-[ "$COST3" = "1" ] && pass "cost 3 = 1 (opus 100k in + 20k out)" || fail "expected 1, got $COST3"
-TRACKER_QUIET=1 run_plain tokens 3 0 0 50000 >/dev/null
-# + 50k cached * 0.5/M = 0.025 -> total 1.025 -> floored 1.02
-COST3C=$(run_plain cost 3)
-[ "$COST3C" = "1.02" ] && pass "cached tokens priced at cacheReadPerMtok (1.02)" || fail "expected 1.02, got $COST3C"
-COSTTOT=$(run_plain cost total)
-[ "$COSTTOT" = "1.02" ] && pass "cost total sums priceable phases" || fail "expected 1.02, got $COSTTOT"
-run_plain add 4 "Review" >/dev/null
-TRACKER_QUIET=1 run_plain tokens 4 5000 1000 >/dev/null
-COST4=$(run_plain cost 4)
-[ "$COST4" = "-" ] && pass "cost is '-' for a phase without a model" || fail "expected -, got $COST4"
-COSTBAD=$(run_plain cost 9)
-[ "$COSTBAD" = "-" ] && pass "cost is '-' for unknown phase id" || fail "expected -, got $COSTBAD"
-
-echo ""
-echo "→ 23. render shows per-tile USD and cached footer"
-RENDER_COST=$(run_plain render)
-echo "$RENDER_COST" | grep -q '~\$1.02' && pass "tile shows ~\$ estimate for priced phase" || fail "render missing tile USD"
-echo "$RENDER_COST" | grep -q "cached" && pass "footer shows cached tokens" || fail "render missing cached footer"
-echo "$RENDER_COST" | grep -qE "Total.*~\\\$" && pass "footer shows total USD" || fail "render missing total USD"
-
-echo ""
-echo "→ 24. render sorts phases by numeric id (continuation ordering)"
-run_plain init ORDER-1 >/dev/null
-for pp in "0:Init" "5:Test"; do run_plain add "${pp%%:*}" "${pp#*:}" >/dev/null; done
-for pp in "4:Review" "6:Commit"; do run_plain add "${pp%%:*}" "${pp#*:}" >/dev/null; done
-ORDER_OUT=$(run_plain render | grep -oE "Phase [0-9]+" | tr -d 'Phase ' | tr '\n' ',')
-[ "$ORDER_OUT" = "0,4,5,6," ] && pass "phases render sorted by id (0,4,5,6)" || fail "order wrong: $ORDER_OUT"
-
-echo ""
-echo "══ phase-tracker smoke: $PASS passed, $FAIL failed ══"
-[ "$FAIL" -eq 0 ]

package/pipeline/scripts/smoke-phase0-bridge-contract.sh

@@ -1,241 +0,0 @@
-#!/usr/bin/env bash
-# smoke-phase0-bridge-contract.sh  -  verify the agent-state.json produced by
-# `multi-repo-pipeline.sh bridge` satisfies every field that Phase 0 (and the
-# downstream phases) read from it.
-#
-# Without this gate, a bridge schema bump could leave Phase 0 reading
-# undefined fields silently  -  the picker → Phase 0 handoff is the seam where
-# multi-repo state changes from the picker world to the pipeline runtime.
-#
-# Live multi-repo E2E (real branch, real PR) cannot run in CI, so this
-# contract test is the closest offline equivalent. It covers:
-#   1. Bridge output validates against agent-state.schema.json v2.1.0.
-#   2. Every required Phase 0 field is non-null.
-#   3. projects[] entries are well-formed (length, branch, baseBranch, identity).
-#   4. Single-repo input still produces a one-entry projects[] (or omits it
-#      cleanly, matching phase-0-init.md "Single-repo selection" rule).
-#   5. Round-trip: re-running bridge on the same state.json is idempotent.
-
-set -uo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-LIB_DIR="$REPO_ROOT/pipeline/lib"
-SCHEMA="$REPO_ROOT/pipeline/schemas/agent-state.schema.json"
-
-PASS=0; FAIL=0
-ok()   { echo "  ✓ $1"; PASS=$((PASS+1)); }
-fail() { echo "  ✗ $1" >&2; FAIL=$((FAIL+1)); }
-
-MRP="$LIB_DIR/multi-repo-pipeline.sh"
-[ -x "$MRP" ] || { fail "multi-repo-pipeline.sh not executable"; exit 2; }
-[ -f "$SCHEMA" ] || { fail "agent-state.schema.json missing"; exit 2; }
-
-# Need jsonschema for full validation  -  fall back to shape check if unavailable.
-HAS_JSONSCHEMA=0
-python3 -c "import jsonschema" 2>/dev/null && HAS_JSONSCHEMA=1
-
-TMP=$(mktemp -d)
-trap 'rm -rf "$TMP"; rm -rf $HOME/.claude/logs/multi-agent/repo-multi/CONTRACT-1; rm -rf $HOME/.claude/logs/multi-agent/repo-single/CONTRACT-2' EXIT
-
-# --- Multi-repo case --------------------------------------------------------
-cat > "$TMP/multi.json" <<EOF
-{
-  "taskId":"CONTRACT-1",
-  "shortId":1,
-  "branch":"feature/CONTRACT-1",
-  "baseBranch":"develop",
-  "issueRef":{"kind":"jira","key":"CONTRACT-1","title":"phase-0 contract","owner":null,"repo":null},
-  "primary":{"name":"repo-multi","cloneUrl":"git@example.com:o/repo-multi.git","provider":"github"},
-  "extras":[
-    {"name":"repo-extra","cloneUrl":"git@example.com:o/repo-extra.git","provider":"github"}
-  ],
-  "worktreeRoot":"$TMP/wt",
-  "commitType":"feat",
-  "identity":{"name":"Tester","email":"t@e.com"}
-}
-EOF
-
-bridged=$("$MRP" bridge "$TMP/multi.json" 2>/dev/null || echo "")
-if [ -z "$bridged" ] || [ ! -f "$bridged" ]; then
-  fail "bridge produced no output for multi-repo input"
-  echo "══ aborted ══"; exit 1
-fi
-
-echo "→ 1. Bridge writes agent-state.json at the canonical logs path"
-expected_dir="$HOME/.claude/logs/multi-agent/repo-multi/CONTRACT-1"
-if [ "$(dirname "$bridged")" = "$expected_dir" ]; then
-  ok "writes to ~/.claude/logs/multi-agent/{primary}/{taskId}/agent-state.json"
-else
-  fail "wrong path: got $bridged, expected $expected_dir/agent-state.json"
-fi
-
-echo "→ 2. Bridge output validates against agent-state.schema.json v2.1.0"
-if [ $HAS_JSONSCHEMA -eq 1 ]; then
-  out=$(python3 -c '
-import json, sys
-from jsonschema import Draft202012Validator
-schema = json.load(open(sys.argv[1]))
-data = json.load(open(sys.argv[2]))
-errs = list(Draft202012Validator(schema).iter_errors(data))
-if errs:
-    for e in errs: print("ERR " + "/".join(str(p) for p in e.absolute_path) + ": " + e.message)
-    sys.exit(1)
-print("VALID")
-' "$SCHEMA" "$bridged" 2>&1)
-  if printf '%s' "$out" | grep -q "^VALID"; then
-    ok "schema validates without errors"
-  else
-    fail "schema validation failed: $out"
-  fi
-else
-  echo "  (skipping  -  jsonschema not installed)"
-fi
-
-echo "→ 3. Phase 0 required-field contract"
-phase0_check=$(python3 -c '
-import json, sys
-d = json.load(open(sys.argv[1]))
-need = ["schemaVersion","taskId","shortId","project","projectRoot","worktreePath",
-        "branch","baseBranch","remoteType","currentPhase","status","startedAt",
-        "phases","identity","projects"]
-miss = [k for k in need if d.get(k) in (None, "")]
-if miss:
-    print("MISS:" + ",".join(miss))
-    sys.exit(1)
-# projects[] must be at least 1
-if not isinstance(d["projects"], list) or len(d["projects"]) < 1:
-    print("PROJECTS_BAD")
-    sys.exit(1)
-# Every project must carry the per-repo Phase 0 contract
-for p in d["projects"]:
-    pneed = ["project","projectRoot","branch","baseBranch","identity"]
-    pmiss = [k for k in pneed if not p.get(k)]
-    if pmiss:
-        print("PROJECT_MISS:" + p.get("project","?") + ":" + ",".join(pmiss))
-        sys.exit(1)
-print("OK")
-' "$bridged" 2>&1)
-if [ "$phase0_check" = "OK" ]; then
-  ok "every Phase 0 required field is non-null + projects[] entries well-formed"
-else
-  fail "Phase 0 contract: $phase0_check"
-fi
-
-echo "→ 4. projects[] cardinality matches input (primary + extras)"
-count=$(python3 -c 'import json,sys; print(len(json.load(open(sys.argv[1]))["projects"]))' "$bridged")
-if [ "$count" = "2" ]; then
-  ok "primary + 1 extra → projects[].length = 2"
-else
-  fail "projects[].length $count != 2"
-fi
-
-echo "→ 5. Top-level scalars mirror primary (back-compat)"
-mirror_check=$(python3 -c '
-import json, sys
-d = json.load(open(sys.argv[1]))
-primary = d["projects"][0]
-if d["project"] != primary["project"]: print("PROJECT"); sys.exit(1)
-if d["projectRoot"] != primary["projectRoot"]: print("ROOT"); sys.exit(1)
-if d["branch"] != primary["branch"]: print("BRANCH"); sys.exit(1)
-print("OK")
-' "$bridged" 2>&1)
-if [ "$mirror_check" = "OK" ]; then
-  ok "top-level project/projectRoot/branch mirror projects[0]"
-else
-  fail "scalar mirror broken: $mirror_check"
-fi
-
-echo "→ 6. Identity propagated to every project"
-identity_check=$(python3 -c '
-import json, sys
-d = json.load(open(sys.argv[1]))
-top = d["identity"]
-for p in d["projects"]:
-    if p["identity"] != top:
-        print("DRIFT:" + p["project"]); sys.exit(1)
-print("OK")
-' "$bridged")
-if [ "$identity_check" = "OK" ]; then
-  ok "every project carries the same identity (no drift)"
-else
-  fail "identity drift: $identity_check"
-fi
-
-echo "→ 7. Bridge is idempotent (re-run yields same content)"
-sha1=$(shasum -a 256 "$bridged" | awk '{print $1}')
-"$MRP" bridge "$TMP/multi.json" >/dev/null
-sha2=$(shasum -a 256 "$bridged" | awk '{print $1}')
-# startedAt timestamp will differ between runs (it's `now`), so we mask it
-masked1=$(python3 -c '
-import json, sys
-d = json.load(open(sys.argv[1]))
-d["startedAt"] = "MASKED"
-print(json.dumps(d, sort_keys=True))
-' "$bridged" | shasum -a 256 | awk '{print $1}')
-"$MRP" bridge "$TMP/multi.json" >/dev/null
-masked2=$(python3 -c '
-import json, sys
-d = json.load(open(sys.argv[1]))
-d["startedAt"] = "MASKED"
-print(json.dumps(d, sort_keys=True))
-' "$bridged" | shasum -a 256 | awk '{print $1}')
-if [ "$masked1" = "$masked2" ]; then
-  ok "idempotent (modulo startedAt) on re-run"
-else
-  fail "bridge content drifts between runs"
-fi
-
-# --- Single-repo case -------------------------------------------------------
-cat > "$TMP/single.json" <<EOF
-{
-  "taskId":"CONTRACT-2",
-  "shortId":2,
-  "branch":"feature/CONTRACT-2",
-  "baseBranch":"main",
-  "issueRef":{"kind":"github","key":"99","title":"single","owner":"o","repo":"repo-single"},
-  "primary":{"name":"repo-single","cloneUrl":"git@example.com:o/repo-single.git","provider":"github"},
-  "extras":[],
-  "worktreeRoot":"$TMP/wt-single",
-  "commitType":"fix",
-  "identity":{"name":"Tester","email":"t@e.com"}
-}
-EOF
-
-bridged_single=$("$MRP" bridge "$TMP/single.json" 2>/dev/null)
-[ -f "$bridged_single" ] || { fail "single-repo bridge produced no output"; exit 1; }
-
-echo "→ 8. Single-repo input → projects[].length = 1"
-count_s=$(python3 -c 'import json,sys; print(len(json.load(open(sys.argv[1]))["projects"]))' "$bridged_single")
-if [ "$count_s" = "1" ]; then
-  ok "single-repo bridges into a one-entry projects[]"
-else
-  fail "single projects[].length $count_s != 1"
-fi
-
-echo "→ 9. Single-repo → githubIssue populated, jiraId null"
-gh_check=$(python3 -c '
-import json, sys
-d = json.load(open(sys.argv[1]))
-if d.get("jiraId") is not None: print("JIRA_NOT_NULL"); sys.exit(1)
-ghi = d.get("githubIssue") or {}
-if ghi.get("owner") != "o" or ghi.get("repo") != "repo-single" or ghi.get("number") != 99:
-    print("GH_WRONG:" + str(ghi)); sys.exit(1)
-print("OK")
-' "$bridged_single")
-if [ "$gh_check" = "OK" ]; then
-  ok "GitHub-issue task: githubIssue object populated, jiraId stays null"
-else
-  fail "github issue propagation: $gh_check"
-fi
-
-# --- Summary ----------------------------------------------------------------
-echo ""
-TOTAL=$((PASS+FAIL))
-if [ $FAIL -eq 0 ]; then
-  echo "══ phase0-bridge-contract smoke: $PASS passed, 0 failed ══"
-  exit 0
-else
-  echo "══ phase0-bridge-contract smoke: $PASS passed, $FAIL failed (of $TOTAL) ══" >&2
-  exit 1
-fi

package/pipeline/scripts/smoke-phase4-gates.sh

@@ -1,45 +0,0 @@
-#!/usr/bin/env bash
-# smoke-phase4-gates.sh  -  contract for the two Phase 4 diff-risk consumers:
-#   test-integrity-gate.mjs (A2)  -  test_lines_removed -> blocking finding
-#   review-scope.mjs (A3)         -  trivial diff -> single reviewer, else full
-# Both are pure functions of the diff-risk JSON (fed on stdin). Deterministic,
-# no git, no LLM. Fail-safe: bad input -> integrity emits 0 findings, scope -> full.
-#
-# Exit 0 = all pass, 1 = any failure.
-
-set -uo pipefail
-ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
-INTEG="$ROOT/pipeline/scripts/test-integrity-gate.mjs"
-SCOPE="$ROOT/pipeline/scripts/review-scope.mjs"
-command -v node >/dev/null 2>&1 || { echo "error: node required" >&2; exit 127; }
-[ -f "$INTEG" ] && [ -f "$SCOPE" ] || { echo "FAIL: gate scripts missing" >&2; exit 1; }
-
-PASS=0; FAIL=0
-pass() { PASS=$((PASS+1)); echo "  ✓ $1"; }
-fail() { FAIL=$((FAIL+1)); echo "  ✗ $1"; }
-
-echo "→ A2 test-integrity-gate"
-OUT=$(echo '{"files":[{"file":"FooTests.swift","signals":[{"name":"test_lines_removed","weight":3,"value":9}]},{"file":"Foo.swift","signals":[{"name":"loc_changed"}]}]}' | node "$INTEG")
-echo "$OUT" | grep -q '"count":1' && pass "flags a shrinking test file (count=1)" || fail "did not flag test shrink: $OUT"
-echo "$OUT" | grep -q '"tag":"test_integrity"' && pass "finding tagged test_integrity + blocking" || fail "missing tag/severity"
-echo "$OUT" | grep -q '"severity":"blocking"' && pass "severity blocking" || fail "not blocking"
-OUT2=$(echo '{"files":[{"file":"Foo.swift","signals":[{"name":"loc_changed"}]}]}' | node "$INTEG")
-echo "$OUT2" | grep -q '"count":0' && pass "clean diff -> 0 findings" || fail "false positive on clean diff"
-OUT3=$(echo 'not-json' | node "$INTEG")
-echo "$OUT3" | grep -q '"count":0' && pass "bad input -> fail-open 0 findings" || fail "bad input not handled"
-
-echo "→ A3 review-scope"
-S1=$(echo '{"totals":{"loc_added":5,"loc_removed":3,"max_score":1.2,"files":1},"files":[{"file":"README.md","signals":[{"name":"loc_changed"}]}]}' | node "$SCOPE")
-echo "$S1" | grep -q '"scope":"single"' && pass "trivial diff -> single reviewer" || fail "trivial not single: $S1"
-S2=$(echo '{"totals":{"loc_added":200,"loc_removed":40,"max_score":2,"files":6},"files":[]}' | node "$SCOPE")
-echo "$S2" | grep -q '"scope":"full"' && pass "large churn -> full" || fail "large churn not full: $S2"
-S3=$(echo '{"totals":{"loc_added":5,"loc_removed":1,"max_score":3,"files":1},"files":[{"file":"Auth.swift","signals":[{"name":"security_path","weight":3}]}]}' | node "$SCOPE")
-echo "$S3" | grep -q '"scope":"full"' && pass "high-stakes signal -> full (even if small)" || fail "security not full: $S3"
-S4=$(echo '{"totals":{"loc_added":3,"loc_removed":1,"max_score":3,"files":1},"files":[{"file":"X","signals":[{"name":"test_lines_removed"}]}]}' | node "$SCOPE")
-echo "$S4" | grep -q '"scope":"full"' && pass "test_lines_removed forces full review" || fail "test shrink not full: $S4"
-S5=$(echo 'garbage' | node "$SCOPE")
-echo "$S5" | grep -q '"scope":"full"' && pass "bad input -> fail-safe full" || fail "bad input not fail-safe: $S5"
-
-echo ""
-echo "══ phase4-gates smoke: $PASS passed, $FAIL failed ══"
-[ "$FAIL" -eq 0 ]