qualia-framework 6.9.2 → 6.22.0

package/tests/project-sync.test.sh

@@ -0,0 +1,175 @@
+#!/bin/bash
+# project-sync.test.sh — bin/project-sync.js (Framework→ERP project-sync payload)
+# Run: bash tests/project-sync.test.sh
+
+PASS=0
+FAIL=0
+BIN_DIR="$(cd "$(dirname "$0")/../bin" && pwd)"
+NODE="${NODE:-node}"
+PS="$BIN_DIR/project-sync.js"
+
+assert_exit() {
+  local name="$1" expected="$2" actual="$3"
+  if [ "$expected" = "$actual" ]; then echo "  ✓ $name"; PASS=$((PASS+1));
+  else echo "  ✗ $name (expected exit $expected, got $actual)"; FAIL=$((FAIL+1)); fi
+}
+assert_contains() {
+  local name="$1" hay="$2" needle="$3"
+  if echo "$hay" | grep -qF "$needle"; then echo "  ✓ $name"; PASS=$((PASS+1));
+  else echo "  ✗ $name (missing '$needle' in output)"; FAIL=$((FAIL+1)); fi
+}
+assert_not_contains() {
+  local name="$1" hay="$2" needle="$3"
+  if echo "$hay" | grep -qF "$needle"; then echo "  ✗ $name (unexpected '$needle')"; FAIL=$((FAIL+1));
+  else echo "  ✓ $name"; PASS=$((PASS+1)); fi
+}
+
+# A fully-populated .planning fixture: milestones, REQ-IDs, offroad, lifetime.
+setup_full() {
+  local tmp
+  tmp=$(mktemp -d)
+  mkdir -p "$tmp/.planning"
+  cat > "$tmp/.planning/tracking.json" <<'EOF'
+{
+  "project": "acme-portal",
+  "project_id": "qs-acme-portal",
+  "client": "Acme",
+  "milestone": 2,
+  "milestone_name": "Product",
+  "milestones": [
+    { "num": 1, "name": "Foundation", "closed_at": "2026-04-10T18:00:00Z", "phases_completed": 3, "tasks_completed": 12, "deployed_url": "https://m1.vercel.app" }
+  ],
+  "phase": 2,
+  "phase_name": "Dashboard",
+  "total_phases": 4,
+  "status": "built",
+  "tasks_done": 3,
+  "tasks_total": 5,
+  "verification": "pending",
+  "gap_cycles": { "2": 1 },
+  "build_count": 4,
+  "deploy_count": 1,
+  "deployed_url": "https://client.vercel.app",
+  "lifecycle": "build",
+  "lifetime": { "tasks_completed": 15, "phases_completed": 4, "milestones_completed": 1, "total_phases": 7, "offroad_count": 2 },
+  "offroad": [
+    { "at": "2026-06-01T10:00:00Z", "milestone": 2, "ref": "BUG-7", "note": "hotfix login" },
+    { "at": "2026-06-02T10:00:00Z", "milestone": 2, "ref": null, "note": "tweak" }
+  ]
+}
+EOF
+  cat > "$tmp/.planning/JOURNEY.md" <<'EOF'
+## Milestone 1 · Foundation
+## Milestone 2 · Product [CURRENT]
+## Milestone 3 · Handoff [FINAL]
+EOF
+  cat > "$tmp/.planning/REQUIREMENTS.md" <<'EOF'
+| ID | Milestone | Phase | Status |
+|----|-----------|-------|--------|
+| CORE-01 | M1: Foundation | Phase 1 | Complete |
+| CORE-02 | M2: Product | Phase 2 | Complete |
+| CORE-03 | M2: Product | Phase 3 | Incomplete |
+EOF
+  echo "$tmp"
+}
+
+echo "project-sync.test.sh — bin/project-sync.js"
+echo ""
+
+# --- syntax ---
+$NODE -c "$PS" 2>/dev/null && { echo "  ✓ syntax valid"; PASS=$((PASS+1)); } || { echo "  ✗ syntax invalid"; FAIL=$((FAIL+1)); }
+
+NOW="2026-06-21T00:00:00.000Z"
+
+# --- no .planning → exit 2 ---
+TMP=$(mktemp -d)
+(cd "$TMP" && $NODE "$PS" >/dev/null 2>&1)
+assert_exit "no .planning → exit 2" 2 $?
+rm -rf "$TMP"
+
+# --- full fixture → exit 0 + valid JSON ---
+TMP=$(setup_full)
+OUT=$($NODE "$PS" --cwd "$TMP" --json --now "$NOW" 2>&1)
+(cd "$TMP" && $NODE "$PS" --json --now "$NOW" >/dev/null 2>&1)
+assert_exit "full fixture → exit 0" 0 $?
+echo "$OUT" | $NODE -e "let s='';process.stdin.on('data',d=>s+=d).on('end',()=>{JSON.parse(s);process.exit(0)})" 2>/dev/null \
+  && { echo "  ✓ --json emits valid JSON"; PASS=$((PASS+1)); } \
+  || { echo "  ✗ --json invalid JSON"; FAIL=$((FAIL+1)); }
+
+# --- schema_version + payload marker ---
+assert_contains "carries schema_version" "$OUT" '"schema_version": 1'
+assert_contains "payload marker is project-sync" "$OUT" '"payload": "project-sync"'
+
+# --- lifecycle + launched_at handling ---
+assert_contains "lifecycle present (build)" "$OUT" '"lifecycle": "build"'
+
+# --- milestones[] with status + REQ completion ---
+assert_contains "milestone 1 closed" "$OUT" '"status": "closed"'
+assert_contains "milestone 2 current" "$OUT" '"status": "current"'
+assert_contains "milestone 3 future" "$OUT" '"status": "future"'
+assert_contains "closed milestone phases count" "$OUT" '"phases": 3'
+assert_contains "closed milestone tasks_completed" "$OUT" '"tasks_completed": 12'
+assert_contains "REQ total tracked for M2" "$OUT" '"total": 2'
+assert_contains "REQ complete count" "$OUT" '"complete": 1'
+assert_contains "incomplete REQ id surfaced" "$OUT" '"id": "CORE-03"'
+assert_contains "future milestone REQ untracked" "$OUT" '"tracked": false'
+assert_contains "per-milestone deployed_url" "$OUT" '"deployed_url": "https://m1.vercel.app"'
+assert_contains "total_milestones from journey" "$OUT" '"total_milestones": 3'
+
+# --- current position ---
+assert_contains "current phase" "$OUT" '"phase": 2'
+assert_contains "current verification" "$OUT" '"verification": "pending"'
+
+# --- task rollup ---
+assert_contains "rollup tasks_completed" "$OUT" '"tasks_completed": 15'
+assert_contains "rollup build_count" "$OUT" '"build_count": 4'
+assert_contains "rollup deploy_count" "$OUT" '"deploy_count": 1'
+assert_contains "rollup gap_cycles (flattened to number)" "$OUT" '"current_phase_gap_cycles": 1'
+
+# --- accountability / offroad ---
+assert_contains "offroad_count" "$OUT" '"offroad_count": 2'
+assert_contains "recent offroad entry" "$OUT" '"ref": "BUG-7"'
+
+# --- integration / merge model ---
+assert_contains "trunk integration model" "$OUT" '"model": "trunk"'
+assert_contains "integrates at ship" "$OUT" '"integrates_at": "/qualia-ship"'
+assert_contains "main-push event type" "$OUT" '"main_push_event_type": "employee_main_push"'
+
+rm -rf "$TMP"
+
+# --- graceful when fields absent: minimal tracking.json, no JOURNEY/REQUIREMENTS ---
+TMP=$(mktemp -d)
+mkdir -p "$TMP/.planning"
+echo '{ "project": "bare", "milestone": 1, "phase": 1 }' > "$TMP/.planning/tracking.json"
+OUT=$($NODE "$PS" --cwd "$TMP" --json --now "$NOW" 2>&1)
+(cd "$TMP" && $NODE "$PS" --json --now "$NOW" >/dev/null 2>&1)
+assert_exit "bare fixture → exit 0" 0 $?
+assert_contains "bare still has schema_version" "$OUT" '"schema_version": 1'
+assert_contains "bare offroad_count defaults to 0" "$OUT" '"offroad_count": 0'
+assert_contains "bare emits a current milestone" "$OUT" '"status": "current"'
+assert_contains "bare REQ untracked (no REQUIREMENTS.md)" "$OUT" '"tracked": false'
+rm -rf "$TMP"
+
+# --- library: buildProjectSync() returns the object ---
+TMP=$(setup_full)
+RES=$($NODE -e "const {buildProjectSync}=require('$PS');const o=buildProjectSync({cwd:'$TMP',now:'$NOW'});console.log(o.schema_version, o.milestones.length, o.milestones[1].requirements.incomplete[0].id)" 2>&1)
+assert_contains "buildProjectSync() returns enriched object" "$RES" "1 3 CORE-03"
+rm -rf "$TMP"
+
+# --- library: milestoneRequirements() parses a fixture dir ---
+TMP=$(setup_full)
+RES=$($NODE -e "const {milestoneRequirements}=require('$PS');const r=milestoneRequirements('$TMP/.planning',2);console.log(r.tracked, r.total, r.complete, r.incomplete.length)" 2>&1)
+assert_contains "milestoneRequirements() counts REQ completion" "$RES" "true 2 1 1"
+rm -rf "$TMP"
+
+# --- --write persists a snapshot file ---
+TMP=$(setup_full)
+FILE=$($NODE "$PS" --cwd "$TMP" --write --now "$NOW" 2>&1)
+if [ -f "$FILE" ]; then echo "  ✓ --write persists a file"; PASS=$((PASS+1));
+else echo "  ✗ --write did not persist ($FILE)"; FAIL=$((FAIL+1)); fi
+assert_contains "written file is project-sync-*" "$FILE" "project-sync-"
+rm -rf "$TMP"
+
+echo ""
+echo "=== Results: $PASS passed, $FAIL failed ==="
+[ "$FAIL" -eq 0 ] && exit 0 || exit 1

