@sandrinio/vbounce 1.5.0 → 1.6.0

package/brains/AGENTS.md

@@ -45,11 +45,13 @@ Before starting any sprint, the Team Lead MUST:
 0. Team Lead runs `./scripts/pre_bounce_sync.sh` to ensure LanceDB RAG context is fresh.
 1. Team Lead sends Story context pack to Developer.
 2. Developer queries LanceDB, implements code, writes Implementation Report. CLI Orchestrator must run `./scripts/validate_report.mjs` on the report to enforce YAML strictness.
-3. QA runs Quick Scan + PR Review, validates against Story §2 The Truth. If fail → Bug Report to Dev. CLI Orchestrator must run `./scripts/validate_report.mjs` on the QA report before passing to Architect/Dev.
-4. Dev fixes and resubmits. 3+ failures → Escalated.
-5. Architect runs Deep Audit + Trend Check, validates Safe Zone compliance and ADR adherence.
-6. DevOps merges story branch into sprint branch, validates post-merge, handles release tagging.
-7. Team Lead consolidates reports into Sprint Report.
+3. **Pre-QA Gate Scan:** Team Lead runs `./scripts/pre_gate_runner.sh qa` to catch mechanical failures before spawning QA. If trivial issues → return to Dev.
+4. QA runs Quick Scan + PR Review (skipping pre-scanned checks), validates against Story §2 The Truth. If fail → Bug Report to Dev. CLI Orchestrator must run `./scripts/validate_report.mjs` on the QA report.
+5. Dev fixes and resubmits. 3+ failures → Escalated.
+6. **Pre-Architect Gate Scan:** Team Lead runs `./scripts/pre_gate_runner.sh arch` to catch structural issues before spawning Architect. If mechanical failures → return to Dev.
+7. Architect runs Deep Audit + Trend Check (skipping pre-scanned checks), validates Safe Zone compliance and ADR adherence.
+8. DevOps merges story branch into sprint branch, validates post-merge (tests + lint + build), handles release tagging.
+9. Team Lead consolidates reports into Sprint Report.
 
 **Hotfix Path (L1 Trivial Tasks):**
 1. Team Lead evaluates request and creates `HOTFIX-{Date}-{Name}.md`.

package/brains/CHANGELOG.md

@@ -6,6 +6,17 @@ Per **Rule 13: Framework Integrity**, anytime an entry is made here, the orchest
 ## [2026-03-02]
 - **Initialized**: Created strict Framework Integrity tracking, YAML context handoffs, and RAG validation pipeline.
 
+## [2026-03-06] — Pre-Gate Automation
+- **Added**: `scripts/pre_gate_common.sh` — shared gate check functions with auto-detection for JS/TS, Python, Rust, Go stacks.
+- **Added**: `scripts/pre_gate_runner.sh` — universal pre-gate scanner. Reads `.bounce/gate-checks.json` config or falls back to auto-detected defaults. Runs before QA (`qa`) and Architect (`arch`) agents to catch mechanical failures with zero tokens.
+- **Added**: `scripts/init_gate_config.sh` — auto-detects project stack (language, framework, test runner, build/lint commands) and generates `.bounce/gate-checks.json`.
+- **Modified**: `brains/claude-agents/qa.md` — added Pre-Computed Scan Results section. QA skips checks covered by `pre-qa-scan.txt`.
+- **Modified**: `brains/claude-agents/architect.md` — added Pre-Computed Scan Results section. Architect skips mechanical checks covered by `pre-arch-scan.txt`.
+- **Modified**: `brains/claude-agents/devops.md` — added `npm run lint` (tsc --noEmit) to post-merge validation.
+- **Modified**: `skills/agent-team/SKILL.md` — wired pre-gate scans into Steps 3 (QA) and 4 (Architect). Added gate config init to Step 0 sprint setup. Added lint to post-merge validation.
+- **Modified**: All brain files (`CLAUDE.md`, `GEMINI.md`, `AGENTS.md`, `cursor-rules/vbounce-process.mdc`) — updated bounce sequence to include pre-gate scan steps.
+- **Modified**: `skills/improve/SKILL.md` — added Gate Check Proposals section for iteratively growing project-specific checks via `gate-checks.json`.
+
 ## [2026-03-06]
 - **Fixed**: All brain files (`CLAUDE.md`, `GEMINI.md`, `AGENTS.md`) incorrectly referenced `DELIVERY_PLAN.md §5 Open Questions` or `ACTIVE_SPRINT.md §3 Open Questions`. Corrected to `sprint-{XX}.md §2 Sprint Open Questions` to match the authoritative `agent-team/SKILL.md` and `sprint.md` template.
 - **Fixed**: Removed duplicate "Product Plans Folder Structure" header in `doc-manager/SKILL.md`.

package/brains/CLAUDE.md

@@ -59,11 +59,13 @@ Before starting any sprint, the Team Lead MUST:
 0. Team Lead runs `./scripts/pre_bounce_sync.sh` to ensure LanceDB RAG context is fresh.
 1. Team Lead sends Story context pack to Developer.
 2. Developer queries LanceDB, implements code, writes Implementation Report. CLI Orchestrator must run `./scripts/validate_report.mjs` on the report to enforce YAML strictness.
-3. QA runs Quick Scan + PR Review, validates against Story §2 The Truth. If fail → Bug Report to Dev. CLI Orchestrator must run `./scripts/validate_report.mjs` on the QA report before passing to Architect/Dev.
-4. Dev fixes and resubmits. 3+ failures → Escalated.
-5. Architect runs Deep Audit + Trend Check, validates Safe Zone compliance and ADR adherence.
-6. DevOps merges story branch into sprint branch, validates post-merge, handles release tagging.
-7. Team Lead consolidates reports into Sprint Report.
+3. **Pre-QA Gate Scan:** Team Lead runs `./scripts/pre_gate_runner.sh qa` to catch mechanical failures (tests, build, lint, debug output, JSDoc) before spawning QA. If trivial issues found → return to Dev.
+4. QA runs Quick Scan + PR Review (skipping pre-scanned checks), validates against Story §2 The Truth. If fail → Bug Report to Dev. CLI Orchestrator must run `./scripts/validate_report.mjs` on the QA report.
+5. Dev fixes and resubmits. 3+ failures → Escalated.
+6. **Pre-Architect Gate Scan:** Team Lead runs `./scripts/pre_gate_runner.sh arch` to catch structural issues (new deps, file sizes) before spawning Architect. If mechanical failures → return to Dev.
+7. Architect runs Deep Audit + Trend Check (skipping pre-scanned checks), validates Safe Zone compliance and ADR adherence.
+8. DevOps merges story branch into sprint branch, validates post-merge (tests + lint + build), handles release tagging.
+9. Team Lead consolidates reports into Sprint Report.
 
 **Hotfix Path (L1 Trivial Tasks):**
 1. Team Lead evaluates request and creates `HOTFIX-{Date}-{Name}.md`.

package/brains/GEMINI.md

@@ -50,11 +50,13 @@ Before starting any sprint, the Team Lead MUST:
 0. Team Lead runs `./scripts/pre_bounce_sync.sh` to ensure LanceDB RAG context is fresh.
 1. Team Lead sends Story context pack to Developer.
 2. Developer queries LanceDB, implements code, writes Implementation Report. CLI Orchestrator must run `./scripts/validate_report.mjs` on the report to enforce YAML strictness.
