@mmerterden/multi-agent-pipeline 8.6.0

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

@@ -0,0 +1,241 @@
+#!/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-triage.sh

@@ -0,0 +1,142 @@
+#!/usr/bin/env bash
+# smoke-phase4-triage.sh — contract check for Phase 4 triage output.
+#
+# Does NOT hit real review agents. Instead:
+#   1. Synthesizes representative triage-output fixtures (valid + each edge case).
+#   2. Validates them against pipeline/schemas/triage-output.schema.json
+#      using a minimal JSON-structure check (zero-dep — same style as
+#      validate-schemas.mjs).
+#   3. Confirms the pipeline's documented edge-case rules hold for:
+#      - no-findings short-circuit (approved: true)
+#      - over-rejection guard threshold (>0.80 rejected)
+#      - schema rejects invented reviewer (e.g. "haiku" — removed in v2.1.0)
+#      - accepted finding without `fix` is rejected (fix is required on accepted)
+
+set -euo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+ROOT="$(cd "$HERE/../.." && pwd)"
+SCHEMA="$ROOT/pipeline/schemas/triage-output.schema.json"
+TMP="$(mktemp -d -t multi-agent-smoke-XXXX)"
+trap 'rm -rf "$TMP"' EXIT
+
+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 node
+need jq
+
+[ -f "$SCHEMA" ] || { echo "error: schema not found at $SCHEMA" >&2; exit 1; }
+
+# Helper: delegate to the real runtime validator so this smoke test exercises
+# the same code path the pipeline uses in production. Exit codes:
+#   0 = valid and clean
+#   1 = structural / field violation
+#   2 = over-rejection guard tripped
+#   3 = contradiction auto-corrected
+check_via_validator() {
+  local file="$1"
+  local expect_exit="$2" # numeric exit code
+  local reason="$3"
+  local actual_exit=0
+  node "$ROOT/pipeline/scripts/validate-triage.mjs" "$file" >/tmp/validator-out 2>/tmp/validator-err || actual_exit=$?
+  if [ "$actual_exit" = "$expect_exit" ]; then
+    pass "$reason (exit=$actual_exit)"
+  else
+    fail "$reason (expected exit=$expect_exit, got $actual_exit; stderr: $(cat /tmp/validator-err))"
+  fi
+}
+
+echo "→ fixture 1: empty findings (short-circuit)"
+cat > "$TMP/empty.json" <<'EOF'
+{"accepted": [], "deferred": [], "rejected": [], "approved": true}
+EOF
+check_via_validator "$TMP/empty.json" 0 "empty triage output is valid (clean)"
+
+echo ""
+echo "→ fixture 2: one accepted blocking finding"
+cat > "$TMP/accepted.json" <<'EOF'
+{
+  "accepted": [
+    {"severity":"blocking","file":"src/auth.ts","line":42,"issue":"SQL injection via untrusted input","fix":"parameterize the query with prepared statement","reviewer":"opus"}
+  ],
+  "deferred": [],
+  "rejected": [],
+  "approved": false
+}
+EOF
+check_via_validator "$TMP/accepted.json" 0 "accepted blocking with fix + reviewer is valid"
+
+echo ""
+echo "→ fixture 3: accepted without fix (must reject — exit 1)"
+cat > "$TMP/no-fix.json" <<'EOF'
+{
+  "accepted": [
+    {"severity":"blocking","file":"src/auth.ts","line":42,"issue":"SQL injection","reviewer":"opus"}
+  ],
+  "deferred": [],
+  "rejected": [],
+  "approved": false
+}
+EOF
+check_via_validator "$TMP/no-fix.json" 1 "accepted without fix triggers exit 1"
+
+echo ""
+echo "→ fixture 4: reviewer=haiku (removed in v2.1.0, must reject — exit 1)"
+cat > "$TMP/haiku.json" <<'EOF'
+{
+  "accepted": [
+    {"severity":"suggestion","file":"x.ts","line":1,"issue":"naming","fix":"rename","reviewer":"haiku"}
+  ],
+  "deferred": [],
+  "rejected": [],
+  "approved": true
+}
+EOF
+check_via_validator "$TMP/haiku.json" 1 "haiku reviewer triggers exit 1"
+
+echo ""
+echo "→ fixture 5: over-rejection guard (5 rejected, 0 others — exit 2)"
+cat > "$TMP/over-reject.json" <<'EOF'
+{
+  "accepted": [],
+  "deferred": [],
+  "rejected": [
+    {"finding":{"severity":"blocking","file":"a.ts","line":1,"issue":"i111"},"reason":"false positive"},
+    {"finding":{"severity":"blocking","file":"b.ts","line":2,"issue":"i222"},"reason":"false positive"},
+    {"finding":{"severity":"important","file":"c.ts","line":3,"issue":"i333"},"reason":"duplicate"},
+    {"finding":{"severity":"blocking","file":"d.ts","line":4,"issue":"i444"},"reason":"style only"},
+    {"finding":{"severity":"suggestion","file":"e.ts","line":5,"issue":"i555"},"reason":"already correct"}
+  ],
+  "approved": true
+}
+EOF
+check_via_validator "$TMP/over-reject.json" 2 "100% rejection triggers over-rejection guard (exit 2)"
+
+echo ""
+echo "→ fixture 6: contradiction (approved=false but no blocker — exit 3 with corrected)"
+cat > "$TMP/contradiction.json" <<'EOF'
+{
+  "accepted": [
+    {"severity":"suggestion","file":"x.ts","line":1,"issue":"name change","fix":"rename to FooBar","reviewer":"opus"}
+  ],
+  "deferred": [],
+  "rejected": [],
+  "approved": false
+}
+EOF
+check_via_validator "$TMP/contradiction.json" 3 "contradiction auto-correct (exit 3)"
+# The validator exits 3 (non-zero) but we still want its stdout.
+CORRECTED_APPROVED=$(node "$ROOT/pipeline/scripts/validate-triage.mjs" "$TMP/contradiction.json" 2>/dev/null || true)
+if echo "$CORRECTED_APPROVED" | jq -e '.corrected.approved == true' >/dev/null 2>&1; then
+  pass "corrected.approved == true"
+else
+  fail "corrected.approved was not true"
+fi
+
+echo ""
+echo "══ phase4-triage smoke: $PASS passed, $FAIL failed ══"
+[ "$FAIL" -eq 0 ]