package/tests/run-all.sh

@@ -18,6 +18,15 @@ SUITES=(
   "refs"
   "install-smoke"
   "slop-detect"
+  "agent-status"
+  "analyze-gate"
+  "instructions"
+  "verify-panel"
+  "wave-plan"
+  "eval-runner"
+  "branch-hygiene"
+  "last-report"
+  "project-sync"
 )
 
 FAILED=()

package/tests/runner.js

@@ -2578,14 +2578,15 @@ describe("install.js", () => {
     }
   });
 
-  it("13 hooks installed (v6.3.2: pre-compact reintroduced with sidecar-snapshot mechanism)", () => {
+  it("15 hooks installed (v6.13: task-write-guard added — R1 plan-contract file-scope guard)", () => {
     const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "qualia-install-"));
     try {
       runInstall("QS-FAWZI-11", tmpHome);
       const hooks = fs.readdirSync(path.join(tmpHome, ".claude", "hooks")).filter(f => f.endsWith(".js"));
-      assert.equal(hooks.length, 13, `expected 13 hooks, got ${hooks.length}: ${hooks.join(", ")}`);
+      assert.equal(hooks.length, 15, `expected 15 hooks, got ${hooks.length}: ${hooks.join(", ")}`);
       assert.ok(hooks.includes("fawzi-approval-guard.js"), "fawzi-approval-guard.js must be installed");
       assert.ok(hooks.includes("pre-compact.js"), "pre-compact.js must be installed (v6.3.2 sidecar-snapshot mechanism)");
+      assert.ok(hooks.includes("task-write-guard.js"), "task-write-guard.js must be installed (v6.13 R1 guard)");
     } finally {
       fs.rmSync(tmpHome, { recursive: true, force: true });
     }

package/tests/state.test.sh

@@ -104,6 +104,12 @@ Goal: Test goal
 ## Success Criteria
 - [ ] Test passes
 PLAN
+  # v7 kernel: `planned` now requires a machine contract and `verified(pass)`
+  # requires passing machine evidence. Emit both so happy-path setups satisfy the
+  # preconditions; the few cases that exercise their ABSENCE delete them explicitly.
+  make_valid_contract "$dir" "$phase"
+  mkdir -p "$dir/.planning/evidence"
+  printf '{"ok":true,"checks":[]}\n' > "$dir/.planning/evidence/phase-${phase}-contract-run.json"
 }
 
 make_valid_contract() {
@@ -289,6 +295,9 @@ fi
 TMP=$(make_project)
 make_valid_plan "$TMP" 1
 make_valid_contract "$TMP" 1
+# This case asserts the missing-evidence guard, so strip the evidence that
+# make_valid_plan now writes by default.
+rm -f "$TMP/.planning/evidence/phase-1-contract-run.json"
 (cd "$TMP" && $NODE "$STATE_JS" transition --to planned >/dev/null 2>&1)
 (cd "$TMP" && $NODE "$STATE_JS" transition --to built --tasks-done 1 --tasks-total 1 >/dev/null 2>&1)
 echo "result: PASS" > "$TMP/.planning/phase-1-verification.md"
@@ -735,6 +744,9 @@ else
   fail_case "validate well-formed plan" "exit=$EXIT out=$OUT"
 fi
 
+# This case asserts the missing-contract path, so strip the contract that
+# make_valid_plan now writes by default.
+rm -f "$TMP/.planning/phase-1-contract.json"
 OUT=$(cd "$TMP" && $NODE "$STATE_JS" validate-plan --phase 1 --require-contract 2>&1)
 EXIT=$?
 if [ "$EXIT" -eq 1 ] \
@@ -946,6 +958,25 @@ else
   fail_case "note without tasks-done"
 fi
 
+# 43b. --scope off tallies offroad_count + ledgers the entry (anti-drift)
+TMP=$(make_project)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to note --notes "ad-hoc widget" --tasks-done 1 --scope off --ref "client asked mid-sprint" >/dev/null 2>&1)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to note --notes "another off-road" --scope off --ref "x" >/dev/null 2>&1)
+if grep -q '"offroad_count": 2' "$TMP/.planning/tracking.json" && grep -q "client asked mid-sprint" "$TMP/.planning/tracking.json"; then
+  pass "--scope off increments offroad_count + records the entry"
+else
+  fail_case "scope off tally" "$(grep -o '"offroad_count": [0-9]*' "$TMP/.planning/tracking.json")"
+fi
+
+# 43c. --scope in does NOT increment offroad_count
+TMP=$(make_project)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to note --notes "in-scope work" --tasks-done 1 --scope in --ref "CORE-01" >/dev/null 2>&1)
+if grep -q '"offroad_count": 0' "$TMP/.planning/tracking.json"; then
+  pass "--scope in leaves offroad_count at 0"
+else
+  fail_case "scope in offroad" "$(grep -o '"offroad_count": [0-9]*' "$TMP/.planning/tracking.json")"
+fi
+
 # ─── Close milestone ─────────────────────────────────────
 echo ""
 echo "close-milestone:"