-3. QA runs Quick Scan + PR Review, validates against Story §2 The Truth. If fail → Bug Report to Dev. CLI Orchestrator must run `./scripts/validate_report.mjs` on the QA report before passing to Architect/Dev.
-4. Dev fixes and resubmits. 3+ failures → Escalated.
-5. Architect runs Deep Audit + Trend Check, validates Safe Zone compliance and ADR adherence.
-6. DevOps merges story branch into sprint branch, validates post-merge, handles release tagging.
-7. Team Lead consolidates reports into Sprint Report.
+3. **Pre-QA Gate Scan:** Team Lead runs `./scripts/pre_gate_runner.sh qa` to catch mechanical failures before spawning QA. If trivial issues → return to Dev.
+4. QA runs Quick Scan + PR Review (skipping pre-scanned checks), validates against Story §2 The Truth. If fail → Bug Report to Dev. CLI Orchestrator must run `./scripts/validate_report.mjs` on the QA report.
+5. Dev fixes and resubmits. 3+ failures → Escalated.
+6. **Pre-Architect Gate Scan:** Team Lead runs `./scripts/pre_gate_runner.sh arch` to catch structural issues before spawning Architect. If mechanical failures → return to Dev.
+7. Architect runs Deep Audit + Trend Check (skipping pre-scanned checks), validates Safe Zone compliance and ADR adherence.
+8. DevOps merges story branch into sprint branch, validates post-merge (tests + lint + build), handles release tagging.
+9. Team Lead consolidates reports into Sprint Report.
 
 **Hotfix Path (L1 Trivial Tasks):**
 1. Team Lead evaluates request and creates `HOTFIX-{Date}-{Name}.md`.

package/brains/claude-agents/architect.md

@@ -19,6 +19,15 @@ Audit the codebase for structural integrity, standards compliance, and long-term
 3. **Read the full Story spec** — especially §3 Implementation Guide and §3.1 ADR References.
 4. **Read Roadmap §3 ADRs** — every architecture decision the implementation must comply with.
 
+## Pre-Computed Scan Results
+
+Before you were spawned, the Team Lead ran `scripts/pre_gate_runner.sh arch`. Read the results at `.bounce/reports/pre-arch-scan.txt`.
+
+- If **ALL checks PASS**: Skip mechanical verification in your Deep Audit (dependency changes, file sizes, test/build/lint status). Focus on **judgment-based dimensions**: architectural consistency, error handling quality, data flow traceability, coupling assessment, and AI-ism detection.
+- If **ANY check FAILS**: Note failures in your report. Focus your audit on the areas that failed.
+
+The 6-dimension evaluation should focus on qualitative judgment. Mechanical checks (new deps, file sizes, exports documentation) are pre-computed — reference `pre-arch-scan.txt` rather than re-running them.
+
 ## Your Audit Process
 
 ### Deep Audit (Full Codebase Analysis)

package/brains/claude-agents/devops.md

@@ -63,6 +63,9 @@ When resolving conflicts:
 # Run test suite on the merged sprint branch
 npm test  # or project-appropriate test command
 
+# Type check (if applicable)
+npm run lint  # tsc --noEmit or equivalent linter
+
 # Verify no regressions
 npm run build  # or project-appropriate build command
 

package/brains/claude-agents/qa.md

@@ -16,12 +16,19 @@ Validate that the Developer's implementation meets the Story's acceptance criter
 2. **Read the Developer Implementation Report** (`.bounce/reports/STORY-{ID}-{StoryName}-dev.md`) to understand what was built.
 3. **Read Story §2 The Truth** — these are your pass/fail criteria. If the Gherkin scenarios don't pass, the bounce failed.
 
+## Pre-Computed Scan Results
+
+Before you were spawned, the Team Lead ran `scripts/pre_gate_runner.sh qa`. Read the results at `.bounce/reports/pre-qa-scan.txt`.
+
+- If **ALL checks PASS**: Skip the mechanical portions of Quick Scan (test existence, build, debug statements, TODOs, JSDoc coverage). Focus your Quick Scan on **architectural consistency and error handling** only.
+- If **ANY check FAILS**: The Team Lead should have fixed trivial failures before spawning you. If failures remain, note them in your report but do not re-run the checks — trust the scan output.
+
 ## Your Testing Process
 
 ### Quick Scan (Health Check)
-Run a fast structural check of the project using the vibe-code-review skill (Quick Scan mode):
+Run a fast structural check using the vibe-code-review skill (Quick Scan mode):
 - Read `skills/vibe-code-review/SKILL.md` and `skills/vibe-code-review/references/quick-scan.md`
-- Execute the checks against the codebase
+- Skip checks already covered by `pre-qa-scan.txt` (tests exist, build passes, no debug output, no TODOs, JSDoc coverage). Focus on **judgment-based structural assessment**.
 - Flag any obvious structural issues
 
 ### PR Review (Diff Analysis)

package/brains/cursor-rules/vbounce-process.mdc

