@drafthq/draft 2.7.0

package/scripts/tools/check-track-hygiene.sh

@@ -0,0 +1,230 @@
+#!/usr/bin/env bash
+# check-track-hygiene.sh
+#
+# Hygiene validator for Draft tracks. Enforces WS-1 contract from
+# core/shared/template-hygiene.md. Generic across any project, any track,
+# any domain.
+#
+# Checks per track:
+# 1. Status parity: metadata.json:status vs Markdown "Status:" lines.
+# 2. Author resolution: no Author1 / xxx@*.com / [name] placeholders.
+# 3. Approver placeholders: no empty cells in Approval-bearing tables.
+# 4. TBD budget: per-doc cap depends on metadata.json:status.
+# 5. Plan staleness (WS-6 chain): plan.md generated_at not older than HLD/LLD.
+#
+# Usage:
+# scripts/tools/check-track-hygiene.sh # scan all ./tracks/*
+# scripts/tools/check-track-hygiene.sh tracks/foo # scan one
+# scripts/tools/check-track-hygiene.sh --json ... # JSON output
+#
+# Exit codes:
+# 0 clean
+# 1 hygiene violation
+# 2 usage / runtime error
+
+set -euo pipefail
+
+if [ "${1:-}" = "--help" ] || [ "${1:-}" = "-h" ]; then
+    echo "${0##*/} — Foundations quality tool (see core/ docs for full behavior)"
+    exit 0
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=/dev/null
+source "$SCRIPT_DIR/_lib.sh"
+
+REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+
+EMIT_JSON=0
+TRACK_PATHS=()
+
+usage() {
+    local stream=2 code=2
+    if [[ "${USAGE_HELP_MODE:-0}" == 1 ]]; then stream=1; code=0; fi
+    sed -n '2,21p' "$0" >&$stream
+    exit "$code"
+}
+
+while (($#)); do
+    case "$1" in
+        -h|--help) USAGE_HELP_MODE=1 usage ;;
+        --json) EMIT_JSON=1; shift ;;
+        -*) printf 'Unknown flag: %s\n' "$1" >&2; usage ;;
+        *) TRACK_PATHS+=("$1"); shift ;;
+    esac
+done
+
+if ((${#TRACK_PATHS[@]} == 0)); then
+    while IFS= read -r p; do TRACK_PATHS+=("$p"); done < <(discover_track_dirs "$REPO_ROOT")
+fi
+
+# Patterns
+# Note: use `(example)?` rather than an empty alternation branch `(|example)` —
+# strict ERE engines (BSD grep, ugrep) reject empty branches as a regex error.
+FORBIDDEN_AUTHOR_RE='Author[0-9]+|xxx@(example)?\.(com|org)|\[name\]'
+EMPTY_APPROVAL_ROW_RE='^\|[^|]*\|[[:space:]]*\|[[:space:]]*\|[[:space:]]*\|[[:space:]]*\|[[:space:]]*$'
+TBD_RE='_TBD_[A-Za-z0-9_]+_'
+
+violation_count=0
+declare -a violations=()
+
+record() {
+    local track="$1" kind="$2" file="$3" line="$4" detail="$5"
+    violations+=("$track|$kind|$file|$line|$detail")
+    violation_count=$((violation_count + 1))
+}
+
+scan_one_track() {
+    local track_dir="$1"
+    local rel_track="${track_dir#"$REPO_ROOT/"}"
+    local meta="$track_dir/metadata.json"
+
+    local meta_status="draft"
+    if [[ -f "$meta" ]]; then
+        local s
+        s="$(read_json_str "$meta" "status")"
+        [[ -n "$s" ]] && meta_status="$s"
+    fi
+
+    # 1. Status parity: search for "Status:" lines in markdown.
+    while IFS= read -r f; do
+        local rel_file="${f#"$track_dir/"}"
+        local n=0
+        while IFS= read -r line; do
+            n=$((n + 1))
+            case "$line" in
+                Status:*|*"**Status:**"*|*"Status: [x] Complete"*)
+                    # Heuristic: if metadata says draft but doc says Complete, mismatch.
+                    if [[ "$meta_status" != "completed" ]] && [[ "$line" == *'[x] Complete'* ]]; then
+                        record "$rel_track" "status-mismatch" "$rel_file" "$n" \
+                            "metadata.status=$meta_status, doc says Complete"
+                    fi
+                    ;;
+            esac
+        done < "$f"
+    done < <(find "$track_dir" -maxdepth 1 -type f -name '*.md')
+
+    # 2. Forbidden author placeholders.
+    while IFS= read -r f; do
+        local rel_file="${f#"$track_dir/"}"
+        while IFS= read -r match; do
+            local n
+            n="${match%%:*}"
+            local rest="${match#*:}"
+            record "$rel_track" "forbidden-author" "$rel_file" "$n" "$rest"
+        done < <(grep -nE "$FORBIDDEN_AUTHOR_RE" "$f" 2>/dev/null || true)
+    done < <(find "$track_dir" -maxdepth 1 -type f -name '*.md')
+
+    # 3. Approval-bearing tables: detect empty cells.
+    while IFS= read -r f; do
+        local rel_file="${f#"$track_dir/"}"
+        local in_table=0
+        local n=0
+        while IFS= read -r line; do
+            n=$((n + 1))
+            # Detect a markdown table header starting with | Role |
+            if echo "$line" | grep -qiE '^\|[[:space:]]*role[[:space:]]*\|'; then
+                in_table=1
+                continue
+            fi
+            # Detect end of table: blank line.
+            if ((in_table)) && [[ -z "$line" ]]; then
+                in_table=0
+                continue
+            fi
+            if ((in_table)) && [[ "$line" =~ $EMPTY_APPROVAL_ROW_RE ]]; then
+                record "$rel_track" "empty-approver" "$rel_file" "$n" "$line"
+            fi
+        done < "$f"
+    done < <(find "$track_dir" -maxdepth 1 -type f -name '*.md')
+
+    # 4. TBD budget per-doc.
+    case "$meta_status" in
+        draft|archived) ;;
+        ready-for-review|in_progress)
+            local tbd_cap=3
+            while IFS= read -r f; do
+                local rel_file="${f#"$track_dir/"}"
+                local count
+                count="$(grep -oE "$TBD_RE" "$f" 2>/dev/null | wc -l | tr -d ' ')"
+                if (( count > tbd_cap )); then
+                    record "$rel_track" "tbd-over-cap" "$rel_file" "0" \
+                        "$count TBD sentinel(s) (cap $tbd_cap at status=$meta_status)"
+                fi
+            done < <(find "$track_dir" -maxdepth 1 -type f -name '*.md')
+            ;;
+        completed)
+            while IFS= read -r f; do
+                local rel_file="${f#"$track_dir/"}"
+                local count
+                count="$(grep -oE "$TBD_RE" "$f" 2>/dev/null | wc -l | tr -d ' ')"
+                if (( count > 0 )); then
+                    record "$rel_track" "tbd-in-completed" "$rel_file" "0" \
+                        "$count TBD sentinel(s) at status=completed"
+                fi
+            done < <(find "$track_dir" -maxdepth 1 -type f -name '*.md')
+            ;;
+    esac
+
+    # 5. Plan staleness vs HLD/LLD (WS-6).
+    if [[ -f "$track_dir/plan.md" ]]; then
+        local plan_ts hld_ts lld_ts
+        plan_ts="$(get_yaml_field "$track_dir/plan.md" "generated_at" || true)"
+        [[ -f "$track_dir/hld.md" ]] && hld_ts="$(get_yaml_field "$track_dir/hld.md" "generated_at" || true)"
+        [[ -f "$track_dir/lld.md" ]] && lld_ts="$(get_yaml_field "$track_dir/lld.md" "generated_at" || true)"
+        for sib_ts_pair in "hld.md|$hld_ts" "lld.md|$lld_ts"; do
+            local sib="${sib_ts_pair%%|*}"
+            local sib_ts="${sib_ts_pair#*|}"
+            [[ -z "$sib_ts" || -z "$plan_ts" ]] && continue
+            # Lexicographic compare works on ISO-8601 strings.
+            if [[ "$plan_ts" < "$sib_ts" ]]; then
+                record "$rel_track" "stale-plan" "plan.md" "0" \
+                    "plan.md generated_at=$plan_ts older than $sib generated_at=$sib_ts"
+            fi
+        done
+    fi
+}
+
+# Self-check: git identity must be set.
+if ! git config user.name >/dev/null 2>&1 || ! git config user.email >/dev/null 2>&1; then
+    printf 'check-track-hygiene: WARNING — git user.name/user.email not configured.\n' >&2
+fi
+
+for t in "${TRACK_PATHS[@]}"; do
+    [[ -d "$t" ]] || { record "$t" "not-a-directory" "" "0" ""; continue; }
+    scan_one_track "$(cd "$t" && pwd)"
+done
+
+emit() {
+    if ((EMIT_JSON)); then
+        printf '{"violation_count": %d, "violations": [\n' "$violation_count"
+        local first=1 v track kind file line detail
+        # Guard the expansion: "${arr[@]}" on an empty array is an unbound-variable
+        # error under `set -u` in bash <= 4.3 (e.g. macOS).
+        if ((violation_count > 0)); then
+            for v in "${violations[@]}"; do
+                IFS='|' read -r track kind file line detail <<< "$v"
+                if ((first)); then first=0; else printf ',\n'; fi
+                printf ' {"track":"%s","kind":"%s","file":"%s","line":%s,"detail":"%s"}' \
+                    "$(json_escape "$track")" "$(json_escape "$kind")" \
+                    "$(json_escape "$file")" "${line:-0}" "$(json_escape "$detail")"
+            done
+        fi
+        printf '\n]}\n'
+    else
+        if ((violation_count == 0)); then
+            printf 'OK: clean across %d track(s).\n' "${#TRACK_PATHS[@]}"
+        else
+            printf 'HYGIENE: %d violation(s) across %d track(s).\n' \
+                "$violation_count" "${#TRACK_PATHS[@]}" >&2
+            local v track kind file line detail
+            for v in "${violations[@]}"; do
+                IFS='|' read -r track kind file line detail <<< "$v"
+                printf ' [%s] %s/%s:%s — %s\n' "$kind" "$track" "$file" "$line" "$detail" >&2
+            done
+        fi
+    fi
+}
+emit
+
+((violation_count == 0))