@@ -1094,6 +1125,79 @@ else
   fail_case "backfill-milestones placeholder repair" "got=$RESULT expected='1|Foundation Arc|7|Core Features'"
 fi
 
+# ─── reqs-check (milestone REQ-ID coverage gate) ─────────
+echo ""
+echo "reqs-check:"
+
+# helper: write a REQUIREMENTS.md traceability table into a project
+write_reqs() {
+  mkdir -p "$1/.planning"
+  cat > "$1/.planning/REQUIREMENTS.md" <<EOF
+## Traceability
+| Requirement | Milestone | Phase | Status |
+|---|---|---|---|
+$2
+EOF
+}
+
+# all complete for M1 → ok, exit 0
+TMP=$(make_project)
+write_reqs "$TMP" "| CORE-01 | M1: Foundation | Phase 1 | Complete |
+| CORE-02 | M1: Foundation | Phase 2 | Complete |"
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" reqs-check --milestone 1 2>&1); EXIT=$?
+if [ "$EXIT" -eq 0 ] && echo "$OUT" | grep -q '"ok": true' && echo "$OUT" | grep -q '"complete": 2'; then
+  pass "reqs-check all complete → ok (exit 0)"
+else
+  fail_case "reqs-check all complete" "exit=$EXIT out=$OUT"
+fi
+
+# an incomplete REQ → not ok, exit 1, lists it
+TMP=$(make_project)
+write_reqs "$TMP" "| CORE-01 | M1: Foundation | Phase 1 | Complete |
+| CORE-02 | M1: Foundation | Phase 2 | Pending |"
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" reqs-check --milestone 1 2>&1); EXIT=$?
+if [ "$EXIT" -eq 1 ] && echo "$OUT" | grep -q '"ok": false' && echo "$OUT" | grep -q 'CORE-02'; then
+  pass "reqs-check incomplete → not ok (exit 1) + lists REQ"
+else
+  fail_case "reqs-check incomplete" "exit=$EXIT out=$OUT"
+fi
+
+# milestone filter: M2's pending REQ doesn't fail an M1 check
+TMP=$(make_project)
+write_reqs "$TMP" "| CORE-01 | M1: Foundation | Phase 1 | Complete |
+| ADMIN-01 | M2: Admin | Phase 1 | Pending |"
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" reqs-check --milestone 1 2>&1); EXIT=$?
+if [ "$EXIT" -eq 0 ] && echo "$OUT" | grep -q '"total": 1'; then
+  pass "reqs-check filters by milestone (M2 pending ignored for M1)"
+else
+  fail_case "reqs-check milestone filter" "exit=$EXIT out=$OUT"
+fi
+
+# no REQUIREMENTS.md → untracked → ok (can't gate what isn't declared)
+TMP=$(make_project)
+rm -f "$TMP/.planning/REQUIREMENTS.md"
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" reqs-check --milestone 1 2>&1); EXIT=$?
+if [ "$EXIT" -eq 0 ] && echo "$OUT" | grep -q '"tracked": false'; then
+  pass "reqs-check untracked (no REQUIREMENTS.md) → ok"
+else
+  fail_case "reqs-check untracked" "exit=$EXIT out=$OUT"
+fi
+
+# close-milestone (strict, no --force) blocks when REQs incomplete.
+# make_project leaves phases unverified, so we --force past the phase gate is NOT
+# what we want here; instead assert the gate code path via a forced close still
+# succeeding (force bypasses both gates) — and the non-forced REQ block is proven
+# by reqs-check above sharing the same readMilestoneRequirements parser.
+TMP=$(make_project)
+write_reqs "$TMP" "| CORE-01 | M1: Foundation | Phase 1 | Pending |
+| CORE-02 | M1: Foundation | Phase 2 | Pending |"
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" close-milestone --force 2>&1); EXIT=$?
+if [ "$EXIT" -eq 0 ] && echo "$OUT" | grep -q '"action": "close-milestone"'; then
+  pass "close-milestone --force bypasses REQ gate (retroactive bookkeeping)"
+else
+  fail_case "close-milestone force bypass" "exit=$EXIT out=$OUT"
+fi
+
 # ─── Backward compatibility ──────────────────────────────
 echo ""
 echo "backward compatibility:"
