@mmerterden/multi-agent-pipeline 12.7.0 → 12.8.0

package/pipeline/scripts/smoke-lib-scripts.sh

@@ -1,448 +0,0 @@
-#!/usr/bin/env bash
-# smoke-lib-scripts.sh  -  sanity checks for picker library scripts.
-# Verifies each lib emits the expected JSON shape so the picker pipeline can
-# rely on it. Network-dependent paths (real Jira/GH fetch) are skipped; only
-# offline-detectable behavior is asserted.
-#
-# Covered:
-#   credential-store.sh   doctor, platform detection, get/set/delete cycle (macOS only)
-#   account-resolver.sh   returns JSON array with required fields
-#   issue-fetcher.sh      input-kind detection + maturity object shape
-#   multi-repo-pipeline.sh bridge → schema-valid agent-state.json v2.1.0
-
-set -uo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-LIB_DIR="$REPO_ROOT/pipeline/lib"
-
-PASS=0
-FAIL=0
-
-ok()   { echo "  ✓ $1"; PASS=$((PASS+1)); }
-fail() { echo "  ✗ $1" >&2; FAIL=$((FAIL+1)); }
-
-# --- credential-store.sh -----------------------------------------------------
-echo "→ credential-store.sh"
-CRED="$LIB_DIR/credential-store.sh"
-if [ ! -x "$CRED" ]; then
-  fail "credential-store.sh missing or not executable"
-else
-  PLATFORM=$("$CRED" platform 2>/dev/null || echo "")
-  case "$PLATFORM" in
-    macos|windows|linux|unknown) ok "platform detected: $PLATFORM" ;;
-    *) fail "unexpected platform output: $PLATFORM" ;;
-  esac
-
-  if "$CRED" doctor 2>&1 | grep -qE '^Backend:'; then
-    ok "doctor reports backend"
-  else
-    fail "doctor missing Backend: line"
-  fi
-
-  # macOS only: full get/set/delete round-trip with throwaway key
-  if [ "$PLATFORM" = "macos" ]; then
-    KEY="multi-agent-smoke-test-$$"
-    VAL="smoke-value-$(date +%s)"
-    if "$CRED" set "$KEY" "$VAL" 2>/dev/null; then
-      readback=$("$CRED" get "$KEY" 2>/dev/null || echo "")
-      if [ "$readback" = "$VAL" ]; then
-        ok "set/get round-trip works"
-      else
-        fail "get returned '$readback' instead of '$VAL'"
-      fi
-      "$CRED" delete "$KEY" 2>/dev/null
-      empty=$("$CRED" get "$KEY" 2>/dev/null || echo "")
-      if [ -z "$empty" ]; then
-        ok "delete clears the entry"
-      else
-        fail "entry still present after delete"
-      fi
-    else
-      fail "set failed on macOS"
-    fi
-  fi
-fi
-
-# --- account-resolver.sh -----------------------------------------------------
-echo "→ account-resolver.sh"
-RESOLVER="$LIB_DIR/account-resolver.sh"
-if [ ! -x "$RESOLVER" ]; then
-  fail "account-resolver.sh missing or not executable"
-else
-  out=$("$RESOLVER" 2>/dev/null || echo "[]")
-  if printf '%s' "$out" | python3 -c 'import json,sys; json.loads(sys.stdin.read())' 2>/dev/null; then
-    ok "emits valid JSON"
-  else
-    fail "JSON output invalid: $(printf '%s' "$out" | head -c 200)"
-  fi
-
-  # When non-empty, every account must have the required fields
-  python3 - <<PY
-import json, sys
-try:
-    data = json.loads('''$out''')
-except Exception as e:
-    print(f"PARSE_FAIL:{e}")
-    sys.exit(0)
-
-if not data:
-    print("EMPTY")
-    sys.exit(0)
-
-required = {"id","label","prefix","providers","tokens","userKeys","users","jiraHost","bitbucketHost","isWork"}
-missing = []
-for i, acc in enumerate(data):
-    miss = required - set(acc.keys())
-    if miss:
-        missing.append((i, sorted(miss)))
-if missing:
-    print(f"MISSING_FIELDS:{missing}")
-else:
-    print(f"OK:{len(data)} accounts, all required fields present")
-PY
-  status=$(python3 - <<PY
-import json
-data = json.loads('''$out''')
-print("ok" if data and all({"id","label","prefix","providers","tokens","userKeys","users","jiraHost","bitbucketHost","isWork"} <= set(a.keys()) for a in data) else ("empty" if not data else "fields-missing"))
-PY
-)
-  case "$status" in
-    ok)             ok "all accounts have required schema fields" ;;
-    empty)          ok "no accounts on this machine (skipping schema check)" ;;
-    fields-missing) fail "some accounts missing required fields" ;;
-  esac
-fi
-
-# --- issue-fetcher.sh: input-kind detection (no network) ---------------------
-echo "→ issue-fetcher.sh"
-FETCHER="$LIB_DIR/issue-fetcher.sh"
-if [ ! -x "$FETCHER" ]; then
-  fail "issue-fetcher.sh missing or not executable"
-else
-  # detect_kind is internal; we exercise via freetext + jira-id paths that
-  # don't hit the network. Freetext is the safest offline assertion.
-  out=$("$FETCHER" "Login crash on iOS 17" 2>/dev/null || echo "")
-  if printf '%s' "$out" | python3 -c 'import json,sys; d=json.loads(sys.stdin.read()); assert d["kind"]=="freetext", d["kind"]; assert d["maturity"]["score"] is None, "freetext score should be None"' 2>/dev/null; then
-    ok "freetext path emits kind=freetext + maturity.score=None"
-  else
-    fail "freetext path output unexpected: $(printf '%s' "$out" | head -c 200)"
-  fi
-
-  # Jira-id detection without token (fetch will fail, but kind detection should still work)
-  out=$(ACCOUNT_JIRA_TOKEN_KEY="" ACCOUNT_JIRA_HOST="" "$FETCHER" "PROJ-1" 2>/dev/null || echo "")
-  if printf '%s' "$out" | python3 -c 'import json,sys; d=json.loads(sys.stdin.read()); assert d["kind"]=="jira", d["kind"]; assert d["key"]=="PROJ-1", d["key"]' 2>/dev/null; then
-    ok "jira-id path emits kind=jira + key parsed"
-  else
-    fail "jira-id path output unexpected"
-  fi
-
-  # Bare "#316" and "316" must land in the gh-num branch (needsRepoPicker
-  # descriptor when no default owner/repo), NOT gh-short with an empty repo
-  # prefix that builds https://github.com/<owner>//issues/316.
-  for bare in "#316" "316"; do
-    out=$(ACCOUNT_DEFAULT_OWNER="" ACCOUNT_DEFAULT_REPO="" "$FETCHER" "$bare" 2>/dev/null || echo "")
-    if printf '%s' "$out" | python3 -c 'import json,sys; d=json.loads(sys.stdin.read()); assert d["kind"]=="github", d["kind"]; assert d["key"]=="316", d["key"]; assert d.get("needsRepoPicker") is True, d' 2>/dev/null; then
-      ok "bare '$bare' classified as gh-num (key=316, needsRepoPicker)"
-    else
-      fail "bare '$bare' misclassified: $(printf '%s' "$out" | head -c 200)"
-    fi
-  done
-fi
-
-# --- multi-repo-pipeline.sh: bridge --------------------------------------
-echo "→ multi-repo-pipeline.sh bridge"
-MRP="$LIB_DIR/multi-repo-pipeline.sh"
-if [ ! -x "$MRP" ]; then
-  fail "multi-repo-pipeline.sh missing or not executable"
-else
-  TMP=$(mktemp -d)
-  cat > "$TMP/state.json" <<EOF
-{
-  "taskId": "PROJ-1-smoke-$$",
-  "shortId": 1,
-  "branch": "feature/PROJ-1",
-  "baseBranch": "develop",
-  "issueRef": {"kind":"jira","key":"PROJ-1","title":"Smoke test"},
-  "primary": {"name":"my-app","cloneUrl":"git@github.com:org/my-app.git","provider":"github"},
-  "extras": [{"name":"common","cloneUrl":"git@github.com:org/common.git","provider":"github"}],
-  "worktreeRoot": "$TMP/worktree",
-  "commitType": "feat",
-  "identity": {"name":"Smoke","email":"smoke@example.com"}
-}
-EOF
-  bridged=$("$MRP" bridge "$TMP/state.json" 2>/dev/null || echo "")
-  if [ -z "$bridged" ] || [ ! -f "$bridged" ]; then
-    fail "bridge did not write agent-state.json"
-  else
-    if python3 - <<PY 2>/dev/null
-import json
-import jsonschema  # may not be installed in CI; fall back to shape check
-PY
-    then
-      python3 - "$bridged" "$REPO_ROOT/pipeline/schemas/agent-state.schema.json" <<'PY' && ok "bridge output schema-valid (jsonschema)" || fail "bridge output schema-invalid"
-import json, sys
-from jsonschema import Draft202012Validator
-data = json.load(open(sys.argv[1]))
-schema = json.load(open(sys.argv[2]))
-errs = list(Draft202012Validator(schema).iter_errors(data))
-if errs:
-    for e in errs: print("✗", "/".join(str(p) for p in e.absolute_path), e.message)
-    sys.exit(1)
-PY
-    else
-      # Fallback: shape-only check
-      if python3 - "$bridged" <<'PY' 2>/dev/null
-import json, sys
-d = json.load(open(sys.argv[1]))
-required = {"schemaVersion","taskId","shortId","project","branch","baseBranch","currentPhase","status","startedAt","phases","identity","projects"}
-missing = required - set(d.keys())
-assert not missing, f"missing: {missing}"
-assert d["schemaVersion"] == "2.1.0"
-assert len(d["projects"]) == 2
-PY
-      then
-        ok "bridge output has required fields (jsonschema unavailable; shape check)"
-      else
-        fail "bridge output missing required fields"
-      fi
-    fi
-    rm -rf "$(dirname "$bridged")"
-  fi
-  rm -rf "$TMP"
-fi
-
-# --- multi-repo-pipeline.sh: prepare + commit + teardown (offline) -----------
-# Uses local bare-repo fixtures so we can exercise prepare/commit/teardown
-# without network access. push and pr remain unverified (network-bound).
-echo "→ multi-repo-pipeline.sh prepare/commit/teardown (offline fixtures)"
-MRP="$LIB_DIR/multi-repo-pipeline.sh"
-if [ ! -x "$MRP" ]; then
-  fail "multi-repo-pipeline.sh not executable (already reported above)"
-else
-  FIXTURE_ROOT=$(mktemp -d)
-  REPO_A_BARE="$FIXTURE_ROOT/repo-a.git"
-  REPO_B_BARE="$FIXTURE_ROOT/repo-b.git"
-  WORKTREE_ROOT="$FIXTURE_ROOT/wt"
-
-  # Build two bare-repo fixtures with one initial commit each.
-  for bare in "$REPO_A_BARE" "$REPO_B_BARE"; do
-    git init --quiet --bare -b main "$bare"
-    seed=$(mktemp -d)
-    git -C "$seed" init --quiet -b main
-    echo "init" > "$seed/README.md"
-    git -C "$seed" add README.md
-    git -C "$seed" -c user.email=t@e.com -c user.name=T commit --quiet -m "init"
-    git -C "$seed" remote add origin "$bare"
-    git -C "$seed" push --quiet origin main
-    rm -rf "$seed"
-  done
-
-  cat > "$FIXTURE_ROOT/state.json" <<EOF
-{
-  "taskId":"OFFLINE-1",
-  "shortId":1,
-  "branch":"feature/OFFLINE-1",
-  "baseBranch":"main",
-  "issueRef":{"kind":"jira","key":"OFFLINE-1","title":"smoke fixture"},
-  "primary":{"name":"repo-a","cloneUrl":"$REPO_A_BARE","provider":"github"},
-  "extras":[{"name":"repo-b","cloneUrl":"$REPO_B_BARE","provider":"github"}],
-  "worktreeRoot":"$WORKTREE_ROOT",
-  "commitType":"feat",
-  "identity":{"name":"T","email":"t@e.com"}
-}
-EOF
-
-  # prepare
-  if "$MRP" prepare "$FIXTURE_ROOT/state.json" >/dev/null 2>&1; then
-    if [ -d "$WORKTREE_ROOT/repo-a/.git" ] && [ -d "$WORKTREE_ROOT/repo-b/.git" ]; then
-      ok "prepare clones every repo into worktreeRoot"
-    else
-      fail "prepare did not create both worktrees"
-    fi
-    branch_a=$(git -C "$WORKTREE_ROOT/repo-a" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")
-    branch_b=$(git -C "$WORKTREE_ROOT/repo-b" rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")
-    if [ "$branch_a" = "feature/OFFLINE-1" ] && [ "$branch_b" = "feature/OFFLINE-1" ]; then
-      ok "prepare checks out the task branch in every repo"
-    else
-      fail "prepare branch mismatch: a=$branch_a b=$branch_b"
-    fi
-  else
-    fail "prepare exited non-zero on offline fixture"
-  fi
-
-  # commit
-  echo "change-a" > "$WORKTREE_ROOT/repo-a/feature.txt"
-  echo "change-b" > "$WORKTREE_ROOT/repo-b/feature.txt"
-  git -C "$WORKTREE_ROOT/repo-a" config user.email t@e.com >/dev/null 2>&1
-  git -C "$WORKTREE_ROOT/repo-a" config user.name T >/dev/null 2>&1
-  git -C "$WORKTREE_ROOT/repo-b" config user.email t@e.com >/dev/null 2>&1
-  git -C "$WORKTREE_ROOT/repo-b" config user.name T >/dev/null 2>&1
-
-  if "$MRP" commit "$FIXTURE_ROOT/state.json" >/dev/null 2>&1; then
-    msg_a=$(git -C "$WORKTREE_ROOT/repo-a" log -1 --pretty=%s 2>/dev/null || echo "")
-    msg_b=$(git -C "$WORKTREE_ROOT/repo-b" log -1 --pretty=%s 2>/dev/null || echo "")
-    if printf '%s' "$msg_a" | grep -q '\[OFFLINE-1\]' && printf '%s' "$msg_b" | grep -q '\[OFFLINE-1\]'; then
-      ok "commit creates one commit per repo with [JIRA-KEY] suffix"
-    else
-      fail "commit messages missing key suffix: a=$msg_a b=$msg_b"
-    fi
-  else
-    fail "commit exited non-zero"
-  fi
-
-  # bridge (re-verify schema-valid output uses the repo names)
-  bridged=$("$MRP" bridge "$FIXTURE_ROOT/state.json" 2>/dev/null || echo "")
-  if [ -n "$bridged" ] && python3 -c '
-import json, sys
-d = json.load(open(sys.argv[1]))
-assert len(d["projects"]) == 2
-assert d["projects"][0]["project"] == "repo-a"
-assert d["projects"][1]["project"] == "repo-b"
-' "$bridged" 2>/dev/null; then
-    ok "bridge populates projects[] from primary + extras"
-    rm -rf "$(dirname "$bridged")"
-  else
-    fail "bridge output missing projects[] entries"
-  fi
-
-  # teardown guard: a worktreeRoot of "." (the current project root) must be
-  # refused loudly, never rm -rf'd.
-  UNSAFE_STATE="$FIXTURE_ROOT/unsafe-state.json"
-  sed 's|"worktreeRoot":"[^"]*"|"worktreeRoot":"."|' "$FIXTURE_ROOT/state.json" > "$UNSAFE_STATE"
-  GUARD_DIR=$(mktemp -d)
-  ( cd "$GUARD_DIR" && "$MRP" teardown "$UNSAFE_STATE" ) >/dev/null 2>&1
-  guard_rc=$?
-  if [ "$guard_rc" -ne 0 ] && [ -d "$GUARD_DIR" ]; then
-    ok "teardown refuses worktreeRoot='.' (exit=$guard_rc, dir intact)"
-  else
-    fail "teardown did not refuse unsafe worktreeRoot='.' (exit=$guard_rc)"
-  fi
-  rm -rf "$GUARD_DIR"
-
-  # teardown
-  "$MRP" teardown "$FIXTURE_ROOT/state.json" >/dev/null 2>&1
-  if [ ! -d "$WORKTREE_ROOT" ]; then
-    ok "teardown removes worktreeRoot"
-  else
-    fail "teardown left $WORKTREE_ROOT in place"
-  fi
-
-  rm -rf "$FIXTURE_ROOT"
-fi
-
-# --- channels-multi-repo.sh: render fan-out (offline) ------------------------
-echo "→ channels-multi-repo.sh renderers"
-CMR="$LIB_DIR/channels-multi-repo.sh"
-if [ ! -x "$CMR" ]; then
-  fail "channels-multi-repo.sh missing or not executable"
-else
-  TMP=$(mktemp -d)
-  cat > "$TMP/multi.json" <<'EOF'
-{
-  "schemaVersion":"2.1.0","taskId":"X","shortId":1,"project":"my-app",
-  "branch":"feature/X","baseBranch":"develop","currentPhase":6,"status":"in_progress",
-  "startedAt":"2026-04-27T12:00:00Z","phases":{},"identity":{"name":"T","email":"t@e.com"},
-  "projects":[
-    {"project":"my-app","projectRoot":"/tmp/a","branch":"feature/X","baseBranch":"develop","identity":{"name":"T","email":"t@e.com"},"pr":{"number":42,"url":"https://github.com/org/my-app/pull/42"}},
-    {"project":"common","projectRoot":"/tmp/b","branch":"feature/X","baseBranch":"develop","identity":{"name":"T","email":"t@e.com"},"pr":{"number":17,"url":"https://github.com/org/common/pull/17"}}
-  ]
-}
-EOF
-  cat > "$TMP/single.json" <<'EOF'
-{
-  "schemaVersion":"2.1.0","taskId":"Y","shortId":1,"project":"my-app",
-  "branch":"feature/Y","baseBranch":"develop","currentPhase":6,"status":"in_progress",
-  "startedAt":"2026-04-27T12:00:00Z","phases":{},"identity":{"name":"T","email":"t@e.com"},
-  "pr":{"number":1,"url":"https://github.com/org/my-app/pull/1"}
-}
-EOF
-  echo "body content" > "$TMP/body.md"
-
-  # targets: multi-repo gives 2 entries with cross-links populated
-  count=$("$CMR" targets "$TMP/multi.json" 2>/dev/null | python3 -c 'import json,sys; d=json.load(sys.stdin); print(len(d))')
-  if [ "$count" = "2" ]; then
-    ok "targets emits one entry per project (multi-repo)"
-  else
-    fail "targets count $count != 2"
-  fi
-
-  # render-pr: extras body must mention 'Part of:' primary URL
-  rendered=$("$CMR" render-pr "$TMP/multi.json" "$TMP/body.md" "common" 2>/dev/null)
-  if printf '%s' "$rendered" | grep -q "Part of: https://github.com/org/my-app"; then
-    ok "render-pr injects 'Part of:' link on extras"
-  else
-    fail "render-pr missing 'Part of:' on extras"
-  fi
-  rendered=$("$CMR" render-pr "$TMP/multi.json" "$TMP/body.md" "my-app" 2>/dev/null)
-  if printf '%s' "$rendered" | grep -q "Related: https://github.com/org/common"; then
-    ok "render-pr injects 'Related:' link on primary"
-  else
-    fail "render-pr missing 'Related:' on primary"
-  fi
-
-  # render-jira: bulleted PR list at top
-  rendered=$("$CMR" render-jira "$TMP/multi.json" "$TMP/body.md" 2>/dev/null)
-  bullet_count=$(printf '%s' "$rendered" | grep -c '^\* PR:' || true)
-  if [ "$bullet_count" = "2" ]; then
-    ok "render-jira prepends bulleted PR list (2 entries)"
-  else
-    fail "render-jira bullet count $bullet_count != 2"
-  fi
-
-  # render-jira/-conf with ZERO PR urls: must pass the body through unchanged
-  # (the old `grep -c || echo 0` idiom emitted "0\n0" here and prepended
-  # bogus "* PR:" bullets to the posted body).
-  cat > "$TMP/noprs.json" <<'EOF'
-{
-  "schemaVersion":"2.1.0","taskId":"Z","shortId":1,"project":"my-app",
-  "branch":"feature/Z","baseBranch":"develop","currentPhase":6,"status":"in_progress",
-  "startedAt":"2026-04-27T12:00:00Z","phases":{},"identity":{"name":"T","email":"t@e.com"},
-  "projects":[
-    {"project":"my-app","projectRoot":"/tmp/a","branch":"feature/Z","baseBranch":"develop","identity":{"name":"T","email":"t@e.com"},"pr":null},
-    {"project":"common","projectRoot":"/tmp/b","branch":"feature/Z","baseBranch":"develop","identity":{"name":"T","email":"t@e.com"},"pr":null}
-  ]
-}
-EOF
-  rendered=$("$CMR" render-jira "$TMP/noprs.json" "$TMP/body.md" 2>/dev/null)
-  if [ "$rendered" = "body content" ]; then
-    ok "render-jira with zero PR urls passes body through unchanged"
-  else
-    fail "render-jira with zero PR urls mutated body: $rendered"
-  fi
-  rendered=$("$CMR" render-conf "$TMP/noprs.json" "$TMP/body.md" 2>/dev/null)
-  if [ "$rendered" = "body content" ]; then
-    ok "render-conf with zero PR urls passes body through unchanged"
-  else
-    fail "render-conf with zero PR urls mutated body: $rendered"
-  fi
-
-  # render-conf: ## Related PRs heading
-  rendered=$("$CMR" render-conf "$TMP/multi.json" "$TMP/body.md" 2>/dev/null)
-  if printf '%s' "$rendered" | grep -q "## Related PRs"; then
-    ok "render-conf prepends 'Related PRs' heading"
-  else
-    fail "render-conf missing heading block"
-  fi
-
-  # single-repo passthrough: render-pr on single state must return body unchanged
-  rendered=$("$CMR" render-pr "$TMP/single.json" "$TMP/body.md" "my-app" 2>/dev/null)
-  if [ "$rendered" = "body content" ]; then
-    ok "single-repo passthrough leaves body unchanged"
-  else
-    fail "single-repo passthrough mutated body: $rendered"
-  fi
-
-  rm -rf "$TMP"
-fi
-
-# --- Summary -----------------------------------------------------------------
-echo ""
-TOTAL=$((PASS+FAIL))
-if [ $FAIL -eq 0 ]; then
-  echo "══ lib-scripts smoke: $PASS passed, 0 failed ══"
-  exit 0
-else
-  echo "══ lib-scripts smoke: $PASS passed, $FAIL failed (of $TOTAL) ══" >&2
-  exit 1
-fi

package/pipeline/scripts/smoke-mcp-gate.sh

@@ -1,68 +0,0 @@
-#!/usr/bin/env bash
-# smoke-mcp-gate.sh  -  fixture-based test harness for smoke-no-mcp-in-dev-phases.sh.
-#
-# The gate script doubles as the production check (run against a live
-# state.telemetry.mcpCalls[] after a pipeline run) and is also picked up by the
-# smoke-*.sh glob  -  but bare, with no live run, it only WARNs. This harness
-# drives the gate with crafted state files so the actual decision logic
-# (PASS / FAIL / WARN / parse-error) is exercised in CI on every run.
-
-set -uo pipefail
-
-REPO_ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
-GATE="$REPO_ROOT/pipeline/scripts/smoke-no-mcp-in-dev-phases.sh"
-
-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)
-
-run_gate() { bash "$GATE" --state-file "$1" >/dev/null 2>&1; echo $?; }
-
-echo "→ 1. Clean run (all MCP calls in Phase 1) PASSES"
-cat > "$TMP/clean.json" <<'EOF'
-{"telemetry":{"mcpCalls":[
-  {"tool":"mcp__claude_ai_Figma__get_design_context","phase":1,"timestamp":"2026-05-29T10:00:00Z"},
-  {"tool":"mcp__claude_ai_Figma__get_screenshot","phase":1,"timestamp":"2026-05-29T10:00:05Z"}
-]}}
-EOF
-[ "$(run_gate "$TMP/clean.json")" = "0" ] && pass "phase-1-only telemetry exits 0" || fail "phase-1-only telemetry should exit 0"
-
-echo "→ 2. Violation (MCP call in Phase 3) FAILS"
-cat > "$TMP/viol.json" <<'EOF'
-{"telemetry":{"mcpCalls":[
-  {"tool":"mcp__claude_ai_Figma__get_design_context","phase":1,"timestamp":"2026-05-29T10:00:00Z"},
-  {"tool":"mcp__claude_ai_Figma__get_screenshot","phase":3,"timestamp":"2026-05-29T11:00:00Z"}
-]}}
-EOF
-[ "$(run_gate "$TMP/viol.json")" = "1" ] && pass "phase-3 MCP call exits 1" || fail "phase-3 MCP call should exit 1 (gate is a no-op?)"
-
-echo "→ 3. Phase 2+ boundary (phase 2 is a violation)"
-cat > "$TMP/viol2.json" <<'EOF'
-{"telemetry":{"mcpCalls":[{"tool":"mcp__claude_ai_Figma__get_metadata","phase":2,"timestamp":"2026-05-29T10:30:00Z"}]}}
-EOF
-[ "$(run_gate "$TMP/viol2.json")" = "1" ] && pass "phase-2 MCP call exits 1" || fail "phase-2 MCP call should exit 1"
-
-echo "→ 4. Empty mcpCalls array PASSES"
-cat > "$TMP/empty.json" <<'EOF'
-{"telemetry":{"mcpCalls":[]}}
-EOF
-[ "$(run_gate "$TMP/empty.json")" = "0" ] && pass "empty mcpCalls exits 0" || fail "empty mcpCalls should exit 0"
-
-echo "→ 5. Absent telemetry field PASSES (backward compat with pre-v9 runs)"
-cat > "$TMP/absent.json" <<'EOF'
-{"taskId":"#1","status":"complete"}
-EOF
-[ "$(run_gate "$TMP/absent.json")" = "0" ] && pass "absent telemetry exits 0" || fail "absent telemetry should exit 0"
-
-echo "→ 6. Corrupt JSON state is a hard error (not silently passed)"
-echo '{not valid json' > "$TMP/corrupt.json"
-[ "$(run_gate "$TMP/corrupt.json")" = "2" ] && pass "corrupt state exits 2" || fail "corrupt state should exit 2"
-
-echo ""
-echo "══ mcp-gate smoke: $PASS passed, $FAIL failed ══"
-[ "$FAIL" -eq 0 ]

package/pipeline/scripts/smoke-md-links.sh

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-# smoke-md-links.sh - thin wrapper so the internal markdown link gate runs
-# inside the standard smoke discovery (run-smokes.mjs picks up smoke-*.sh).
-# Logic lives in check-md-links.mjs.
-set -euo pipefail
-
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
-node "$ROOT/pipeline/scripts/check-md-links.mjs"

package/pipeline/scripts/smoke-md2confluence.sh

@@ -1,126 +0,0 @@
-#!/usr/bin/env bash
-# smoke-md2confluence.sh  -  offline sanity checks for md2confluence-v3.py.
-# Imports the module from its file path and exercises the pure conversion
-# layer: front-matter parsing, the TR/EN punctuation gate (fancy punctuation
-# stripped, diacritics preserved), and markdown -> storage-XML rendering for
-# headings, tables, and code blocks. No network, no credentials, no Confluence.
-
-set -uo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-MOD="$REPO_ROOT/pipeline/lib/md2confluence-v3.py"
-
-if ! command -v python3 >/dev/null 2>&1; then
-  echo "smoke-md2confluence: python3 not found; skipping" >&2
-  exit 0
-fi
-
-if [ ! -f "$MOD" ]; then
-  echo "  ✗ md2confluence-v3.py missing at $MOD" >&2
-  exit 1
-fi
-
-MOD_PATH="$MOD" python3 - <<'PYEOF'
-import importlib.util
-import os
-import sys
-
-spec = importlib.util.spec_from_file_location("md2c", os.environ["MOD_PATH"])
-mod = importlib.util.module_from_spec(spec)
-sys.modules["md2c"] = mod  # dataclass introspection needs the module registered
-spec.loader.exec_module(mod)
-
-passed = 0
-failed = 0
-
-def ok(msg):
-    global passed
-    print(f"  ✓ {msg}")
-    passed += 1
-
-def fail(msg):
-    global failed
-    print(f"  ✗ {msg}", file=sys.stderr)
-    failed += 1
-
-# --- parse_front_matter ------------------------------------------------------
-print("→ parse_front_matter")
-fm, body = mod.parse_front_matter("---\nfeature: Sample\nlanguage: tr\n---\n# Heading\nbody text\n")
-if fm.get("feature") == "Sample" and fm.get("language") == "tr":
-    ok("front-matter keys parsed")
-else:
-    fail(f"front-matter parse wrong: {fm}")
-if body.startswith("# Heading"):
-    ok("body separated from front-matter")
-else:
-    fail(f"body not separated: {body[:40]!r}")
-
-fm2, body2 = mod.parse_front_matter("# No front matter\n")
-if fm2 == {} and body2.startswith("# No"):
-    ok("no-front-matter input passes through")
-else:
-    fail("no-front-matter input mangled")
-
-# --- apply_punctuation_gate ----------------------------------------------------
-print("→ apply_punctuation_gate")
-dirty = "Geliştirme Özeti — kullanıcı için “detay” …"
-clean, warnings = mod.apply_punctuation_gate(dirty, "tr")
-forbidden = ["—", "–", "…", "“", "”", "‘", "’"]
-if not any(ch in clean for ch in forbidden):
-    ok("fancy punctuation stripped")
-else:
-    fail(f"fancy punctuation survived: {clean!r}")
-for ch in ("ş", "Ö", "ı", "ç"):
-    if ch not in clean:
-        fail(f"diacritic {ch!r} was lost - gate must not ASCII-fold")
-        break
-else:
-    ok("Turkish diacritics preserved")
-
-# --- markdown_to_storage ---------------------------------------------------------
-print("→ markdown_to_storage")
-md = "\n".join([
-    "# Title",
-    "",
-    "Intro paragraph.",
-    "",
-    "| A | B |",
-    "|---|---|",
-    "| 1 | 2 |",
-    "",
-    "```swift",
-    "let x = 1",
-    "```",
-])
-res = mod.markdown_to_storage(
-    md,
-    attachments_available=set(),
-    mermaid_fallback=True,
-    tooltip_macro_supported=False,
-)
-xml = res.storage_xml
-checks = [
-    ("<h1>", "h1 heading rendered"),
-    ("<table>", "table rendered"),
-    ("ac:structured-macro", "code block rendered as macro"),
-]
-for needle, label in checks:
-    if needle in xml:
-        ok(label)
-    else:
-        fail(f"{label}: {needle!r} not found in storage XML")
-
-if res.images_referenced == []:
-    ok("no phantom image references")
-else:
-    fail(f"unexpected images referenced: {res.images_referenced}")
-
-# --- summary -------------------------------------------------------------------
-print()
-if failed == 0:
-    print(f"══ md2confluence smoke: {passed} passed, 0 failed ══")
-    sys.exit(0)
-print(f"══ md2confluence smoke: {passed} passed, {failed} failed ══", file=sys.stderr)
-sys.exit(1)
-PYEOF