package/pipeline/scripts/smoke-plan-approval-gate.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+# smoke-plan-approval-gate.sh — contract check for Phase 2 Plan Approval Gate (v5.3.0).
+#
+# Verifies:
+#   1. phase-2-planning.md declares Step 5 as the gate (clarification + approval)
+#   2. Gate is explicitly scoped to non-autopilot, non-dev modes (autopilot + --dev skip)
+#   3. Clarification cap is 2 rounds
+#   4. agent-state schema exposes the six audit fields in phases.*
+#   5. Mode matrix in modes.md, autopilot.md, dev.md, dev-autopilot.md mention the gate
+#   6. SKILL.md autopilot matrix shows "Gate skip"
+
+set -uo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+ROOT="$(cd "$HERE/../.." && pwd)"
+
+PASS=0
+FAIL=0
+pass() { PASS=$((PASS+1)); echo "  ✓ $1"; }
+fail() { FAIL=$((FAIL+1)); echo "  ✗ $1"; }
+
+PHASE2="$ROOT/pipeline/commands/multi-agent/refs/phases/phase-2-planning.md"
+SCHEMA="$ROOT/pipeline/schemas/agent-state.schema.json"
+SKILL="$ROOT/pipeline/skills/shared/core/multi-agent/SKILL.md"
+MODES="$ROOT/pipeline/commands/multi-agent/refs/phases/modes.md"
+AUTOPILOT="$ROOT/pipeline/commands/multi-agent/autopilot.md"
+DEV="$ROOT/pipeline/commands/multi-agent/dev.md"
+DEVAUTO="$ROOT/pipeline/commands/multi-agent/dev-autopilot.md"
+
+echo "→ 1. Phase 2 doc declares the gate + sub-modes"
+grep -q "Plan Approval Gate" "$PHASE2" && pass "phase-2 has 'Plan Approval Gate'" || fail "phase-2 missing gate heading"
+grep -q "Clarification Mode" "$PHASE2" && pass "phase-2 has Clarification Mode (5a)" || fail "phase-2 missing 5a"
+grep -q "Approval Loop" "$PHASE2" && pass "phase-2 has Approval Loop (5b)" || fail "phase-2 missing 5b"
+
+echo ""
+echo "→ 2. Gate is scoped — autopilot + --dev skip"
+grep -q "state.autopilot === true" "$PHASE2" && pass "phase-2 guards against autopilot" || fail "phase-2 missing autopilot guard"
+grep -q "state.onlyDevelop === true" "$PHASE2" && pass "phase-2 guards against --dev" || fail "phase-2 missing --dev guard"
+
+echo ""
+echo "→ 3. Clarification cap = 2 rounds"
+grep -qi "max 2 rounds" "$PHASE2" && pass "phase-2 states 'max 2 rounds'" || fail "phase-2 missing '2 rounds' cap"
+grep -q '"clarificationRounds"' "$SCHEMA" && pass "schema exposes clarificationRounds" || fail "schema missing clarificationRounds"
+grep -A4 '"clarificationRounds"' "$SCHEMA" | grep -q '"maximum": 2' && pass "clarificationRounds max=2" || fail "clarificationRounds schema cap wrong"
+
+echo ""
+echo "→ 4. Schema exposes all six audit fields"
+for field in clarificationRounds clarificationQuestions clarificationAnswers planIterations planApprovedAt planEditRequests; do
+  grep -q "\"$field\"" "$SCHEMA" && pass "schema has $field" || fail "schema missing $field"
+done
+
+echo ""
+echo "→ 5. Mode matrices reference the gate"
+grep -qi "Plan Approval Gate" "$MODES" && pass "modes.md references gate" || fail "modes.md missing gate"
+grep -qi "Gate skip\|Plan Approval Gate" "$AUTOPILOT" && pass "autopilot.md references gate skip" || fail "autopilot.md missing gate mention"
+grep -qi "Plan Approval Gate\|plan gate\|Plan Approval" "$DEV" && pass "dev.md references gate (skipped)" || fail "dev.md missing gate mention"
+grep -qi "Plan Approval Gate" "$DEVAUTO" && pass "dev-autopilot.md references gate (skipped)" || fail "dev-autopilot.md missing gate mention"
+
+echo ""
+echo "→ 6. SKILL.md autopilot matrix shows Gate skip semantics"
+grep -qi "Plan Approval Gate" "$SKILL" && pass "SKILL.md references gate" || fail "SKILL.md missing gate"
+grep -qi "Gate skip" "$SKILL" && pass "SKILL.md autopilot matrix shows 'Gate skip'" || fail "SKILL.md autopilot matrix missing 'Gate skip'"
+
+echo ""
+echo "→ 7. Free-text edit contract (no sentinel required)"
+grep -qi "serbest metin" "$PHASE2" && pass "phase-2 documents free-text edit in TR" || fail "phase-2 missing 'serbest metin'"
+grep -q 'planEditRequests' "$PHASE2" && pass "phase-2 references planEditRequests" || fail "phase-2 missing planEditRequests"
+
+echo ""
+echo "══ plan-approval-gate smoke: $PASS passed, $FAIL failed ══"
+[ "$FAIL" -eq 0 ]