@@ -1417,6 +1521,89 @@ else
   fail_case "id traversal guard" "out=$TRAV"
 fi
 
+# ─── v7 lifecycle (build → operate) ──────────────────────
+echo ""
+echo "lifecycle (build/operate):"
+
+# Helper: drive a fresh single-phase project to verified(pass).
+make_verified() {
+  local dir="$1"
+  make_valid_plan "$dir" 1
+  (cd "$dir" && $NODE "$STATE_JS" transition --to planned >/dev/null 2>&1)
+  (cd "$dir" && $NODE "$STATE_JS" transition --to built --tasks-done 1 --tasks-total 1 >/dev/null 2>&1)
+  echo "result: PASS" > "$dir/.planning/phase-1-verification.md"
+}
+
+# 1. A new project defaults to lifecycle=build
+TMP=$(_mktemp_native); TMP_DIRS+=("$TMP")
+(cd "$TMP" && git init -q 2>/dev/null; $NODE "$STATE_JS" init --project acme --total-phases 1 --phases '[{"name":"Core","goal":"x"}]' --force >/dev/null 2>&1)
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" check 2>&1)
+if echo "$OUT" | grep -q '"lifecycle": "build"'; then
+  pass "init defaults to lifecycle=build"
+else
+  fail_case "init lifecycle default" "out=$OUT"
+fi
+
+# 2. launch flips to operate, stamps launched_at + source, routes to /qualia-update
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" launch --deployed-url https://acme.app --source erp 2>&1)
+if echo "$OUT" | grep -q '"lifecycle": "operate"' \
+   && echo "$OUT" | grep -q '"launch_source": "erp"' \
+   && echo "$OUT" | grep -q '"next_command": "/qualia-update"' \
+   && echo "$OUT" | grep -q '"launched_at"'; then
+  pass "launch → operate (stamped, routes to /qualia-update)"
+else
+  fail_case "launch to operate" "out=$OUT"
+fi
+
+# 3. launch is idempotent
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" launch 2>&1)
+if echo "$OUT" | grep -q '"already_launched": true'; then
+  pass "launch is idempotent (already_launched)"
+else
+  fail_case "launch idempotent" "out=$OUT"
+fi
+
+# 4. operate: verified(pass) on the last phase routes to /qualia-update + bumps updates_completed
+TMP=$(_mktemp_native); TMP_DIRS+=("$TMP")
+(cd "$TMP" && git init -q 2>/dev/null; $NODE "$STATE_JS" init --project beta --total-phases 1 --phases '[{"name":"Core","goal":"x"}]' --force >/dev/null 2>&1)
+(cd "$TMP" && $NODE "$STATE_JS" launch >/dev/null 2>&1)
+make_verified "$TMP"
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" transition --to verified --verification pass 2>&1)
+if echo "$OUT" | grep -q '"next_command": "/qualia-update"'; then
+  pass "operate verified(pass) → /qualia-update"
+else
+  fail_case "operate verified routing" "out=$OUT"
+fi
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" check 2>&1)
+if echo "$OUT" | grep -q '"updates_completed": 1'; then
+  pass "operate verified(pass) bumps lifetime.updates_completed"
+else
+  fail_case "updates_completed bump" "out=$OUT"
+fi
+
+# 5. BUILD mode still REQUIRES HANDOFF.md (regression: forced handoff intact in build)
+TMP=$(_mktemp_native); TMP_DIRS+=("$TMP")
+(cd "$TMP" && git init -q 2>/dev/null; $NODE "$STATE_JS" init --project gamma --total-phases 1 --phases '[{"name":"Core","goal":"x"}]' --force >/dev/null 2>&1)
+make_verified "$TMP"
+(cd "$TMP" && $NODE "$STATE_JS" transition --to verified --verification pass >/dev/null 2>&1)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to polished >/dev/null 2>&1)
+(cd "$TMP" && $NODE "$STATE_JS" transition --to shipped --deployed-url https://x.app >/dev/null 2>&1)
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" transition --to handed_off 2>&1)
+if echo "$OUT" | grep -q '"error": "MISSING_FILE"'; then
+  pass "build mode → handed_off still requires HANDOFF.md"
+else
+  fail_case "build handoff still gated" "out=$OUT"
+fi
+
+# 6. OPERATE mode: handed_off allowed WITHOUT HANDOFF.md (forced handoff removed)
+(cd "$TMP" && $NODE "$STATE_JS" launch >/dev/null 2>&1)   # same project → flip to operate
+OUT=$(cd "$TMP" && $NODE "$STATE_JS" transition --to handed_off 2>&1)
+if echo "$OUT" | grep -q '"status": "handed_off"' && echo "$OUT" | grep -q '"ok": true'; then
+  pass "operate mode → handed_off allowed without HANDOFF.md"
+else
+  fail_case "operate handoff ungated" "out=$OUT"
+fi
+
 # ─── Summary ─────────────────────────────────────────────
 echo ""
 echo "=== Results: $PASS passed, $FAIL failed ==="

package/tests/verify-panel.test.sh

@@ -0,0 +1,162 @@
+#!/bin/bash
+# verify-panel.test.sh — bin/verify-panel.js (panel + skeptic aggregator, R8)
+# Run: bash tests/verify-panel.test.sh
+
+PASS=0
+FAIL=0
+BIN_DIR="$(cd "$(dirname "$0")/../bin" && pwd)"
+NODE="${NODE:-node}"
+VP="$BIN_DIR/verify-panel.js"
+
+assert_exit() {
+  local name="$1" expected="$2" actual="$3"
+  if [ "$expected" = "$actual" ]; then echo "  ✓ $name"; PASS=$((PASS+1));
+  else echo "  ✗ $name (expected exit $expected, got $actual)"; FAIL=$((FAIL+1)); fi
+}
+assert_contains() {
+  local name="$1" hay="$2" needle="$3"
+  if echo "$hay" | grep -qF "$needle"; then echo "  ✓ $name"; PASS=$((PASS+1));
+  else echo "  ✗ $name (missing '$needle' in: $hay)"; FAIL=$((FAIL+1)); fi
+}
+assert_eq() {
+  local name="$1" expected="$2" actual="$3"
+  if [ "$expected" = "$actual" ]; then echo "  ✓ $name"; PASS=$((PASS+1));
+  else echo "  ✗ $name (expected '$expected', got '$actual')"; FAIL=$((FAIL+1)); fi
+}
+
+echo "verify-panel.test.sh — bin/verify-panel.js"
+echo ""
+
+$NODE -c "$VP" 2>/dev/null && { echo "  ✓ syntax valid"; PASS=$((PASS+1)); } || { echo "  ✗ syntax invalid"; FAIL=$((FAIL+1)); }
+
+# --- clean panel: no findings → PASS, score 5 ---
+TMP=$(mktemp -d)
+cat > "$TMP/panel.json" <<'EOF'
+{ "phase": 1, "lenses": ["correctness","security"], "findings": [] }
+EOF
+$NODE "$VP" "$TMP/panel.json" >/dev/null 2>&1
+assert_exit "empty panel → PASS (exit 0)" 0 $?
+OUT=$($NODE "$VP" "$TMP/panel.json" --json 2>&1)
+assert_contains "verdict PASS" "$OUT" '"verdict": "PASS"'
+assert_contains "score 5" "$OUT" '"score": 5'
+rm -rf "$TMP"
+
+# --- a surviving CRITICAL fails the phase ---
+TMP=$(mktemp -d)
+cat > "$TMP/panel.json" <<'EOF'
+{ "phase": 2, "lenses": ["security"], "findings": [
+  { "lens":"security", "file":"lib/auth.ts", "line":42, "severity":"CRITICAL", "title":"service_role reachable client-side", "votes": {"real":3,"notReal":0} }
+] }
+EOF
+$NODE "$VP" "$TMP/panel.json" >/dev/null 2>&1
+assert_exit "surviving CRITICAL → FAIL (exit 1)" 1 $?
+OUT=$($NODE "$VP" "$TMP/panel.json" --json 2>&1)
+assert_contains "verdict FAIL" "$OUT" '"verdict": "FAIL"'
+rm -rf "$TMP"
+
+# --- skeptics kill a finding by majority not-real → back to PASS ---
+TMP=$(mktemp -d)
+cat > "$TMP/panel.json" <<'EOF'
+{ "phase": 2, "lenses": ["security"], "findings": [
+  { "lens":"security", "file":"lib/auth.ts", "line":42, "severity":"CRITICAL", "title":"false alarm", "votes": {"real":1,"notReal":2} }
+] }
+EOF
+$NODE "$VP" "$TMP/panel.json" >/dev/null 2>&1
+assert_exit "skeptic-killed CRITICAL → PASS (exit 0)" 0 $?
+OUT=$($NODE "$VP" "$TMP/panel.json" --json 2>&1)
+assert_contains "finding moved to killed" "$OUT" '"killed"'
+assert_contains "1 killed total" "$OUT" '"killed": 1'
+rm -rf "$TMP"
+
+# --- tie vote survives (conservative: killed only on strict majority not-real) ---
+TMP=$(mktemp -d)
+cat > "$TMP/panel.json" <<'EOF'
+{ "phase": 3, "lenses": ["correctness"], "findings": [
+  { "lens":"correctness", "file":"a.ts", "line":1, "severity":"HIGH", "title":"tie", "votes": {"real":2,"notReal":2} }
+] }
+EOF
+$NODE "$VP" "$TMP/panel.json" >/dev/null 2>&1
+assert_exit "tie vote → finding survives → FAIL" 1 $?
+rm -rf "$TMP"
+
+# --- no votes → survives (unverified != disproven) ---
+TMP=$(mktemp -d)
+cat > "$TMP/panel.json" <<'EOF'
+{ "phase": 3, "lenses": ["correctness"], "findings": [
+  { "lens":"correctness", "file":"a.ts", "line":1, "severity":"HIGH", "title":"unvoted" }
+] }
+EOF
+$NODE "$VP" "$TMP/panel.json" >/dev/null 2>&1
+assert_exit "no-vote HIGH survives → FAIL" 1 $?
+rm -rf "$TMP"
+
+# --- dedupe: same file:line:title from two lenses merges, votes sum, severity max ---
+DEDUP=$($NODE -e '
+const vp=require("'"$VP"'");
+const d=vp.dedupeFindings([
+  {lens:"correctness",file:"x.ts",line:5,severity:"MEDIUM",title:"Race condition here",votes:{real:1,notReal:0}},
+  {lens:"security",file:"x.ts",line:5,severity:"HIGH",title:"Race condition here",votes:{real:1,notReal:1}}
+]);
+console.log(JSON.stringify({n:d.length,sev:d[0].severity,lenses:d[0].lenses,real:d[0].votes.real,notReal:d[0].votes.notReal}));
+' 2>&1)
+assert_contains "dedupe merges to one finding" "$DEDUP" '"n":1'
+assert_contains "dedupe keeps highest severity" "$DEDUP" '"sev":"HIGH"'
+assert_contains "dedupe unions lenses" "$DEDUP" 'correctness'
+assert_contains "dedupe sums real votes" "$DEDUP" '"real":2'
+
+# --- scoreFromCounts matches the grounding.md formula ---
+assert_eq "score 0/0/0/0 = 5" "5" "$($NODE -e "console.log(require('$VP').scoreFromCounts({CRITICAL:0,HIGH:0,MEDIUM:0,LOW:0}))")"
+assert_eq "score 0/2/0/0 = 4" "4" "$($NODE -e "console.log(require('$VP').scoreFromCounts({CRITICAL:0,HIGH:2,MEDIUM:0,LOW:0}))")"
+assert_eq "score 4/0/0/0 = 1" "1" "$($NODE -e "console.log(require('$VP').scoreFromCounts({CRITICAL:4,HIGH:0,MEDIUM:0,LOW:0}))")"
+assert_eq "score 1/2/0/0 = 3" "3" "$($NODE -e "console.log(require('$VP').scoreFromCounts({CRITICAL:1,HIGH:2,MEDIUM:0,LOW:0}))")"
+
+# --- MEDIUM/LOW only → still PASS (severity gate is C/H) ---
+TMP=$(mktemp -d)
+cat > "$TMP/panel.json" <<'EOF'
+{ "phase": 4, "lenses": ["design"], "findings": [
+  { "lens":"design", "file":"a.css", "line":3, "severity":"MEDIUM", "title":"missing empty state", "votes":{"real":2,"notReal":0} },
+  { "lens":"design", "file":"b.css", "line":9, "severity":"LOW", "title":"console.log", "votes":{"real":2,"notReal":0} }
+] }
+EOF
+$NODE "$VP" "$TMP/panel.json" >/dev/null 2>&1
+assert_exit "MEDIUM+LOW only → PASS (exit 0)" 0 $?
+rm -rf "$TMP"
+
+# --- --write emits panel artifacts ---
+TMP=$(mktemp -d); mkdir -p "$TMP/.planning"
+cat > "$TMP/panel.json" <<'EOF'
+{ "phase": 7, "lenses": ["security"], "findings": [
+  { "lens":"security", "file":"s.ts", "line":1, "severity":"CRITICAL", "title":"leak", "votes":{"real":2,"notReal":0} }
+] }
+EOF
+(cd "$TMP" && $NODE "$VP" panel.json --write >/dev/null 2>&1)
+[ -f "$TMP/.planning/phase-7-verification-panel.json" ] && { echo "  ✓ writes panel json artifact"; PASS=$((PASS+1)); } || { echo "  ✗ no panel json artifact"; FAIL=$((FAIL+1)); }
+[ -f "$TMP/.planning/phase-7-verification-panel.md" ] && { echo "  ✓ writes panel md artifact"; PASS=$((PASS+1)); } || { echo "  ✗ no panel md artifact"; FAIL=$((FAIL+1)); }
+rm -rf "$TMP"
+
+# --- assemble: merge per-lens finding files into one panel.json ---
+TMP=$(mktemp -d); mkdir -p "$TMP/.planning"
+cat > "$TMP/.planning/phase-5-panel-security.json" <<'EOF'
+[{"file":"auth.ts","line":1,"severity":"CRITICAL","title":"leak"}]
+EOF
+cat > "$TMP/.planning/phase-5-panel-correctness.json" <<'EOF'
+[{"file":"util.ts","line":9,"severity":"MEDIUM","title":"off by one"}]
+EOF
+(cd "$TMP" && $NODE "$VP" assemble 5 >/dev/null 2>&1)
+assert_exit "assemble exits 0" 0 $?
+ASM=$(cat "$TMP/.planning/phase-5-panel.json")
+assert_contains "assemble tags security lens" "$ASM" '"lens": "security"'
+assert_contains "assemble tags correctness lens" "$ASM" '"lens": "correctness"'
+assert_contains "assemble zeroes votes" "$ASM" '"real": 0'
+# round-trip: assembled panel aggregates to FAIL (the CRITICAL survives, unvoted)
+(cd "$TMP" && $NODE "$VP" .planning/phase-5-panel.json >/dev/null 2>&1)
+assert_exit "assembled panel aggregates (CRITICAL → FAIL)" 1 $?
+rm -rf "$TMP"
+
+# --- malformed input → exit 2 ---
+$NODE "$VP" /nonexistent/panel.json >/dev/null 2>&1
+assert_exit "missing panel file → exit 2" 2 $?
+
+echo ""
+echo "=== Results: $PASS passed, $FAIL failed ==="
+[ "$FAIL" -eq 0 ] && exit 0 || exit 1