@@ -22,11 +22,13 @@ Before sprints: Lead triages request (L1 Trivial → Hotfix Path. L2-L4 → Epic
 0. Team Lead runs `./scripts/pre_bounce_sync.sh` to ensure LanceDB RAG context is fresh.
 1. Team Lead sends Story context pack to Developer.
 2. Developer reads LESSONS.md, implements code, writes Implementation Report. CLI Orchestrator must run `./scripts/validate_report.mjs` on the report to enforce YAML strictness.
-3. QA validates against Story §2 The Truth. If fail → Bug Report to Dev. CLI Orchestrator must run `./scripts/validate_report.mjs` on the QA report before passing to Architect/Dev.
-4. Dev fixes and resubmits. 3+ failures → Escalated.
-5. Architect validates Safe Zone compliance and ADR adherence.
-6. DevOps merges story into sprint branch, validates, handles releases.
-7. Team Lead consolidates into Sprint Report.
+3. Pre-QA Gate Scan: `./scripts/pre_gate_runner.sh qa` catches mechanical failures before spawning QA. Trivial issues → return to Dev.
+4. QA validates against Story §2 The Truth (skipping pre-scanned checks). If fail → Bug Report to Dev.
+5. Dev fixes and resubmits. 3+ failures → Escalated.
+6. Pre-Architect Gate Scan: `./scripts/pre_gate_runner.sh arch` catches structural issues before spawning Architect.
+7. Architect validates Safe Zone compliance and ADR adherence (skipping pre-scanned checks).
+8. DevOps merges story into sprint branch, validates (tests + lint + build), handles releases.
+9. Team Lead consolidates into Sprint Report.
 
 **Hotfix Path (L1 Trivial Task):**
 1. Team Lead evaluates request and creates `HOTFIX-{Date}-{Name}.md`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sandrinio/vbounce",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "V-Bounce OS: Turn your AI coding assistant into a full engineering team through structured SDLC skills.",
   "type": "module",
   "bin": {

package/scripts/init_gate_config.sh

@@ -0,0 +1,151 @@
+#!/usr/bin/env bash
+# init_gate_config.sh — Auto-detect project stack and generate .bounce/gate-checks.json
+# Usage: ./scripts/init_gate_config.sh [project-path]
+#
+# Run once during project setup or when the improve skill suggests new checks.
+# Safe to re-run — merges with existing config (preserves custom checks).
+
+set -euo pipefail
+
+PROJECT_PATH="${1:-.}"
+PROJECT_PATH="$(cd "$PROJECT_PATH" && pwd)"
+CONFIG_PATH="${PROJECT_PATH}/.bounce/gate-checks.json"
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+
+echo -e "${CYAN}V-Bounce OS Gate Config Initializer${NC}"
+echo -e "Project: ${PROJECT_PATH}"
+echo ""
+
+# ── Detect stack ─────────────────────────────────────────────────────
+
+LANGUAGE="unknown"
+FRAMEWORK="unknown"
+TEST_RUNNER="unknown"
+BUILD_CMD=""
+LINT_CMD=""
+TEST_CMD=""
+
+# Language detection
+if [[ -f "${PROJECT_PATH}/tsconfig.json" ]]; then
+  LANGUAGE="typescript"
+elif [[ -f "${PROJECT_PATH}/package.json" ]]; then
+  LANGUAGE="javascript"
+elif [[ -f "${PROJECT_PATH}/pyproject.toml" || -f "${PROJECT_PATH}/setup.py" || -f "${PROJECT_PATH}/requirements.txt" ]]; then
+  LANGUAGE="python"
+elif [[ -f "${PROJECT_PATH}/Cargo.toml" ]]; then
+  LANGUAGE="rust"
+elif [[ -f "${PROJECT_PATH}/go.mod" ]]; then
+  LANGUAGE="go"
+elif [[ -f "${PROJECT_PATH}/build.gradle" || -f "${PROJECT_PATH}/pom.xml" ]]; then
+  LANGUAGE="java"
+elif [[ -f "${PROJECT_PATH}/Package.swift" ]]; then
+  LANGUAGE="swift"
+fi
+
+echo -e "Language: ${GREEN}${LANGUAGE}${NC}"
+
+# Framework detection (JS/TS ecosystem)
+if [[ -f "${PROJECT_PATH}/package.json" ]]; then
+  PKG_CONTENT=$(cat "${PROJECT_PATH}/package.json")
+
+  if echo "$PKG_CONTENT" | grep -q '"next"'; then FRAMEWORK="nextjs"
+  elif echo "$PKG_CONTENT" | grep -q '"react"'; then FRAMEWORK="react"
+  elif echo "$PKG_CONTENT" | grep -q '"vue"'; then FRAMEWORK="vue"
+  elif echo "$PKG_CONTENT" | grep -q '"svelte"'; then FRAMEWORK="svelte"
+  elif echo "$PKG_CONTENT" | grep -q '"express"'; then FRAMEWORK="express"
+  elif echo "$PKG_CONTENT" | grep -q '"fastify"'; then FRAMEWORK="fastify"
+  elif echo "$PKG_CONTENT" | grep -q '"@angular/core"'; then FRAMEWORK="angular"
+  fi
+
+  # Test runner
+  if echo "$PKG_CONTENT" | grep -q '"vitest"'; then TEST_RUNNER="vitest"
+  elif echo "$PKG_CONTENT" | grep -q '"jest"'; then TEST_RUNNER="jest"
+  elif echo "$PKG_CONTENT" | grep -q '"mocha"'; then TEST_RUNNER="mocha"
+  elif echo "$PKG_CONTENT" | grep -q '"ava"'; then TEST_RUNNER="ava"
+  fi
+
+  # Commands from scripts
+  BUILD_CMD=$(node -e "try{const p=require('${PROJECT_PATH}/package.json');console.log(p.scripts&&p.scripts.build||'')}catch(e){}" 2>/dev/null || echo "")
+  LINT_CMD=$(node -e "try{const p=require('${PROJECT_PATH}/package.json');console.log(p.scripts&&p.scripts.lint||'')}catch(e){}" 2>/dev/null || echo "")
+  TEST_CMD=$(node -e "try{const p=require('${PROJECT_PATH}/package.json');const t=p.scripts&&p.scripts.test||'';if(t&&!t.includes('no test specified'))console.log(t);else console.log('')}catch(e){}" 2>/dev/null || echo "")
+elif [[ "$LANGUAGE" == "python" ]]; then
+  if command -v pytest &>/dev/null; then TEST_RUNNER="pytest"; fi
+  if command -v ruff &>/dev/null; then LINT_CMD="ruff check ."; fi
+elif [[ "$LANGUAGE" == "rust" ]]; then
+  TEST_RUNNER="cargo"
+  BUILD_CMD="cargo build"
+  LINT_CMD="cargo clippy"
+elif [[ "$LANGUAGE" == "go" ]]; then
+  TEST_RUNNER="go"
+  BUILD_CMD="go build ./..."
+  LINT_CMD="golangci-lint run"
+fi
+
+echo -e "Framework: ${GREEN}${FRAMEWORK}${NC}"
+echo -e "Test runner: ${GREEN}${TEST_RUNNER}${NC}"
+[[ -n "$BUILD_CMD" ]] && echo -e "Build: ${GREEN}${BUILD_CMD}${NC}"
+[[ -n "$LINT_CMD" ]] && echo -e "Lint: ${GREEN}${LINT_CMD}${NC}"
+echo ""
+
+# ── Generate config ──────────────────────────────────────────────────
+
+# Build QA checks array
+QA_CHECKS='[
+    { "id": "tests_exist", "enabled": true, "description": "Verify test files exist for modified source files" },
+    { "id": "tests_pass", "enabled": true, "description": "Run test suite" },
+    { "id": "build", "enabled": true, "description": "Run build command" },
+    { "id": "lint", "enabled": true, "description": "Run linter" },
+    { "id": "no_debug_output", "enabled": true, "description": "No debug statements in modified files" },
+    { "id": "no_todo_fixme", "enabled": true, "description": "No TODO/FIXME in modified files" },
+    { "id": "exports_have_docs", "enabled": true, "description": "Exported symbols have doc comments" }
+  ]'
+
+# Build Architect checks array
+ARCH_CHECKS='[
+    { "id": "tests_exist", "enabled": true, "description": "Verify test files exist for modified source files" },
+    { "id": "tests_pass", "enabled": true, "description": "Run test suite" },
+    { "id": "build", "enabled": true, "description": "Run build command" },
+    { "id": "lint", "enabled": true, "description": "Run linter" },
+    { "id": "no_debug_output", "enabled": true, "description": "No debug statements in modified files" },
+    { "id": "no_todo_fixme", "enabled": true, "description": "No TODO/FIXME in modified files" },
+    { "id": "exports_have_docs", "enabled": true, "description": "Exported symbols have doc comments" },
+    { "id": "no_new_deps", "enabled": true, "description": "No new dependencies without review" },
+    { "id": "file_size", "enabled": true, "max_lines": 500, "description": "Source files under 500 lines" }
+  ]'
+
+# Write config
+mkdir -p "$(dirname "$CONFIG_PATH")"
+
+cat > "$CONFIG_PATH" << HEREDOC
+{
+  "version": 1,
+  "detected_stack": {
+    "language": "${LANGUAGE}",
+    "framework": "${FRAMEWORK}",
+    "test_runner": "${TEST_RUNNER}",
+    "build_cmd": "${BUILD_CMD}",
+    "lint_cmd": "${LINT_CMD}",
+    "test_cmd": "${TEST_CMD}"
+  },
+  "qa_checks": ${QA_CHECKS},
+  "arch_checks": ${ARCH_CHECKS},
+  "custom_checks": []
+}
+HEREDOC
+
+echo -e "${GREEN}Generated: ${CONFIG_PATH}${NC}"
+echo ""
+echo "Universal checks enabled. To add project-specific checks:"
+echo "  1. Run sprints and let agents collect Process Feedback"
+echo "  2. Use the 'improve' skill to propose new checks"
+echo "  3. Or manually add entries to the custom_checks array"
+echo ""
+echo -e "Example custom check (add to custom_checks):"
+echo '  { "id": "custom_grep", "gate": "arch", "enabled": true,'
+echo '    "pattern": "var\\(--my-prefix-", "glob": "*.tsx",'
+echo '    "should_find": false, "description": "No raw CSS vars in components" }'

