@mmerterden/multi-agent-pipeline 12.7.0 → 12.9.0

package/pipeline/scripts/smoke-no-mcp-in-dev-phases.sh

@@ -1,194 +0,0 @@
-#!/usr/bin/env bash
-#
-# smoke-no-mcp-in-dev-phases.sh
-#
-# Gate: pipeline run telemetry must not contain MCP calls outside Phase 1
-# (Analysis). Per Locked decision 30, MCP usage is permitted only during
-# Phase 1; any entry in state.telemetry.mcpCalls[] with phase >= 2 is a
-# violation.
-#
-# Two modes.
-#
-# CHECK MODE (--state-file <path>): audit that one state file.
-#   - telemetry.mcpCalls field absent -> PASS, exit 0 (older run, no telemetry)
-#   - All entries phase < 2   -> PASS, exit 0
-#   - One or more violations  -> FAIL summary on stdout, exit 1
-#   - Missing / corrupt file  -> exit 2
-#
-# SELF-TEST MODE (no arguments): drive check mode over fixtures that cover
-# every verdict, then audit the live state file if one happens to exist.
-#
-# Why: with no --state-file this script used to print "no run to check" and
-# exit 0. On a clean clone, on CI, and on any machine that had not just
-# finished a pipeline run - which is nearly always - the gate for Locked
-# decision 30 therefore asserted nothing while reporting success. A gate whose
-# green tick means "I had nothing to look at" is indistinguishable from one
-# that passed, and this suite had three of those.
-#
-# stdout: human-readable summary only. stderr: empty in normal operation.
-
-set -euo pipefail
-
-STATE_FILE="${HOME}/.claude/state/run/latest.json"
-STATE_FILE_EXPLICIT=0
-
-while [ "$#" -gt 0 ]; do
-  case "$1" in
-    --state-file)
-      shift
-      if [ "$#" -eq 0 ]; then
-        echo "FAIL: --state-file requires a path argument"
-        exit 2
-      fi
-      STATE_FILE="$1"
-      STATE_FILE_EXPLICIT=1
-      shift
-      ;;
-    --state-file=*)
-      STATE_FILE="${1#--state-file=}"
-      STATE_FILE_EXPLICIT=1
-      shift
-      ;;
-    -h|--help)
-      echo "Usage: $0 [--state-file <path>]"
-      echo ""
-      echo "No arguments: run the fixture self-test suite."
-      echo "Default state file when checking live: ~/.claude/state/run/latest.json"
-      exit 0
-      ;;
-    *)
-      echo "FAIL: unknown argument: $1"
-      exit 2
-      ;;
-  esac
-done
-
-if ! command -v jq >/dev/null 2>&1; then
-  echo "FAIL: jq is required but not installed"
-  exit 2
-fi
-
-# ── self-test mode ─────────────────────────────────────────────────────────
-if [ "$STATE_FILE_EXPLICIT" -eq 0 ]; then
-  SELF="$0"
-  TMP=$(mktemp -d)
-  trap 'rm -rf "$TMP"' EXIT
-  PASS=0
-  FAIL=0
-
-  expect() {
-    local name="$1" want="$2" file="$3"
-    local got=0
-    bash "$SELF" --state-file "$file" >/dev/null 2>&1 || got=$?
-    if [ "$got" -eq "$want" ]; then
-      PASS=$((PASS + 1)); echo "  ✓ $name (exit $got)"
-    else
-      FAIL=$((FAIL + 1)); echo "  ✗ $name (exit $got, expected $want)"
-    fi
-  }
-
-  echo "→ Locked decision 30 gate, fixture self-test"
-
-  printf '%s' '{"telemetry":{"mcpCalls":[{"tool":"mcp__figma__get_design_context","phase":1}]}}' \
-    > "$TMP/phase1-only.json"
-  expect "MCP call in Phase 1 passes" 0 "$TMP/phase1-only.json"
-
-  printf '%s' '{"telemetry":{"mcpCalls":[{"tool":"mcp__figma__get_design_context","phase":3}]}}' \
-    > "$TMP/phase3.json"
-  expect "MCP call in Phase 3 is a violation" 1 "$TMP/phase3.json"
-
-  printf '%s' '{"telemetry":{"mcpCalls":[{"tool":"a","phase":1},{"tool":"b","phase":2}]}}' \
-    > "$TMP/mixed.json"
-  expect "one violation among clean entries still fails" 1 "$TMP/mixed.json"
-
-  printf '%s' '{"telemetry":{"mcpCalls":[]}}' > "$TMP/empty.json"
-  expect "empty call list passes" 0 "$TMP/empty.json"
-
-  printf '%s' '{"telemetry":{}}' > "$TMP/no-field.json"
-  expect "absent telemetry.mcpCalls passes (older state format)" 0 "$TMP/no-field.json"
-
-  printf '%s' '{"telemetry":{"mcpCalls":[{"tool":"a"}]}}' > "$TMP/no-phase.json"
-  expect "entry with no phase defaults to Phase 0 and passes" 0 "$TMP/no-phase.json"
-
-  printf '%s' 'not json at all' > "$TMP/corrupt.json"
-  expect "corrupt state is an error, never a silent pass" 2 "$TMP/corrupt.json"
-
-  expect "missing state file is an error in check mode" 2 "$TMP/does-not-exist.json"
-
-  # The live run, when there is one. Absence is not a failure here - the
-  # fixtures above already proved the gate works.
-  if [ -f "$STATE_FILE" ]; then
-    echo "→ live state file"
-    if bash "$SELF" --state-file "$STATE_FILE"; then
-      PASS=$((PASS + 1)); echo "  ✓ live run clean"
-    else
-      FAIL=$((FAIL + 1)); echo "  ✗ live run has violations"
-    fi
-  else
-    echo "→ live state file: none at $STATE_FILE (fixtures already exercised every path)"
-  fi
-
-  echo ""
-  echo "══ smoke-no-mcp-in-dev-phases: $PASS passed, $FAIL failed ══"
-  [ "$FAIL" -gt 0 ] && exit 1 || exit 0
-fi
-
-# ── check mode ─────────────────────────────────────────────────────────────
-if [ ! -f "$STATE_FILE" ]; then
-  echo "FAIL: state file not found at $STATE_FILE"
-  exit 2
-fi
-
-# Validate JSON parse first; corrupt state cannot be silently passed.
-if ! jq empty "$STATE_FILE" >/dev/null 2>&1; then
-  echo "FAIL: state file is not valid JSON: $STATE_FILE"
-  exit 2
-fi
-
-# If telemetry.mcpCalls is absent or not an array, this is an older state
-# format that did not record MCP usage. PASS by contract.
-HAS_FIELD=$(jq -r '
-  if (.telemetry // empty) | type == "object"
-  then
-    if (.telemetry.mcpCalls // empty) | type == "array" then "yes" else "no" end
-  else "no" end
-' "$STATE_FILE")
-
-if [ "$HAS_FIELD" != "yes" ]; then
-  echo "PASS: telemetry.mcpCalls field absent - no MCP usage recorded"
-  exit 0
-fi
-
-# Count total entries and violations (phase >= 2).
-TOTAL=$(jq -r '.telemetry.mcpCalls | length' "$STATE_FILE")
-VIOLATIONS=$(jq -r '
-  .telemetry.mcpCalls
-  | map(select((.phase // 0) >= 2))
-  | length
-' "$STATE_FILE")
-
-if [ "$VIOLATIONS" -eq 0 ]; then
-  if [ "$TOTAL" -eq 0 ]; then
-    echo "PASS: no MCP calls outside Phase 1 (Analysis) - 0 entries"
-  else
-    echo "PASS: no MCP calls outside Phase 1 (Analysis) - ${TOTAL} entries, all in Phase 1"
-  fi
-  exit 0
-fi
-
-# Emit FAIL summary with up to first 5 offenders.
-echo "FAIL: ${VIOLATIONS} MCP call(s) outside Phase 1 (Analysis) - Locked decision 30 violation"
-echo ""
-echo "First $([ "$VIOLATIONS" -lt 5 ] && echo "$VIOLATIONS" || echo 5) violation(s):"
-
-jq -r '
-  .telemetry.mcpCalls
-  | map(select((.phase // 0) >= 2))
-  | .[0:5]
-  | .[]
-  | "  FAIL: MCP call \(.tool // "<unknown>") in Phase \(.phase) at \(.timestamp // "<no timestamp>") - Locked decision 30 violation"
-' "$STATE_FILE"
-
-echo ""
-echo "Total violations: ${VIOLATIONS} of ${TOTAL} entries"
-exit 1

package/pipeline/scripts/smoke-no-token-prompt.sh

@@ -1,85 +0,0 @@
-#!/usr/bin/env bash
-#
-# smoke-no-token-prompt.sh
-#
-# Asserts the pipeline never asks the user to type a token in chat. Tokens
-# are resolved via credential-store.sh; missing/expired tokens trigger the
-# Setup Wizard, not an inline prompt. See refs/keychain.md Rule 1.
-#
-# Greps shell scripts, markdown adapters, and orchestrator commands for
-# hardcoded prompt patterns. Allowlist for legitimate setup wizard prompts.
-
-set -euo pipefail
-
-SELF_DIR=$(cd "$(dirname "$0")" && pwd)
-PIPELINE_ROOT=$(cd "$SELF_DIR/.." && pwd)
-
-cd "$PIPELINE_ROOT"
-
-FAIL=0
-
-# Pattern: anything that looks like the script asking for a token interactively.
-# Acceptable: setup wizard explicitly tagged with `# allow: token-prompt`.
-PATTERNS=(
-  "read -rp.*[Tt]oken"
-  "read -rp.*[Aa]pi.[Kk]ey"
-  "read -rp.*[Pp]aste.*token"
-  "read -rp.*[Ee]nter.*token"
-  'echo "Enter your.*[Tt]oken'
-  'echo "Paste.*[Tt]oken'
-  "AskUserQuestion.*[Tt]oken"
-)
-
-# Files in scope: shell scripts + adapter markdown.
-TARGET_GLOB=(
-  "scripts/*.sh"
-  "scripts/*.mjs"
-  "multi-agent-refs/channels/*.md"
-  "multi-agent-refs/phases/*.md"
-  "commands/multi-agent/dev/SKILL.md"
-  "commands/multi-agent/dev-autopilot/SKILL.md"
-  "commands/multi-agent/autopilot/SKILL.md"
-)
-
-# Build a single grep invocation: all patterns via repeated -e flags,
-# all target globs expanded once. Drops 7x7=49 grep subprocesses down to 1.
-GREP_PATTERN_ARGS=()
-for pattern in "${PATTERNS[@]}"; do
-  GREP_PATTERN_ARGS+=(-e "$pattern")
-done
-
-# Expand all target globs to actual paths once. Globs that don't match are
-# silently dropped so the single grep call sees only existing files.
-TARGET_PATHS=()
-for glob in "${TARGET_GLOB[@]}"; do
-  for path in pipeline/$glob; do
-    [ -e "$path" ] && TARGET_PATHS+=("$path")
-  done
-done
-
-if [ "${#TARGET_PATHS[@]}" -gt 0 ]; then
-  while IFS= read -r match; do
-    [ -z "$match" ] && continue
-    file="${match%%:*}"
-    # Allowlist: setup.md and setup-related files explicitly handle token entry
-    # via the inline Token Save Flow (clipboard-based, not chat).
-    case "$file" in
-      */setup.md|*setup-token-flow*|*credential-store*) continue ;;
-    esac
-    # Allowlist: explicit `# allow: token-prompt` annotation on the line.
-    case "$match" in
-      *'# allow: token-prompt'*) continue ;;
-    esac
-    echo "FAIL [smoke-no-token-prompt]: token prompt found in $file"
-    echo "  $match"
-    FAIL=$((FAIL + 1))
-  done < <(grep -rEn "${GREP_PATTERN_ARGS[@]}" "${TARGET_PATHS[@]}" 2>/dev/null || true)
-fi
-
-if [ "$FAIL" -gt 0 ]; then
-  echo ""
-  echo "smoke-no-token-prompt: $FAIL violation(s). Tokens must be resolved via credential-store.sh; see refs/keychain.md Rule 1."
-  exit 1
-fi
-
-echo "smoke-no-token-prompt: ok"

package/pipeline/scripts/smoke-own-punctuation.sh

@@ -1,103 +0,0 @@
-#!/usr/bin/env bash
-#
-# smoke-own-punctuation.sh  -  the punctuation rule applies to this repo's own
-# shipped files, not only to the documents it generates.
-#
-# validate-analysis-doc.mjs has enforced the locked policy (no em-dash, en-dash,
-# ellipsis or section sign) on generated analysis documents for a long time,
-# and smoke-generate-issue.sh / smoke-review-readiness.sh enforce it on issue
-# and review payloads. Nothing applied it to the pipeline's own tree, so 77
-# shipped files carried 719 em-dashes, 10 en-dashes and 24 ellipses while the
-# rule was described as enforced.
-#
-# ALLOWED holds the files that carry these characters as data rather than
-# prose: the detector's own table and the grep patterns that look for them.
-# Stripping those would disable the very checks this rule depends on. Every
-# entry needs a reason, and the list is expected to stay this short.
-#
-# Exit codes: 0=clean, 1=violations
-
-set -euo pipefail
-
-REPO_ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
-cd "$REPO_ROOT"
-
-# file path -> why the characters are legitimately present
-ALLOWED_PATHS="
-pipeline/scripts/validate-analysis-doc.mjs|the detector's own table of banned characters
-pipeline/scripts/smoke-generate-issue.sh|greps for the banned characters
-pipeline/scripts/smoke-review-readiness.sh|greps for the banned characters
-pipeline/scripts/smoke-md2confluence.sh|dirty-input fixture plus the forbidden list
-pipeline/scripts/smoke-own-punctuation.sh|this file names the characters it bans
-pipeline/lib/md2confluence-v3.py|the converter's codepoint-to-ASCII mapping table
-"
-
-# The same characters written as escapes. prefs.schema.json carried 50 of them
-# in its descriptions and was invisible to a search for the literal character,
-# so the first version of this gate passed it. A rule that only sees one
-# encoding of what it bans is not enforcing the rule.
-ESCAPED='\\u2014|\\u2013|\\u2026|\\u00a7'
-
-is_allowed() {
-  printf '%s\n' "$ALLOWED_PATHS" | grep -q "^$1|"
-}
-
-PASS=0
-FAIL=0
-pass() { PASS=$((PASS + 1)); echo "  ✓ $1"; }
-fail() { FAIL=$((FAIL + 1)); echo "  ✗ $1"; }
-
-echo "→ 1. no em-dash, en-dash, ellipsis or section sign in shipped files"
-
-# CHANGELOG history is left as written; rewriting released notes to satisfy a
-# later style rule would falsify the record.
-VIOLATIONS=""
-while IFS= read -r f; do
-  case "$f" in CHANGELOG*.md) continue ;; esac
-  is_allowed "$f" && continue
-  VIOLATIONS="${VIOLATIONS}${f}\n"
-done < <(git grep -lI -e $'—' -e $'–' -e $'…' -e $'§' -- . 2>/dev/null || true)
-
-if [ -z "$VIOLATIONS" ]; then
-  pass "no banned punctuation outside the allowlist"
-else
-  COUNT=$(printf '%b' "$VIOLATIONS" | grep -c . || true)
-  fail "$COUNT file(s) carry banned punctuation"
-  printf '%b' "$VIOLATIONS" | sed 's/^/    /'
-  echo "    fix: plain ASCII - or : or parentheses; 'section 4' rather than the sign"
-fi
-
-echo "→ 2. same characters written as unicode escapes"
-ESC_VIOLATIONS=""
-while IFS= read -r f; do
-  case "$f" in CHANGELOG*.md) continue ;; esac
-  is_allowed "$f" && continue
-  ESC_VIOLATIONS="${ESC_VIOLATIONS}${f}\n"
-done < <(git grep -lI -E "$ESCAPED" -- . 2>/dev/null || true)
-
-if [ -z "$ESC_VIOLATIONS" ]; then
-  pass "no escaped forms outside the allowlist"
-else
-  COUNT=$(printf '%b' "$ESC_VIOLATIONS" | grep -c . || true)
-  fail "$COUNT file(s) carry the banned characters as unicode escapes"
-  printf '%b' "$ESC_VIOLATIONS" | sed 's/^/    /'
-fi
-
-echo "→ 3. every allowlist entry still exists and still needs the exemption"
-while IFS='|' read -r path reason; do
-  [ -z "$path" ] && continue
-  if [ ! -f "$path" ]; then
-    fail "allowlisted path no longer exists: $path"
-  elif ! grep -qI -e $'—' -e $'–' -e $'…' -e $'§' "$path" 2>/dev/null \
-    && ! grep -qIE "$ESCAPED" "$path" 2>/dev/null; then
-    # Either encoding justifies the entry: md2confluence-v3.py holds them as
-    # escapes, the detector table holds them literally.
-    fail "$path is allowlisted ($reason) but is now clean - drop it from the list"
-  else
-    pass "allowlist justified: ${path##*/} ($reason)"
-  fi
-done < <(printf '%s\n' "$ALLOWED_PATHS" | grep '|')
-
-echo ""
-echo "══ smoke-own-punctuation: $PASS passed, $FAIL failed ══"
-[ "$FAIL" -gt 0 ] && exit 1 || exit 0

package/pipeline/scripts/smoke-pack-contents.sh

@@ -1,140 +0,0 @@
-#!/usr/bin/env bash
-#
-# smoke-pack-contents.sh  -  guard what `npm publish` would actually ship.
-#
-#   1. Deny patterns: package.json files[] carries negations (`!...`) for
-#      dev-only / personal-data files. The published tarball must contain
-#      no file matching any of them. Patterns are read from package.json at
-#      runtime (via node), so the smoke never goes stale when the deny list
-#      changes.
-#   2. File-count band: the total packed file count is compared against the
-#      committed fixture pipeline/scripts/fixtures/pack-expected-count.txt.
-#      Drift beyond +-15 percent fails - that magnitude means the files[]
-#      globs picked up (or dropped) a whole subtree, which deserves a human
-#      look. Refresh the fixture after reviewing:
-#        npm pack --dry-run --json 2>/dev/null \
-#          | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>console.log(JSON.parse(s)[0].files.length))' \
-#          > pipeline/scripts/fixtures/pack-expected-count.txt
-#   3. publint (optional): linted via `npx --no-install` so it only runs
-#      when the package is already installed - never a network fetch.
-#
-# Exit codes: 0=pass, 1=violation, 2=environment broken
-
-set -uo pipefail
-
-REPO_ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
-FIXTURE="$REPO_ROOT/pipeline/scripts/fixtures/pack-expected-count.txt"
-
-command -v npm >/dev/null 2>&1 || { echo "FAIL: npm not on PATH"; exit 2; }
-command -v node >/dev/null 2>&1 || { echo "FAIL: node not on PATH"; exit 2; }
-
-PASS=0
-FAIL=0
-pass() { PASS=$((PASS + 1)); echo "  ✓ $1"; }
-fail() { FAIL=$((FAIL + 1)); echo "  ✗ $1"; }
-
-cleanup() { [ -n "${TMP:-}" ] && rm -rf "$TMP"; }
-trap cleanup EXIT
-TMP=$(mktemp -d)
-
-# ──────────────────────────────────────────────────────────────────────────
-echo "→ 1. npm pack --dry-run --json"
-if ! (cd "$REPO_ROOT" && npm pack --dry-run --json 2>/dev/null > "$TMP/pack.json"); then
-  echo "FAIL: npm pack --dry-run failed"
-  exit 2
-fi
-
-# Deny check runs in node so the patterns come straight from package.json
-# files[] negations - never hardcoded here.
-cat > "$TMP/check.mjs" <<'MJS'
-import { readFileSync } from "node:fs";
-
-const [packJsonPath, pkgJsonPath] = process.argv.slice(2);
-const packed = JSON.parse(readFileSync(packJsonPath, "utf-8"))[0].files.map((f) => f.path);
-const files = JSON.parse(readFileSync(pkgJsonPath, "utf-8")).files || [];
-const denies = files.filter((p) => p.startsWith("!")).map((p) => p.slice(1));
-
-// Minimal glob -> regex: '**' spans path separators, '*' does not.
-const toRegex = (glob) => {
-  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-  const body = escaped
-    .split("**")
-    .map((part) => part.replace(/\*/g, "[^/]*"))
-    .join(".*");
-  return new RegExp("^" + body + "$");
-};
-
-const regexes = denies.map((d) => [d, toRegex(d)]);
-let bad = 0;
-for (const path of packed) {
-  for (const [glob, re] of regexes) {
-    if (re.test(path)) {
-      console.log(`DENY ${path} (matches !${glob})`);
-      bad++;
-    }
-  }
-}
-console.log(`DENYCOUNT ${bad}`);
-console.log(`PATTERNS ${denies.length}`);
-console.log(`COUNT ${packed.length}`);
-MJS
-
-CHECK=$(node "$TMP/check.mjs" "$TMP/pack.json" "$REPO_ROOT/package.json")
-COUNT=$(echo "$CHECK" | awk '/^COUNT /{print $2}')
-DENYCOUNT=$(echo "$CHECK" | awk '/^DENYCOUNT /{print $2}')
-PATTERNS=$(echo "$CHECK" | awk '/^PATTERNS /{print $2}')
-
-if [ -z "$COUNT" ] || [ -z "$DENYCOUNT" ]; then
-  echo "FAIL: deny-pattern checker produced no result (node error?)"
-  exit 2
-fi
-
-pass "pack dry-run produced $COUNT files ($PATTERNS deny patterns loaded from package.json)"
-
-# ──────────────────────────────────────────────────────────────────────────
-echo "→ 2. deny patterns (files[] negations must not ship)"
-if [ "$DENYCOUNT" -eq 0 ]; then
-  pass "no packed file matches a files[] negation"
-else
-  fail "$DENYCOUNT packed file(s) match dev-only/personal-data exclusions:"
-  echo "$CHECK" | grep '^DENY ' | sed 's/^/    /'
-fi
-
-# ──────────────────────────────────────────────────────────────────────────
-echo "→ 3. file-count band vs fixture (+-15 percent)"
-if [ ! -f "$FIXTURE" ]; then
-  fail "fixture missing: $FIXTURE - create it from the refresh command in this script's header"
-else
-  EXPECTED=$(tr -cd '0-9' < "$FIXTURE")
-  if [ -z "$EXPECTED" ] || [ "$EXPECTED" -eq 0 ]; then
-    fail "fixture unreadable or zero: $FIXTURE"
-  else
-    DIFF=$((COUNT - EXPECTED))
-    [ "$DIFF" -lt 0 ] && DIFF=$((-DIFF))
-    LIMIT=$((EXPECTED * 15 / 100))
-    if [ "$DIFF" -le "$LIMIT" ]; then
-      pass "count $COUNT within +-15 percent of expected $EXPECTED (drift $DIFF, limit $LIMIT)"
-    else
-      fail "count $COUNT drifted beyond +-15 percent of expected $EXPECTED (drift $DIFF, limit $LIMIT)"
-      echo "    Review what the files[] globs now include, then refresh the fixture"
-      echo "    (refresh command is in this script's header comment)."
-    fi
-  fi
-fi
-
-# ──────────────────────────────────────────────────────────────────────────
-echo "→ 4. publint (optional, npx --no-install only)"
-if (cd "$REPO_ROOT" && npx --no-install publint --help >/dev/null 2>&1); then
-  if OUT=$(cd "$REPO_ROOT" && npx --no-install publint 2>&1); then
-    pass "publint: no errors"
-  else
-    fail "publint reported errors"
-    echo "$OUT" | sed 's/^/    /'
-  fi
-else
-  echo "  ↷ SKIP: publint not installed (npx --no-install found no local package)"
-fi
-
-echo ""
-echo "══ smoke-pack-contents: $PASS passed, $FAIL failed ══"
-[ "$FAIL" -gt 0 ] && exit 1 || exit 0

package/pipeline/scripts/smoke-pat-audit.sh

@@ -1,128 +0,0 @@
-#!/usr/bin/env bash
-# smoke-pat-audit.sh  -  exercises audit-log.sh + audit-log-rotate.sh and
-# asserts the section18.2 contract:
-#
-#   • Every PAT lookup writes a structured event to audit.jsonl
-#   • Repo URLs are SHA-256 hashed (no plaintext)
-#   • Identity is logged by name (NOT anonymized  -  user's own debug)
-#   • Audit log is gitignored
-#   • Daily rotation script preserves history (gzipped) + drops >30d archives
-
-set -uo pipefail
-
-AUDIT_FILE="$HOME/.claude/logs/multi-agent/audit.jsonl"
-TMP_AUDIT="$(mktemp -d -t ma-audit-smoke-XXXX)"
-TMP_FILE="$TMP_AUDIT/audit.jsonl"
-trap 'rm -rf "$TMP_AUDIT"' EXIT
-
-PASS=0; FAIL=0
-pass() { PASS=$((PASS+1)); echo "  ✓ $1"; }
-fail() { FAIL=$((FAIL+1)); echo "  ✗ $1"; }
-
-LOG="$HOME/.claude/scripts/audit-log.sh"
-ROTATE="$HOME/.claude/scripts/audit-log-rotate.sh"
-
-if [ ! -x "$LOG" ]; then
-  fail "audit-log.sh missing or not executable: $LOG"
-  echo "══ aborted ══"; exit 2
-fi
-
-echo "→ 1. Emit a sample PAT lookup"
-TEST_IDENTITY="smoke-user"
-AUDIT_FILE="$TMP_FILE" "$LOG" pat_lookup bitbucket "$TEST_IDENTITY" \
-  "https://bitbucket.example.com/proj/repo" true scope=REPO_WRITE
-[ -s "$TMP_FILE" ] && pass "audit.jsonl has content after emit" \
-  || fail "audit.jsonl empty after emit"
-
-LINE=$(tail -1 "$TMP_FILE")
-echo "  emitted: $LINE"
-
-echo ""
-echo "→ 2. Repo URL is SHA-256 hashed (not plaintext)"
-echo "$LINE" | grep -q '"repo_url_sha":"[a-f0-9]\{64\}"' \
-  && pass "repo_url_sha is a 64-char hex SHA-256" \
-  || fail "repo_url_sha not in expected SHA-256 form"
-echo "$LINE" | grep -q "bitbucket.example.com" \
-  && fail "PLAINTEXT URL leaked into audit log!" \
-  || pass "Plaintext URL absent (only hash present)"
-
-echo ""
-echo "→ 3. Identity is logged by name (per section18.2.3  -  not anonymized)"
-echo "$LINE" | grep -q "\"identity\":\"$TEST_IDENTITY\"" \
-  && pass "identity logged as plaintext name" \
-  || fail "identity not logged or anonymized"
-
-echo ""
-echo "→ 4. Service is captured"
-echo "$LINE" | grep -q '"service":"bitbucket"' \
-  && pass "service field captured" \
-  || fail "service field missing"
-
-echo ""
-echo "→ 5. Success flag is a JSON bool (not string)"
-echo "$LINE" | grep -q '"success":true' \
-  && pass "success is JSON bool" \
-  || fail "success is not bool"
-
-echo ""
-echo "→ 6. Extras (key=value pairs) preserved"
-echo "$LINE" | grep -q '"scope":"REPO_WRITE"' \
-  && pass "extras preserved (scope=REPO_WRITE)" \
-  || fail "extras not preserved"
-
-echo ""
-echo "→ 7. Rotation script exists + executable"
-[ -x "$ROTATE" ] \
-  && pass "audit-log-rotate.sh present + executable" \
-  || fail "audit-log-rotate.sh missing or not executable"
-
-echo ""
-echo "→ 8. Rotation produces a dated archive + truncates live file"
-# Drive a dry rotation in our TMP dir
-AUDIT_DIR="$TMP_AUDIT" bash "$ROTATE" >/dev/null 2>&1
-ROTATED=$(find "$TMP_AUDIT" -name 'audit.*.jsonl*' -type f 2>/dev/null | head -1)
-[ -n "$ROTATED" ] \
-  && pass "rotation produced archive: $(basename "$ROTATED")" \
-  || fail "rotation produced no archive"
-[ -f "$TMP_FILE" ] && [ ! -s "$TMP_FILE" ] \
-  && pass "live audit.jsonl truncated to empty after rotation" \
-  || fail "live audit.jsonl not properly truncated"
-
-echo ""
-echo "→ 9. .gitignore covers audit logs (sensitive  -  never sync upstream)"
-SMOKE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-GITIGNORES=(
-  "$HOME/.claude/.gitignore"
-  "$SMOKE_DIR/../../.gitignore"
-  "$HOME/multi-agent-pipeline/.gitignore"
-)
-GITIGNORE_OK=false
-for gi in "${GITIGNORES[@]}"; do
-  [ -f "$gi" ] && grep -qE 'audit\.jsonl|logs/multi-agent' "$gi" 2>/dev/null && GITIGNORE_OK=true
-done
-$GITIGNORE_OK \
-  && pass ".gitignore covers audit.jsonl / logs/multi-agent" \
-  || fail ".gitignore does NOT cover audit logs (sensitive!)"
-
-echo ""
-echo "→ 10. Quote-bearing fields are JSON-escaped (no malformed lines)"
-REPO_LOG="$(cd "$(dirname "$0")" && pwd)/audit-log.sh"
-ESC_FILE="$TMP_AUDIT/escape.jsonl"
-AUDIT_FILE="$ESC_FILE" bash "$REPO_LOG" \
-  'pat_"lookup' 'bit"bucket' 'evil" ,"injected":"x' \
-  "https://x.example/r" true 'rea"son=quote'
-ESC_LINE=$(tail -1 "$ESC_FILE")
-if printf '%s' "$ESC_LINE" | python3 -c 'import json,sys; json.loads(sys.stdin.read())' 2>/dev/null; then
-  pass "line with embedded double-quotes parses as valid JSON"
-else
-  fail "embedded quotes produced malformed JSON: $ESC_LINE"
-fi
-if printf '%s' "$ESC_LINE" | python3 -c 'import json,sys; d=json.load(sys.stdin); sys.exit(0 if "injected" not in d else 1)' 2>/dev/null; then
-  pass "quote in field value did not inject a sibling JSON key"
-else
-  fail "quote in field value injected an extra top-level key"
-fi
-
-echo ""
-echo "══ pat-audit smoke: $PASS passed, $FAIL failed ══"
-[ "$FAIL" -eq 0 ]