package/pipeline/scripts/smoke-plan-safety.sh

@@ -0,0 +1,139 @@
+#!/usr/bin/env bash
+# smoke-plan-safety.sh — v7.0.G
+#
+# Verifies the Phase 2 autopilot safety classifier:
+#   1. Low-risk plan: score low, recommendPause=false
+#   2. High-risk plan (destructive + security + migration): recommendPause=true
+#   3. File-count thresholds fire: medium (8-15) vs high (>15)
+#   4. Security-path detection on /auth/, /keychain/, /credentials/, etc.
+#   5. delete-without-test rule fires when destructive task has no sibling test
+#   6. Malformed JSON input → exit 1
+#   7. Schema pref exposes autopilotSafetyGate default true
+#
+# Exit 0 all pass, 1 any failure.
+
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
+CLS="$ROOT/pipeline/scripts/classify-plan-safety.mjs"
+SCHEMA="$ROOT/pipeline/schemas/prefs.schema.json"
+
+pass=0; fail=0; failures=()
+record_pass() { pass=$((pass + 1)); printf '  \033[0;32mPASS\033[0m %s\n' "$1"; }
+record_fail() { fail=$((fail + 1)); failures+=("$1"); printf '  \033[0;31mFAIL\033[0m %s\n' "$1"; }
+
+printf '→ smoke-plan-safety (v7.0.G): autopilot safety classifier contract\n'
+
+# --- 1: low-risk ---
+out=$(cat <<'JSON' | node "$CLS" -
+{"tasks":[{"id":"T1","title":"Rename a test helper","type":"test","files":["tests/helpers/fixtures.ts"]}],"approved":true}
+JSON
+)
+if [ "$(jq -r .recommendPause <<< "$out")" = "false" ]; then
+  record_pass "low-risk plan does not recommend pause"
+else
+  record_fail "low-risk plan should not recommend pause (got: $out)"
+fi
+
+# --- 2: high-risk (multi-signal) ---
+out=$(cat <<'JSON' | node "$CLS" -
+{"approach":"Drop auth schema and remove legacy keychain storage","tasks":[
+  {"id":"T1","title":"Drop auth_tokens migration","type":"code","files":["schemas/migrations/008.sql"]},
+  {"id":"T2","title":"Remove KeychainStore","type":"refactor","files":["Sources/Auth/KeychainStore.swift","Sources/Security/TokenManager.swift"]}
+],"approved":true}
+JSON
+)
+if [ "$(jq -r .recommendPause <<< "$out")" = "true" ]; then
+  record_pass "high-risk plan recommends pause"
+else
+  record_fail "high-risk plan should recommend pause (got: $out)"
+fi
+
+# --- 3: file-count thresholds ---
+files_json=$(jq -cn '[range(0;10)] | map("src/m\(.).kt")')
+out=$(cat <<JSON | node "$CLS" -
+{"tasks":[{"id":"T1","title":"touch 10 files","type":"code","files":$files_json}],"approved":true}
+JSON
+)
+rules=$(jq -r '.reasons[].rule' <<< "$out" | tr '\n' ' ')
+if echo "$rules" | grep -q 'file-count-medium'; then
+  record_pass "file-count-medium fires at 10 files"
+else
+  record_fail "file-count-medium should fire at 10 files (got rules: $rules)"
+fi
+
+files_json=$(jq -cn '[range(0;20)] | map("src/m\(.).kt")')
+out=$(cat <<JSON | node "$CLS" -
+{"tasks":[{"id":"T1","title":"touch 20 files","type":"code","files":$files_json}],"approved":true}
+JSON
+)
+rules=$(jq -r '.reasons[].rule' <<< "$out" | tr '\n' ' ')
+if echo "$rules" | grep -q 'file-count-high'; then
+  record_pass "file-count-high fires at 20 files"
+else
+  record_fail "file-count-high should fire at 20 files (got rules: $rules)"
+fi
+
+# --- 4: security-path ---
+out=$(cat <<'JSON' | node "$CLS" -
+{"tasks":[{"id":"T1","title":"add test","type":"test","files":["tests/keychain/helper.ts"]}],"approved":true}
+JSON
+)
+if jq -e '.reasons[] | select(.rule=="security-path")' <<< "$out" >/dev/null; then
+  record_pass "security-path detects /keychain/"
+else
+  record_fail "security-path should detect /keychain/"
+fi
+
+# --- 5: delete-without-test rule ---
+out=$(cat <<'JSON' | node "$CLS" -
+{"tasks":[
+  {"id":"T1","title":"Remove old feature flag handler","type":"refactor","files":["Sources/FeatureFlags/OldHandler.swift"]}
+],"approved":true}
+JSON
+)
+if jq -e '.reasons[] | select(.rule=="delete-without-test")' <<< "$out" >/dev/null; then
+  record_pass "delete-without-test fires when destructive task has no paired test task"
+else
+  record_fail "delete-without-test should fire here"
+fi
+
+# --- delete WITH paired test should NOT fire ---
+out=$(cat <<'JSON' | node "$CLS" -
+{"tasks":[
+  {"id":"T1","title":"Add regression test for old flag removal","type":"test","files":["Sources/FeatureFlags/OldHandlerTests.swift"]},
+  {"id":"T2","title":"Remove old feature flag handler","type":"refactor","files":["Sources/FeatureFlags/OldHandler.swift"]}
+],"approved":true}
+JSON
+)
+if ! jq -e '.reasons[] | select(.rule=="delete-without-test")' <<< "$out" >/dev/null; then
+  record_pass "delete-without-test does NOT fire when paired test exists"
+else
+  record_fail "delete-without-test should NOT fire when paired test exists"
+fi
+
+# --- 6: malformed input ---
+set +e
+echo 'not json' | node "$CLS" - >/dev/null 2>&1
+rc=$?
+set -e
+if [ "$rc" = "1" ]; then
+  record_pass "exit 1 on malformed JSON"
+else
+  record_fail "expected exit 1 on malformed JSON (got $rc)"
+fi
+
+# --- 7: schema pref ---
+if jq -e '.properties.global.properties.autopilotSafetyGate.default == true' "$SCHEMA" >/dev/null 2>&1; then
+  record_pass "prefs schema exposes autopilotSafetyGate with default true"
+else
+  record_fail "prefs schema missing autopilotSafetyGate or wrong default"
+fi
+
+printf '\n══ plan-safety smoke: %d passed, %d failed ══\n' "$pass" "$fail"
+if [ "$fail" -gt 0 ]; then
+  printf '\nFailures:\n'
+  for m in "${failures[@]}"; do printf '  - %s\n' "$m"; done
+  exit 1
+fi
+exit 0