package/scripts/pre_gate_common.sh

@@ -0,0 +1,576 @@
+#!/usr/bin/env bash
+# pre_gate_common.sh — Shared gate check functions for V-Bounce OS
+# Sourced by pre_gate_runner.sh. Never run directly.
+
+set -euo pipefail
+
+# ── Colors & formatting ──────────────────────────────────────────────
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+
+PASS_COUNT=0
+FAIL_COUNT=0
+SKIP_COUNT=0
+RESULTS=""
+
+record_result() {
+  local id="$1" status="$2" detail="$3"
+  case "$status" in
+    PASS) PASS_COUNT=$((PASS_COUNT + 1)); RESULTS+="| ${id} | ${GREEN}PASS${NC} | ${detail} |"$'\n' ;;
+    FAIL) FAIL_COUNT=$((FAIL_COUNT + 1)); RESULTS+="| ${id} | ${RED}FAIL${NC} | ${detail} |"$'\n' ;;
+    SKIP) SKIP_COUNT=$((SKIP_COUNT + 1)); RESULTS+="| ${id} | ${YELLOW}SKIP${NC} | ${detail} |"$'\n' ;;
+  esac
+}
+
+record_result_plain() {
+  local id="$1" status="$2" detail="$3"
+  PLAIN_RESULTS+="| ${id} | ${status} | ${detail} |"$'\n'
+}
+
+print_summary() {
+  echo ""
+  echo -e "${CYAN}── Gate Check Results ──${NC}"
+  echo "| Check | Status | Detail |"
+  echo "|-------|--------|--------|"
+  echo -e "$RESULTS"
+  echo ""
+  echo -e "PASS: ${GREEN}${PASS_COUNT}${NC}  FAIL: ${RED}${FAIL_COUNT}${NC}  SKIP: ${YELLOW}${SKIP_COUNT}${NC}"
+}
+
+write_report() {
+  local output_path="$1"
+  mkdir -p "$(dirname "$output_path")"
+  {
+    echo "# Pre-Gate Scan Results"
+    echo "Date: $(date -u '+%Y-%m-%d %H:%M UTC')"
+    echo "Target: ${WORKTREE_PATH}"
+    echo "Gate: ${GATE_TYPE}"
+    echo ""
+    echo "| Check | Status | Detail |"
+    echo "|-------|--------|--------|"
+    echo -e "$PLAIN_RESULTS"
+    echo ""
+    echo "PASS: ${PASS_COUNT}  FAIL: ${FAIL_COUNT}  SKIP: ${SKIP_COUNT}"
+  } > "$output_path"
+}
+
+# ── Stack detection helpers ──────────────────────────────────────────
+
+detect_test_cmd() {
+  local dir="$1"
+  if [[ -f "${dir}/package.json" ]]; then
+    local test_script
+    test_script=$(node -e "try{const p=require('${dir}/package.json');console.log(p.scripts&&p.scripts.test||'')}catch(e){}" 2>/dev/null || echo "")
+    if [[ -n "$test_script" && "$test_script" != "echo \"Error: no test specified\" && exit 1" ]]; then
+      echo "npm test"
+      return
+    fi
+  fi
+  if [[ -f "${dir}/pytest.ini" || -f "${dir}/pyproject.toml" || -f "${dir}/setup.cfg" ]]; then
+    echo "pytest"
+    return
+  fi
+  if [[ -f "${dir}/Cargo.toml" ]]; then
+    echo "cargo test"
+    return
+  fi
+  if [[ -f "${dir}/go.mod" ]]; then
+    echo "go test ./..."
+    return
+  fi
+  echo ""
+}
+
+detect_build_cmd() {
+  local dir="$1"
+  if [[ -f "${dir}/package.json" ]]; then
+    local build_script
+    build_script=$(node -e "try{const p=require('${dir}/package.json');console.log(p.scripts&&p.scripts.build||'')}catch(e){}" 2>/dev/null || echo "")
+    if [[ -n "$build_script" ]]; then
+      echo "npm run build"
+      return
+    fi
+  fi
+  if [[ -f "${dir}/Cargo.toml" ]]; then
+    echo "cargo build"
+    return
+  fi
+  if [[ -f "${dir}/go.mod" ]]; then
+    echo "go build ./..."
+    return
+  fi
+  echo ""
+}
+
+detect_lint_cmd() {
+  local dir="$1"
+  if [[ -f "${dir}/package.json" ]]; then
+    local lint_script
+    lint_script=$(node -e "try{const p=require('${dir}/package.json');console.log(p.scripts&&p.scripts.lint||'')}catch(e){}" 2>/dev/null || echo "")
+    if [[ -n "$lint_script" ]]; then
+      echo "npm run lint"
+      return
+    fi
+  fi
+  if command -v ruff &>/dev/null && [[ -f "${dir}/pyproject.toml" ]]; then
+    echo "ruff check ."
+    return
+  fi
+  if [[ -f "${dir}/Cargo.toml" ]]; then
+    echo "cargo clippy"
+    return
+  fi
+  echo ""
+}
+
+detect_source_glob() {
+  local dir="$1"
+  if [[ -f "${dir}/tsconfig.json" ]]; then
+    echo "*.{ts,tsx}"
+    return
+  fi
+  if [[ -f "${dir}/package.json" ]]; then
+    echo "*.{js,jsx}"
+    return
+  fi
+  if [[ -f "${dir}/pyproject.toml" || -f "${dir}/setup.py" || -f "${dir}/setup.cfg" ]]; then
+    echo "*.py"
+    return
+  fi
+  if [[ -f "${dir}/Cargo.toml" ]]; then
+    echo "*.rs"
+    return
+  fi
+  if [[ -f "${dir}/go.mod" ]]; then
+    echo "*.go"
+    return
+  fi
+  echo "*"
+}
+
+detect_dep_file() {
+  local dir="$1"
+  if [[ -f "${dir}/package-lock.json" ]]; then echo "package.json"; return; fi
+  if [[ -f "${dir}/yarn.lock" ]]; then echo "package.json"; return; fi
+  if [[ -f "${dir}/pnpm-lock.yaml" ]]; then echo "package.json"; return; fi
+  if [[ -f "${dir}/requirements.txt" ]]; then echo "requirements.txt"; return; fi
+  if [[ -f "${dir}/Pipfile.lock" ]]; then echo "Pipfile"; return; fi
+  if [[ -f "${dir}/pyproject.toml" ]]; then echo "pyproject.toml"; return; fi
+  if [[ -f "${dir}/Cargo.lock" ]]; then echo "Cargo.toml"; return; fi
+  if [[ -f "${dir}/go.sum" ]]; then echo "go.mod"; return; fi
+  echo ""
+}
+
+detect_test_pattern() {
+  local dir="$1"
+  if [[ -f "${dir}/tsconfig.json" || -f "${dir}/package.json" ]]; then
+    echo '\.test\.\|\.spec\.\|__tests__'
+    return
+  fi
+  if [[ -f "${dir}/pyproject.toml" || -f "${dir}/setup.py" ]]; then
+    echo 'test_\|_test\.py'
+    return
+  fi
+  if [[ -f "${dir}/Cargo.toml" ]]; then
+    echo '_test\.rs\|tests/'
+    return
+  fi
+  echo '\.test\.\|\.spec\.\|test_'
+}
+
+detect_doc_comment_pattern() {
+  local dir="$1"
+  if [[ -f "${dir}/tsconfig.json" || -f "${dir}/package.json" ]]; then
+    echo '/\*\*'
+    return
+  fi
+  if [[ -f "${dir}/pyproject.toml" || -f "${dir}/setup.py" ]]; then
+    echo '"""'
+    return
+  fi
+  if [[ -f "${dir}/Cargo.toml" ]]; then
+    echo '///'
+    return
+  fi
+  echo '/\*\*\|"""\|///'
+}
+
+detect_export_pattern() {
+  local dir="$1"
+  if [[ -f "${dir}/tsconfig.json" || -f "${dir}/package.json" ]]; then
+    echo 'export '
+    return
+  fi
+  if [[ -f "${dir}/pyproject.toml" || -f "${dir}/setup.py" ]]; then
+    echo '^def \|^class '
+    return
+  fi
+  if [[ -f "${dir}/Cargo.toml" ]]; then
+    echo '^pub '
+    return
+  fi
+  if [[ -f "${dir}/go.mod" ]]; then
+    echo '^func [A-Z]'
+    return
+  fi
+  echo 'export \|^def \|^class \|^pub \|^func [A-Z]'
+}
+
+detect_debug_pattern() {
+  local dir="$1"
+  if [[ -f "${dir}/tsconfig.json" || -f "${dir}/package.json" ]]; then
+    echo 'console\.log\|console\.debug'
+    return
+  fi
+  if [[ -f "${dir}/pyproject.toml" || -f "${dir}/setup.py" ]]; then
+    echo 'print(\|breakpoint()'
+    return
+  fi
+  if [[ -f "${dir}/Cargo.toml" ]]; then
+    echo 'dbg!\|println!'
+    return
+  fi
+  if [[ -f "${dir}/go.mod" ]]; then
+    echo 'fmt\.Print'
+    return
+  fi
+  echo 'console\.log\|print(\|dbg!\|fmt\.Print'
+}
+
+# ── Get modified files from git diff ─────────────────────────────────
+
+get_modified_files() {
+  local dir="$1"
+  local base_branch="${2:-}"
+  cd "$dir"
+  if [[ -n "$base_branch" ]]; then
+    git diff --name-only "$base_branch"...HEAD -- . 2>/dev/null || git diff --name-only HEAD~1 -- . 2>/dev/null || echo ""
+  else
+    git diff --name-only HEAD~1 -- . 2>/dev/null || echo ""
+  fi
+}
+
+# ── Universal check functions ────────────────────────────────────────
+
+check_tests_exist() {
+  local dir="$1" modified_files="$2"
+  local test_pattern
+  test_pattern=$(detect_test_pattern "$dir")
+  local source_glob
+  source_glob=$(detect_source_glob "$dir")
+
+  if [[ -z "$modified_files" ]]; then
+    record_result "tests_exist" "SKIP" "No modified files detected"
+    record_result_plain "tests_exist" "SKIP" "No modified files detected"
+    return
+  fi
+
+  local missing=0
+  local checked=0
+  while IFS= read -r file; do
+    [[ -z "$file" ]] && continue
+    # Skip test files themselves, configs, docs
+    if echo "$file" | grep -qE '(\.test\.|\.spec\.|__tests__|test_|_test\.|\.md$|\.json$|\.yml$|\.yaml$|\.config\.)'; then
+      continue
+    fi
+    # Only check source files
+    if ! echo "$file" | grep -qE "\.(ts|tsx|js|jsx|py|rs|go)$"; then
+      continue
+    fi
+    checked=$((checked + 1))
+    local basename
+    basename=$(basename "$file" | sed 's/\.[^.]*$//')
+    # Look for a corresponding test file anywhere in the tree
+    if ! find "$dir" -name "*${basename}*" 2>/dev/null | grep -q "$test_pattern"; then
+      missing=$((missing + 1))
+    fi
+  done <<< "$modified_files"
+
+  if [[ $checked -eq 0 ]]; then
+    record_result "tests_exist" "SKIP" "No source files in diff"
+    record_result_plain "tests_exist" "SKIP" "No source files in diff"
+  elif [[ $missing -eq 0 ]]; then
+    record_result "tests_exist" "PASS" "${checked} source files have tests"
+    record_result_plain "tests_exist" "PASS" "${checked} source files have tests"
+  else
+    record_result "tests_exist" "FAIL" "${missing}/${checked} source files missing tests"
+    record_result_plain "tests_exist" "FAIL" "${missing}/${checked} source files missing tests"
+  fi
+}
+
+check_tests_pass() {
+  local dir="$1"
+  local test_cmd
+  test_cmd=$(detect_test_cmd "$dir")
+
+  if [[ -z "$test_cmd" ]]; then
+    record_result "tests_pass" "SKIP" "No test runner detected"
+    record_result_plain "tests_pass" "SKIP" "No test runner detected"
+    return
+  fi
+
+  if (cd "$dir" && eval "$test_cmd" > /dev/null 2>&1); then
+    record_result "tests_pass" "PASS" "${test_cmd}"
+    record_result_plain "tests_pass" "PASS" "${test_cmd}"
+  else
+    record_result "tests_pass" "FAIL" "${test_cmd} failed"
+    record_result_plain "tests_pass" "FAIL" "${test_cmd} failed"
+  fi
+}
+
+check_build() {
+  local dir="$1"
+  local build_cmd
+  build_cmd=$(detect_build_cmd "$dir")
+
+  if [[ -z "$build_cmd" ]]; then
+    record_result "build" "SKIP" "No build command detected"
+    record_result_plain "build" "SKIP" "No build command detected"
+    return
+  fi
+
+  if (cd "$dir" && eval "$build_cmd" > /dev/null 2>&1); then
+    record_result "build" "PASS" "${build_cmd}"
+    record_result_plain "build" "PASS" "${build_cmd}"
+  else
+    record_result "build" "FAIL" "${build_cmd} failed"
+    record_result_plain "build" "FAIL" "${build_cmd} failed"
+  fi
+}
+
+check_lint() {
+  local dir="$1"
+  local lint_cmd
+  lint_cmd=$(detect_lint_cmd "$dir")
+
+  if [[ -z "$lint_cmd" ]]; then
+    record_result "lint" "SKIP" "No linter detected"
+    record_result_plain "lint" "SKIP" "No linter detected"
+    return
+  fi
+
+  if (cd "$dir" && eval "$lint_cmd" > /dev/null 2>&1); then
+    record_result "lint" "PASS" "${lint_cmd}"
+    record_result_plain "lint" "PASS" "${lint_cmd}"
+  else
+    record_result "lint" "FAIL" "${lint_cmd} failed"
+    record_result_plain "lint" "FAIL" "${lint_cmd} failed"
+  fi
+}
+
+check_no_debug_output() {
+  local dir="$1" modified_files="$2"
+  local debug_pattern
+  debug_pattern=$(detect_debug_pattern "$dir")
+
+  if [[ -z "$modified_files" ]]; then
+    record_result "no_debug_output" "SKIP" "No modified files"
+    record_result_plain "no_debug_output" "SKIP" "No modified files"
+    return
+  fi
+
+  local found=0
+  while IFS= read -r file; do
+    [[ -z "$file" ]] && continue
+    [[ ! -f "${dir}/${file}" ]] && continue
+    # Skip test files and configs
+    if echo "$file" | grep -qE '(\.test\.|\.spec\.|__tests__|test_|_test\.|\.config\.|\.md$|\.json$)'; then
+      continue
+    fi
+    if grep -qE "$debug_pattern" "${dir}/${file}" 2>/dev/null; then
+      found=$((found + 1))
+    fi
+  done <<< "$modified_files"
+
+  if [[ $found -eq 0 ]]; then
+    record_result "no_debug_output" "PASS" "No debug statements in modified files"
+    record_result_plain "no_debug_output" "PASS" "No debug statements in modified files"
+  else
+    record_result "no_debug_output" "FAIL" "${found} files contain debug statements"
+    record_result_plain "no_debug_output" "FAIL" "${found} files contain debug statements"
+  fi
+}
+
+check_no_todo_fixme() {
+  local dir="$1" modified_files="$2"
+
+  if [[ -z "$modified_files" ]]; then
+    record_result "no_todo_fixme" "SKIP" "No modified files"
+    record_result_plain "no_todo_fixme" "SKIP" "No modified files"
+    return
+  fi
+
+  local found=0
+  while IFS= read -r file; do
+    [[ -z "$file" ]] && continue
+    [[ ! -f "${dir}/${file}" ]] && continue
+    if grep -qiE '(TODO|FIXME|HACK|XXX)' "${dir}/${file}" 2>/dev/null; then
+      found=$((found + 1))
+    fi
+  done <<< "$modified_files"
+
+  if [[ $found -eq 0 ]]; then
+    record_result "no_todo_fixme" "PASS" "No TODO/FIXME in modified files"
+    record_result_plain "no_todo_fixme" "PASS" "No TODO/FIXME in modified files"
+  else
+    record_result "no_todo_fixme" "FAIL" "${found} files contain TODO/FIXME"
+    record_result_plain "no_todo_fixme" "FAIL" "${found} files contain TODO/FIXME"
+  fi
+}
+
+check_exports_have_docs() {
+  local dir="$1" modified_files="$2"
+  local export_pattern doc_pattern
+  export_pattern=$(detect_export_pattern "$dir")
+  doc_pattern=$(detect_doc_comment_pattern "$dir")
+
+  if [[ -z "$modified_files" ]]; then
+    record_result "exports_have_docs" "SKIP" "No modified files"
+    record_result_plain "exports_have_docs" "SKIP" "No modified files"
+    return
+  fi
+
+  local missing=0
+  local total=0
+  while IFS= read -r file; do
+    [[ -z "$file" ]] && continue
+    [[ ! -f "${dir}/${file}" ]] && continue
+    # Skip test files and configs
+    if echo "$file" | grep -qE '(\.test\.|\.spec\.|__tests__|test_|_test\.|\.config\.|\.md$|\.json$)'; then
+      continue
+    fi
+    if ! echo "$file" | grep -qE "\.(ts|tsx|js|jsx|py|rs|go)$"; then
+      continue
+    fi
+    # Count exports without preceding doc comments
+    local exports_in_file
+    exports_in_file=$(grep -c "$export_pattern" "${dir}/${file}" 2>/dev/null || echo 0)
+    if [[ $exports_in_file -gt 0 ]]; then
+      total=$((total + exports_in_file))
+      local docs_in_file
+      docs_in_file=$(grep -c "$doc_pattern" "${dir}/${file}" 2>/dev/null || echo 0)
+      if [[ $docs_in_file -lt $exports_in_file ]]; then
+        missing=$((missing + (exports_in_file - docs_in_file)))
+      fi
+    fi
+  done <<< "$modified_files"
+
+  if [[ $total -eq 0 ]]; then
+    record_result "exports_have_docs" "SKIP" "No exports in modified files"
+    record_result_plain "exports_have_docs" "SKIP" "No exports in modified files"
+  elif [[ $missing -eq 0 ]]; then
+    record_result "exports_have_docs" "PASS" "${total} exports documented"
+    record_result_plain "exports_have_docs" "PASS" "${total} exports documented"
+  else
+    record_result "exports_have_docs" "FAIL" "${missing}/${total} exports missing doc comments"
+    record_result_plain "exports_have_docs" "FAIL" "${missing}/${total} exports missing doc comments"
+  fi
+}
+
+check_no_new_dependencies() {
+  local dir="$1" base_branch="${2:-}"
+  local dep_file
+  dep_file=$(detect_dep_file "$dir")
+
+  if [[ -z "$dep_file" ]]; then
+    record_result "no_new_deps" "SKIP" "No dependency file detected"
+    record_result_plain "no_new_deps" "SKIP" "No dependency file detected"
+    return
+  fi
+
+  if [[ -z "$base_branch" ]]; then
+    record_result "no_new_deps" "SKIP" "No base branch to compare"
+    record_result_plain "no_new_deps" "SKIP" "No base branch to compare"
+    return
+  fi
+
+  cd "$dir"
+  local diff_output
+  diff_output=$(git diff "$base_branch"...HEAD -- "$dep_file" 2>/dev/null || echo "")
+
+  if [[ -z "$diff_output" ]]; then
+    record_result "no_new_deps" "PASS" "No changes to ${dep_file}"
+    record_result_plain "no_new_deps" "PASS" "No changes to ${dep_file}"
+  else
+    local added
+    added=$(echo "$diff_output" | grep -c "^+" | head -1 || echo "0")
+    record_result "no_new_deps" "FAIL" "${dep_file} modified — review new dependencies"
+    record_result_plain "no_new_deps" "FAIL" "${dep_file} modified — review new dependencies"
+  fi
+}
+
+check_file_size_limit() {
+  local dir="$1" modified_files="$2" max_lines="${3:-500}"
+
+  if [[ -z "$modified_files" ]]; then
+    record_result "file_size" "SKIP" "No modified files"
+    record_result_plain "file_size" "SKIP" "No modified files"
+    return
+  fi
+
+  local oversized=0
+  local details=""
+  while IFS= read -r file; do
+    [[ -z "$file" ]] && continue
+    [[ ! -f "${dir}/${file}" ]] && continue
+    if ! echo "$file" | grep -qE "\.(ts|tsx|js|jsx|py|rs|go|swift|kt|java)$"; then
+      continue
+    fi
+    local lines
+    lines=$(wc -l < "${dir}/${file}" | tr -d ' ')
+    if [[ $lines -gt $max_lines ]]; then
+      oversized=$((oversized + 1))
+      details="${details}${file}(${lines}L) "
+    fi
+  done <<< "$modified_files"
+
+  if [[ $oversized -eq 0 ]]; then
+    record_result "file_size" "PASS" "All files under ${max_lines} lines"
+    record_result_plain "file_size" "PASS" "All files under ${max_lines} lines"
+  else
+    record_result "file_size" "FAIL" "${oversized} files over ${max_lines}L: ${details}"
+    record_result_plain "file_size" "FAIL" "${oversized} files over ${max_lines}L: ${details}"
+  fi
+}
+
+# ── Custom check runner ──────────────────────────────────────────────
+
+run_custom_check() {
+  local dir="$1" id="$2" cmd="$3" description="${4:-Custom check}"
+
+  if (cd "$dir" && eval "$cmd" > /dev/null 2>&1); then
+    record_result "$id" "PASS" "$description"
+    record_result_plain "$id" "PASS" "$description"
+  else
+    record_result "$id" "FAIL" "$description"
+    record_result_plain "$id" "FAIL" "$description"
+  fi
+}
+
+run_custom_grep_check() {
+  local dir="$1" id="$2" pattern="$3" glob="$4" should_find="${5:-false}"
+
+  local count
+  count=$(find "$dir" -name "$glob" -not -path '*/node_modules/*' -not -path '*/.git/*' -exec grep -l "$pattern" {} \; 2>/dev/null | wc -l | tr -d ' ')
+
+  if [[ "$should_find" == "true" ]]; then
+    if [[ $count -gt 0 ]]; then
+      record_result "$id" "PASS" "Pattern found in ${count} files"
+      record_result_plain "$id" "PASS" "Pattern found in ${count} files"
+    else
+      record_result "$id" "FAIL" "Expected pattern not found"
+      record_result_plain "$id" "FAIL" "Expected pattern not found"
+    fi
+  else
+    if [[ $count -eq 0 ]]; then
+      record_result "$id" "PASS" "Pattern not found (good)"
+      record_result_plain "$id" "PASS" "Pattern not found (good)"
+    else
+      record_result "$id" "FAIL" "Unwanted pattern in ${count} files"
+      record_result_plain "$id" "FAIL" "Unwanted pattern in ${count} files"
+    fi
+  fi
+}