package/scripts/tools/classify-files.sh

@@ -0,0 +1,231 @@
+#!/usr/bin/env bash
+# classify-files.sh — deterministic file classification for a repo.
+#
+# Walks --root (default: cwd) respecting common ignore globs, emits one JSON
+# object per line (JSONL) with language, category, test/generated flags,
+# LOC, and top-level module.
+#
+# Usage:
+# scripts/tools/classify-files.sh [--root DIR] [--json]
+#
+# Output fields: path, lang, category, is_test, is_generated, loc, module
+# Exit codes: 0 OK (with or without results), 1 invocation error.
+set -euo pipefail
+
+# shellcheck source=_lib.sh
+source "$(dirname "${BASH_SOURCE[0]}")/_lib.sh"
+
+ROOT="."
+FORMAT="jsonl"
+
+usage() {
+    cat <<'EOF'
+classify-files.sh — deterministic file classification (JSONL).
+
+Usage:
+  scripts/tools/classify-files.sh [--root DIR] [--json]
+
+Flags:
+  --root DIR Root directory to scan (default: cwd).
+  --json Emit a single JSON array instead of JSONL.
+  --help Show this help.
+
+Output (per file): {path, lang, category, is_test, is_generated, loc, module}
+
+Language is inferred from extension and shebang. A file is classified as a
+test when its path or basename matches common test patterns. It is flagged
+generated when the first 5 lines contain "Code generated" or "DO NOT EDIT".
+Module is the first path segment under root.
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --root) ROOT="$2"; shift 2;;
+        --json) FORMAT="json"; shift;;
+        --jsonl) FORMAT="jsonl"; shift;;
+        --help|-h) usage; exit 0;;
+        *) echo "Unknown flag: $1" >&2; usage >&2; exit 1;;
+    esac
+done
+
+if [[ ! -d "$ROOT" ]]; then
+    echo "ERROR: --root '$ROOT' is not a directory" >&2
+    exit 1
+fi
+
+# Exclusions: common generated/vendor directories.
+EXCLUDE_DIRS=(
+    .git node_modules dist build out .next .venv venv __pycache__
+    target vendor third_party .mypy_cache .pytest_cache coverage
+    .cache .tox .gradle .idea .vscode
+)
+
+lang_for() {
+    local path="$1"
+    local base; base="$(basename "$path")"
+    local ext="${base##*.}"
+    [[ "$ext" == "$base" ]] && ext=""
+
+    case "$ext" in
+        py) echo "python";;
+        js|mjs|cjs) echo "javascript";;
+        ts|tsx) echo "typescript";;
+        jsx) echo "javascript";;
+        go) echo "go";;
+        rs) echo "rust";;
+        java) echo "java";;
+        kt|kts) echo "kotlin";;
+        c|h) echo "c";;
+        cc|cpp|cxx|hpp|hh|hxx) echo "cpp";;
+        rb) echo "ruby";;
+        sh|bash) echo "bash";;
+        md|markdown) echo "markdown";;
+        yml|yaml) echo "yaml";;
+        json) echo "json";;
+        toml) echo "toml";;
+        proto) echo "proto";;
+        sql) echo "sql";;
+        html|htm) echo "html";;
+        css) echo "css";;
+        scss|sass) echo "sass";;
+        lua) echo "lua";;
+        php) echo "php";;
+        cs) echo "csharp";;
+        swift) echo "swift";;
+        *)
+            # shebang-based detection for extensionless scripts
+            if [[ -f "$path" ]] && head -1 "$path" 2>/dev/null | grep -qE '^#!'; then
+                local shebang
+                shebang="$(head -1 "$path")"
+                case "$shebang" in
+                    *bash*|*zsh*|*/sh*) echo "bash";;
+                    *python*) echo "python";;
+                    *node*) echo "javascript";;
+                    *ruby*) echo "ruby";;
+                    *) echo "other";;
+                esac
+            else
+                echo "other"
+            fi
+            ;;
+    esac
+}
+
+is_test_file() {
+    local path="$1"
+    local base; base="$(basename "$path")"
+
+    # Path segment
+    case "/$path/" in
+        */tests/*|*/test/*|*/__tests__/*|*/spec/*|*/specs/*) echo "true"; return;;
+    esac
+
+    # Filename patterns
+    case "$base" in
+        test_*.py|*_test.py|tests.py|conftest.py) echo "true"; return;;
+        *_test.go) echo "true"; return;;
+        *.test.ts|*.test.tsx|*.test.js|*.test.jsx) echo "true"; return;;
+        *.spec.ts|*.spec.tsx|*.spec.js|*.spec.jsx) echo "true"; return;;
+        *Test.java|*Tests.java|*Spec.java) echo "true"; return;;
+        test-*.sh|*-test.sh|*_test.sh) echo "true"; return;;
+    esac
+
+    echo "false"
+}
+
+is_generated() {
+    local path="$1"
+    [[ -f "$path" ]] || { echo "false"; return; }
+    if head -5 "$path" 2>/dev/null | grep -qE 'Code generated|DO NOT EDIT|@generated|autogenerated'; then
+        echo "true"
+    else
+        echo "false"
+    fi
+}
+
+module_for() {
+    local rel="$1"
+    local first="${rel%%/*}"
+    if [[ "$first" == "$rel" ]]; then
+        echo "."
+    else
+        echo "$first"
+    fi
+}
+
+# Build find with prunes for excluded dirs. Use absolute root so emitted paths are absolute.
+ROOT_REAL="$(cd "$ROOT" && pwd)"
+FIND_ARGS=("$ROOT_REAL" -type d \( )
+first_dir=true
+for dir in "${EXCLUDE_DIRS[@]}"; do
+    if $first_dir; then
+        FIND_ARGS+=(-name "$dir")
+        first_dir=false
+    else
+        FIND_ARGS+=(-o -name "$dir")
+    fi
+done
+FIND_ARGS+=(\) -prune -o -type f -print)
+
+first_record=true
+
+emit_record() {
+    local json="$1"
+    if [[ "$FORMAT" == "json" ]]; then
+        if $first_record; then
+            printf '[\n %s' "$json"
+            first_record=false
+        else
+            printf ',\n %s' "$json"
+        fi
+    else
+        printf '%s\n' "$json"
+    fi
+}
+
+while IFS= read -r file; do
+    # `find -type f` guarantees the entry is a regular file; no re-check needed.
+    # `find` run on an absolute ROOT emits absolute paths — strip the prefix.
+    rel="${file#"$ROOT_REAL/"}"
+    case "$rel" in
+        .git/*) continue;;
+    esac
+
+    lang="$(lang_for "$file")"
+    is_test="$(is_test_file "$rel")"
+    gen="$(is_generated "$file")"
+    module="$(module_for "$rel")"
+
+    loc="$(wc -l <"$file" 2>/dev/null | tr -d ' ' || echo 0)"
+
+    # Category: test > generated > source > config/docs
+    if [[ "$is_test" == "true" ]]; then
+        category="test"
+    elif [[ "$gen" == "true" ]]; then
+        category="generated"
+    else
+        case "$lang" in
+            markdown|yaml|json|toml) category="docs";;
+            *) category="source";;
+        esac
+    fi
+
+    record=$(printf '{"path":"%s","lang":"%s","category":"%s","is_test":%s,"is_generated":%s,"loc":%s,"module":"%s"}' \
+        "$(json_escape "$rel")" \
+        "$(json_escape "$lang")" \
+        "$(json_escape "$category")" \
+        "$is_test" \
+        "$gen" \
+        "$loc" \
+        "$(json_escape "$module")")
+    emit_record "$record"
+done < <(find "${FIND_ARGS[@]}" 2>/dev/null | sort)
+
+if [[ "$FORMAT" == "json" ]]; then
+    if $first_record; then
+        printf '[]\n'
+    else
+        printf '\n]\n'
+    fi
+fi

package/scripts/tools/cycle-detect.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+# cycle-detect.sh — emit call cycles from the knowledge graph.
+#
+# Backed by the codebase-memory-mcp engine. Uses bounded, fixed-length CALLS
+# patterns via openCypher (this engine's dialect handles explicit patterns
+# reliably but not variable-length/aggregate queries). Detects 2- and 3-node
+# call cycles, which surface mutual recursion and tight coupling.
+#
+# Usage:
+#   scripts/tools/cycle-detect.sh [--repo DIR]
+#
+# Output: JSON {cycles:[[a,b],[a,b,c], ...], source}.
+#   source = "memory-graph" | "unavailable"
+#
+# Exit codes: 0 OK, 1 invocation error, 2 graph engine/data unavailable.
+set -euo pipefail
+
+# shellcheck source=_lib.sh
+source "$(dirname "${BASH_SOURCE[0]}")/_lib.sh"
+
+REPO="."
+
+usage() {
+    cat <<'EOF'
+cycle-detect.sh — call-cycle detection from the knowledge graph.
+
+Usage:
+  scripts/tools/cycle-detect.sh [--repo DIR]
+
+Flags:
+  --repo DIR  Repository root (default: cwd).
+  --help      Show this help.
+
+Output: JSON {cycles:[[a,b],[a,b,c]], source}. Fallback when the engine is
+unavailable: {"cycles":[],"source":"unavailable"}, exit 2.
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --repo) REPO="$2"; shift 2;;
+        --help|-h) usage; exit 0;;
+        *) echo "Unknown flag: $1" >&2; usage >&2; exit 1;;
+    esac
+done
+
+if [[ ! -d "$REPO" ]]; then
+    echo "ERROR: --repo '$REPO' is not a directory" >&2
+    exit 1
+fi
+
+REPO_ABS="$(cd "$REPO" && pwd)"
+SELF_REPO="$(cd "$(dirname "$0")/../.." && pwd)"
+
+unavailable() { echo '{"cycles":[],"source":"unavailable"}'; exit 2; }
+
+find_memory_bin "$REPO_ABS" "$SELF_REPO" || unavailable
+command -v jq >/dev/null 2>&1 || unavailable
+
+PROJECT="$(memory_ensure_index "$REPO_ABS" || true)"
+[[ -n "$PROJECT" ]] || unavailable
+
+# 2-cycles: a -> b -> a (dedup with a.qualified_name < b.qualified_name).
+Q2="MATCH (a:Function)-[:CALLS]->(b:Function)-[:CALLS]->(a) WHERE a.qualified_name < b.qualified_name RETURN a.qualified_name AS a, b.qualified_name AS b LIMIT 100"
+# 3-cycles: a -> b -> c -> a.
+Q3="MATCH (a:Function)-[:CALLS]->(b:Function)-[:CALLS]->(c:Function)-[:CALLS]->(a) RETURN a.qualified_name AS a, b.qualified_name AS b, c.qualified_name AS c LIMIT 100"
+
+R2="$(memory_cli query_graph "{\"project\":\"$PROJECT\",\"query\":\"$Q2\"}" || echo '{}')"
+R3="$(memory_cli query_graph "{\"project\":\"$PROJECT\",\"query\":\"$Q3\"}" || echo '{}')"
+
+jq -n --argjson r2 "${R2:-{\}}" --argjson r3 "${R3:-{\}}" '
+    {
+      cycles: (((($r2.rows) // []) + (($r3.rows) // []))),
+      source: "memory-graph"
+    }'

package/scripts/tools/detect-test-framework.sh

@@ -0,0 +1,135 @@
+#!/usr/bin/env bash
+# detect-test-framework.sh — detect test framework(s) used in a repo.
+#
+# Output: JSON {languages:[{language, framework, runner_command, test_globs, config_file}]}
+#
+# Detection rules (first match per language wins):
+# python → pytest (pytest.ini | pyproject.toml has "[tool.pytest.ini_options]")
+# | unittest (has tests but no pytest config)
+# go → go test (go.mod + any *_test.go)
+# javascript/typescript → vitest | jest | mocha (by package.json scripts / devDependencies)
+# rust → cargo test (Cargo.toml + tests/)
+# shell → plain bash (tests/ dir has test-*.sh)
+#
+# Usage:
+# scripts/tools/detect-test-framework.sh [--root DIR]
+#
+# Exit codes: 0 (always; empty languages array is valid output).
+set -euo pipefail
+
+# shellcheck source=_lib.sh
+source "$(dirname "${BASH_SOURCE[0]}")/_lib.sh"
+
+ROOT="."
+
+usage() {
+    cat <<'EOF'
+detect-test-framework.sh — detect language test frameworks.
+
+Usage:
+  scripts/tools/detect-test-framework.sh [--root DIR]
+
+Flags:
+  --root DIR Repository root (default: cwd).
+  --help Show this help.
+
+Output: JSON {languages:[{language, framework, runner_command, test_globs, config_file}]}
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --root) ROOT="$2"; shift 2;;
+        --help|-h) usage; exit 0;;
+        *) echo "Unknown flag: $1" >&2; usage >&2; exit 1;;
+    esac
+done
+
+if [[ ! -d "$ROOT" ]]; then
+    echo "ERROR: --root '$ROOT' is not a directory" >&2
+    exit 1
+fi
+
+cd "$ROOT"
+
+emit_lang() {
+    local language="$1" framework="$2" runner="$3" globs="$4" config="$5"
+    printf '{"language":"%s","framework":"%s","runner_command":"%s","test_globs":%s,"config_file":%s}' \
+        "$(json_escape "$language")" \
+        "$(json_escape "$framework")" \
+        "$(json_escape "$runner")" \
+        "$globs" \
+        "$([[ -z "$config" ]] && echo null || echo "\"$(json_escape "$config")\"")"
+}
+
+RESULTS=()
+
+# ── Python ──
+PY_CONFIG=""
+PY_FRAMEWORK=""
+if [[ -f pytest.ini ]]; then
+    PY_CONFIG="pytest.ini"; PY_FRAMEWORK="pytest"
+elif [[ -f pyproject.toml ]] && grep -q 'tool.pytest' pyproject.toml 2>/dev/null; then
+    PY_CONFIG="pyproject.toml"; PY_FRAMEWORK="pytest"
+elif [[ -f setup.cfg ]] && grep -qE '^\[tool:pytest\]' setup.cfg 2>/dev/null; then
+    PY_CONFIG="setup.cfg"; PY_FRAMEWORK="pytest"
+fi
+if [[ -z "$PY_FRAMEWORK" ]]; then
+    if find . -maxdepth 4 \( -name 'test_*.py' -o -name '*_test.py' \) \
+        -not -path './.git/*' -not -path './node_modules/*' -print -quit 2>/dev/null | grep -q .; then
+        PY_FRAMEWORK="unittest"
+    fi
+fi
+if [[ -n "$PY_FRAMEWORK" ]]; then
+    RESULTS+=("$(emit_lang "python" "$PY_FRAMEWORK" \
+        "$([[ "$PY_FRAMEWORK" == pytest ]] && echo 'pytest' || echo 'python -m unittest')" \
+        '["test_*.py","*_test.py"]' \
+        "$PY_CONFIG")")
+fi
+
+# ── Go ──
+if [[ -f go.mod ]]; then
+    if find . -maxdepth 6 -name '*_test.go' -not -path './vendor/*' -print -quit 2>/dev/null | grep -q .; then
+        RESULTS+=("$(emit_lang "go" "go test" "go test ./..." '["*_test.go"]' "go.mod")")
+    fi
+fi
+
+# ── JS/TS ── (single file read, match in-memory)
+if [[ -f package.json ]]; then
+    PKG_JSON="$(<package.json)"
+    JS_FRAMEWORK=""
+    if [[ "$PKG_JSON" == *'"vitest"'* ]]; then
+        JS_FRAMEWORK="vitest"
+    elif [[ "$PKG_JSON" == *'"jest"'* ]]; then
+        JS_FRAMEWORK="jest"
+    elif [[ "$PKG_JSON" == *'"mocha"'* ]]; then
+        JS_FRAMEWORK="mocha"
+    fi
+    if [[ -n "$JS_FRAMEWORK" ]]; then
+        RESULTS+=("$(emit_lang "javascript" "$JS_FRAMEWORK" \
+            "npm test" \
+            '["*.test.[jt]s","*.test.[jt]sx","*.spec.[jt]s","*.spec.[jt]sx"]' \
+            "package.json")")
+    fi
+fi
+
+# ── Rust ──
+if [[ -f Cargo.toml ]]; then
+    RESULTS+=("$(emit_lang "rust" "cargo test" "cargo test" '["tests/*.rs","src/**/*_test.rs"]' "Cargo.toml")")
+fi
+
+# ── Shell ──
+if find . -maxdepth 3 -type d -name tests -print -quit 2>/dev/null | grep -q .; then
+    if find tests -maxdepth 2 -name 'test-*.sh' -print -quit 2>/dev/null | grep -q .; then
+        RESULTS+=("$(emit_lang "shell" "bash" "./tests/run-all.sh" '["tests/test-*.sh"]' "")")
+    fi
+fi
+
+# Assemble
+printf '{"languages":['
+first=true
+for r in ${RESULTS[@]+"${RESULTS[@]}"}; do
+    if $first; then first=false; else printf ','; fi
+    printf '%s' "$r"
+done
+printf ']}\n'