package/scripts/pre_gate_runner.sh

@@ -0,0 +1,176 @@
+#!/usr/bin/env bash
+# pre_gate_runner.sh — Runs pre-gate checks before QA or Architect agents
+# Usage: ./scripts/pre_gate_runner.sh <qa|arch> [worktree-path] [base-branch]
+#
+# Reads .bounce/gate-checks.json for check configuration.
+# If no config exists, runs universal defaults with auto-detected stack.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "${SCRIPT_DIR}/pre_gate_common.sh"
+
+# ── Arguments ────────────────────────────────────────────────────────
+
+GATE_TYPE="${1:-}"
+WORKTREE_PATH="${2:-.}"
+BASE_BRANCH="${3:-}"
+PLAIN_RESULTS=""
+
+if [[ -z "$GATE_TYPE" ]] || [[ "$GATE_TYPE" != "qa" && "$GATE_TYPE" != "arch" ]]; then
+  echo "Usage: ./scripts/pre_gate_runner.sh <qa|arch> [worktree-path] [base-branch]"
+  echo ""
+  echo "  qa    — Run QA pre-gate checks (before QA agent)"
+  echo "  arch  — Run Architect pre-gate checks (before Architect agent)"
+  echo ""
+  echo "  worktree-path  — Path to story worktree (default: current dir)"
+  echo "  base-branch    — Branch to diff against (default: auto-detect)"
+  exit 1
+fi
+
+# Resolve to absolute path
+WORKTREE_PATH="$(cd "$WORKTREE_PATH" && pwd)"
+
+echo -e "${CYAN}V-Bounce OS Pre-Gate Scanner${NC}"
+echo -e "Gate: ${YELLOW}${GATE_TYPE}${NC}"
+echo -e "Target: ${WORKTREE_PATH}"
+echo ""
+
+# ── Auto-detect base branch if not provided ──────────────────────────
+
+if [[ -z "$BASE_BRANCH" ]]; then
+  cd "$WORKTREE_PATH"
+  # Try to find the sprint branch this story branched from
+  BASE_BRANCH=$(git log --oneline --merges -1 --format=%H 2>/dev/null || echo "")
+  if [[ -z "$BASE_BRANCH" ]]; then
+    # Fall back to parent branch detection
+    BASE_BRANCH=$(git rev-parse --abbrev-ref HEAD@{upstream} 2>/dev/null || echo "")
+  fi
+fi
+
+# ── Load config or use defaults ──────────────────────────────────────
+
+CONFIG_PATH="${WORKTREE_PATH}/.bounce/gate-checks.json"
+HAS_CONFIG=false
+
+if [[ -f "$CONFIG_PATH" ]]; then
+  HAS_CONFIG=true
+  echo -e "Config: ${GREEN}${CONFIG_PATH}${NC}"
+else
+  # Check parent repo too (worktree might not have it)
+  REPO_ROOT=$(cd "$WORKTREE_PATH" && git rev-parse --show-toplevel 2>/dev/null || echo "$WORKTREE_PATH")
+  CONFIG_PATH="${REPO_ROOT}/.bounce/gate-checks.json"
+  if [[ -f "$CONFIG_PATH" ]]; then
+    HAS_CONFIG=true
+    echo -e "Config: ${GREEN}${CONFIG_PATH}${NC}"
+  else
+    echo -e "Config: ${YELLOW}None found — using universal defaults${NC}"
+  fi
+fi
+
+echo ""
+
+# ── Get modified files ───────────────────────────────────────────────
+
+MODIFIED_FILES=$(get_modified_files "$WORKTREE_PATH" "$BASE_BRANCH")
+
+# ── Run checks ───────────────────────────────────────────────────────
+
+run_checks_from_config() {
+  local gate="$1"
+  local checks_key="${gate}_checks"
+
+  # Parse config with node (available since V-Bounce requires it)
+  local check_ids
+  check_ids=$(node -e "
+    const fs = require('fs');
+    const cfg = JSON.parse(fs.readFileSync('${CONFIG_PATH}', 'utf8'));
+    const checks = cfg['${checks_key}'] || [];
+    checks.filter(c => c.enabled !== false).forEach(c => {
+      console.log(JSON.stringify(c));
+    });
+  " 2>/dev/null)
+
+  while IFS= read -r check_json; do
+    [[ -z "$check_json" ]] && continue
+
+    local id cmd pattern glob should_find max_lines description
+    id=$(echo "$check_json" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(d.id||'')" 2>/dev/null)
+    cmd=$(echo "$check_json" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(d.cmd||'')" 2>/dev/null)
+    pattern=$(echo "$check_json" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(d.pattern||'')" 2>/dev/null)
+    glob=$(echo "$check_json" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(d.glob||'')" 2>/dev/null)
+    should_find=$(echo "$check_json" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(d.should_find||'false')" 2>/dev/null)
+    max_lines=$(echo "$check_json" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(d.max_lines||'500')" 2>/dev/null)
+    description=$(echo "$check_json" | node -e "const d=JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));console.log(d.description||d.id||'')" 2>/dev/null)
+
+    case "$id" in
+      tests_exist)       check_tests_exist "$WORKTREE_PATH" "$MODIFIED_FILES" ;;
+      tests_pass)        check_tests_pass "$WORKTREE_PATH" ;;
+      build)             check_build "$WORKTREE_PATH" ;;
+      lint)              check_lint "$WORKTREE_PATH" ;;
+      no_debug_output)   check_no_debug_output "$WORKTREE_PATH" "$MODIFIED_FILES" ;;
+      no_todo_fixme)     check_no_todo_fixme "$WORKTREE_PATH" "$MODIFIED_FILES" ;;
+      exports_have_docs) check_exports_have_docs "$WORKTREE_PATH" "$MODIFIED_FILES" ;;
+      no_new_deps)       check_no_new_dependencies "$WORKTREE_PATH" "$BASE_BRANCH" ;;
+      file_size)         check_file_size_limit "$WORKTREE_PATH" "$MODIFIED_FILES" "$max_lines" ;;
+      custom_cmd)        run_custom_check "$WORKTREE_PATH" "$description" "$cmd" "$description" ;;
+      custom_grep)       run_custom_grep_check "$WORKTREE_PATH" "$description" "$pattern" "$glob" "$should_find" ;;
+      *)
+        # Unknown built-in — try as custom command if cmd is provided
+        if [[ -n "$cmd" ]]; then
+          run_custom_check "$WORKTREE_PATH" "$id" "$cmd" "$description"
+        else
+          record_result "$id" "SKIP" "Unknown check type"
+          record_result_plain "$id" "SKIP" "Unknown check type"
+        fi
+        ;;
+    esac
+  done <<< "$check_ids"
+}
+
+run_universal_defaults() {
+  local gate="$1"
+
+  # QA-level checks (always run)
+  check_tests_exist "$WORKTREE_PATH" "$MODIFIED_FILES"
+  check_tests_pass "$WORKTREE_PATH"
+  check_build "$WORKTREE_PATH"
+  check_lint "$WORKTREE_PATH"
+  check_no_debug_output "$WORKTREE_PATH" "$MODIFIED_FILES"
+  check_no_todo_fixme "$WORKTREE_PATH" "$MODIFIED_FILES"
+  check_exports_have_docs "$WORKTREE_PATH" "$MODIFIED_FILES"
+
+  # Architect-level checks (only for arch gate)
+  if [[ "$gate" == "arch" ]]; then
+    check_no_new_dependencies "$WORKTREE_PATH" "$BASE_BRANCH"
+    check_file_size_limit "$WORKTREE_PATH" "$MODIFIED_FILES" 500
+  fi
+}
+
+# ── Execute ──────────────────────────────────────────────────────────
+
+if [[ "$HAS_CONFIG" == "true" ]]; then
+  run_checks_from_config "$GATE_TYPE"
+else
+  run_universal_defaults "$GATE_TYPE"
+fi
+
+# ── Output ───────────────────────────────────────────────────────────
+
+print_summary
+
+# Write report
+REPORT_DIR="${WORKTREE_PATH}/.bounce/reports"
+REPORT_FILE="${REPORT_DIR}/pre-${GATE_TYPE}-scan.txt"
+write_report "$REPORT_FILE"
+echo ""
+echo -e "Report: ${CYAN}${REPORT_FILE}${NC}"
+
+# Exit code
+if [[ $FAIL_COUNT -gt 0 ]]; then
+  echo -e "\n${RED}Gate check failed with ${FAIL_COUNT} failure(s).${NC}"
+  exit 1
+else
+  echo -e "\n${GREEN}All checks passed.${NC}"
+  exit 0
+fi

package/skills/agent-team/SKILL.md

@@ -201,20 +201,24 @@ Examples:
    e. DevOps runs `hotfix_manager.sh sync` to update any active story worktrees.
    f. Update Delivery Plan Status to "Done".
 
-6. **Parallel Readiness Check** (before bouncing multiple stories simultaneously):
+6. **Gate Config Check**:
+   - If `.bounce/gate-checks.json` does not exist, run `./scripts/init_gate_config.sh` to auto-detect the project stack and generate default gate checks.
+   - If it exists, verify it's current (stack detection may have changed).
+
+7. **Parallel Readiness Check** (before bouncing multiple stories simultaneously):
    - Verify test runner config excludes `.worktrees/` (vitest, jest, pytest, etc.)
    - Verify no shared mutable state between worktrees (e.g., shared temp files, singletons writing to same path)
    - Verify `.gitignore` includes `.worktrees/`
    If any check fails, fix before spawning parallel stories. Intermittent test failures from worktree cross-contamination erode trust in the test suite fast.
 
-7. **Dependency Check & Execution Mode**:
+8. **Dependency Check & Execution Mode**:
    - For each story, check the `Depends On:` field in its template.
    - If Story B depends on Story A, you MUST execute them sequentially. Do not create Story B's worktree or spawn its Developer until Story A has successfully passed the DevOps merge step.
    - Determine Execution Mode:
      - **Full Bounce (Default)**: Normal L2-L4 stories go through full Dev → QA → Architect → DevOps flow.
      - **Fast Track (L1/L2 Minor)**: For cosmetic UI tweaks or isolated refactors, execute Dev → DevOps only. Skip QA and Architect loops to save overhead. Validate manually during Sprint Review.
      
-8. Update sprint-{XX}.md: Status → "Active"
+9. Update sprint-{XX}.md: Status → "Active"
 ```
 
 ### Step 1: Story Initialization
@@ -245,11 +249,18 @@ mkdir -p .worktrees/STORY-{ID}-{StoryName}/.bounce/{tasks,reports}
 
 ### Step 3: QA Pass
 ```
+0. Run pre-QA gate scan:
+   ./scripts/pre_gate_runner.sh qa .worktrees/STORY-{ID}-{StoryName}/ sprint/S-{XX}
+   - If scan FAILS on trivial issues (debug statements, missing JSDoc, TODOs):
+     Return to Developer for quick fix. Do NOT spawn QA for mechanical failures.
+   - If scan PASSES: Include scan output path in the QA task file.
 1. Spawn qa subagent in .worktrees/STORY-{ID}-{StoryName}/ with:
    - Developer Implementation Report
+   - Pre-QA scan results (.bounce/reports/pre-qa-scan.txt)
    - Story §2 The Truth (acceptance criteria)
    - LESSONS.md
 2. QA validates against Gherkin scenarios, runs vibe-code-review
+   (skipping checks already covered by pre-qa-scan.txt)
 3. If FAIL:
    - QA writes Bug Report (STORY-{ID}-{StoryName}-qa-bounce{N}.md)
    - Increment bounce counter
@@ -262,8 +273,14 @@ mkdir -p .worktrees/STORY-{ID}-{StoryName}/.bounce/{tasks,reports}
 
 ### Step 4: Architect Pass
 ```
+0. Run pre-Architect gate scan:
+   ./scripts/pre_gate_runner.sh arch .worktrees/STORY-{ID}-{StoryName}/ sprint/S-{XX}
+   - If scan reveals new dependencies or structural violations:
+     Return to Developer for resolution. Do NOT spawn Architect for mechanical failures.
+   - If scan PASSES: Include scan output path in the Architect task file.
 1. Spawn architect subagent in .worktrees/STORY-{ID}-{StoryName}/ with:
    - All reports for this story
+   - Pre-Architect scan results (.bounce/reports/pre-arch-scan.txt)
    - Full Story spec + Roadmap §3 ADRs
    - LESSONS.md
 2. If FAIL:
@@ -286,7 +303,7 @@ mkdir -p .worktrees/STORY-{ID}-{StoryName}/.bounce/{tasks,reports}
    - Pre-merge checks (worktree clean, gate reports verified)
    - Archive reports to .bounce/archive/S-{XX}/STORY-{ID}-{StoryName}/
    - Merge story branch into sprint branch (--no-ff)
-   - Post-merge validation (tests + build on sprint branch)
+   - Post-merge validation (tests + lint + build on sprint branch)
    - Worktree removal and story branch cleanup
 3. DevOps writes Merge Report to .bounce/archive/S-{XX}/STORY-{ID}-{StoryName}/STORY-{ID}-{StoryName}-devops.md
 4. If merge conflicts:

package/skills/improve/SKILL.md

@@ -107,6 +107,32 @@ For script changes, describe the new behavior.}
 **Reversibility:** {Easy — revert the edit / Medium — downstream docs may need updating}
 ```
 
+#### Special Case: Gate Check Proposals
+
+When agent feedback reveals a mechanical check that was repeated manually across multiple stories (e.g., "QA checked for inline styles 4 times"), propose adding it as a pre-gate check instead of a skill/template change:
+
+```markdown
+### Proposal {N}: Add pre-gate check — {check name}
+
+**Finding:** {Agent} manually performed {check description} in {N} stories this sprint.
+**Tokens saved:** ~{estimate} per story (based on agent token usage for this check type)
+**Gate:** qa / arch
+**Check config to add to `.bounce/gate-checks.json`:**
+```json
+{
+  "id": "custom_grep",
+  "gate": "arch",
+  "enabled": true,
+  "pattern": "{regex}",
+  "glob": "{file pattern}",
+  "should_find": false,
+  "description": "{human-readable description}"
+}
+```
+```
+
+This is the primary mechanism for the gate system to grow organically — the `improve` skill reads what agents repeatedly checked by hand and proposes automating those checks via `gate-checks.json`.
+
 ### Step 5: Present to Human
 Present ALL proposals as a numbered list. The human can:
 - **Approve** — apply the change