test.sh

#!/usr/bin/env bash
# test.sh — Self-tests for quick-question repo
# Run: ./test.sh
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"

# Python compatibility (Windows Git Bash has python, not python3)
# Note: Windows Store has a python3 alias that exists but doesn't work,
# so we verify with --version, not just command -v.
QQ_PY="python3"
python3 --version >/dev/null 2>&1 || QQ_PY="python"
export QQ_PY

# Force core.autocrlf=false for all git operations in test fixtures so Windows
# checkouts don't appear "modified" relative to the index right after commit.
# Without this, the worktree closeout test sees its own committed files as dirty.
export GIT_CONFIG_PARAMETERS="'core.autocrlf=false'"

# OS detection — used to gate a small set of test fixtures that create fake
# bare-name executables (no .cmd / .exe extension) which Linux/macOS can run
# via shebang but Windows cannot exec via PATHEXT.
IS_WINDOWS=false
case "$(uname -s)" in
  MINGW*|MSYS*|CYGWIN*) IS_WINDOWS=true ;;
esac

PASS=0
FAIL=0
SKIP=0
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
CYAN='\033[0;36m'
NC='\033[0m'

pass() { PASS=$((PASS + 1)); echo -e "  ${GREEN}✓${NC} $1"; }
fail() { FAIL=$((FAIL + 1)); echo -e "  ${RED}✗${NC} $1"; }
skip() { SKIP=$((SKIP + 1)); echo -e "  ${YELLOW}∅${NC} $1 (skipped: $2)"; }

# ── 1. ShellCheck ──
echo -e "${CYAN}[1/10] ShellCheck${NC}"
if command -v shellcheck &>/dev/null; then
  SHELL_FILES=$(find "$SCRIPT_DIR/scripts" -name "*.sh" -not -type l)
  SHELL_FILES="$SHELL_FILES $SCRIPT_DIR/install.sh $SCRIPT_DIR/test.sh $SCRIPT_DIR/.devcontainer/postCreate.sh $SCRIPT_DIR/scripts/docker-dev.sh"
  SC_FAIL=0
  for f in $SHELL_FILES; do
    if shellcheck -S error "$f" >/dev/null 2>&1; then
      pass "$(basename "$f")"
    else
      fail "$(basename "$f")"
      shellcheck -S error "$f" 2>&1 | head -20
      SC_FAIL=1
    fi
  done
  [ "$SC_FAIL" -eq 0 ] || echo ""
else
  echo -e "  ${CYAN}shellcheck not installed — skipping (brew install shellcheck)${NC}"
fi

# ── 2. Python compilation ──
echo -e "${CYAN}[2/10] Python compilation${NC}"
PY_FILES=$(find "$SCRIPT_DIR/scripts" -name "*.py" -not -type l)
for py_file in $PY_FILES; do
  if $QQ_PY -m py_compile "$py_file" >/dev/null 2>&1; then
    pass "$(basename "$py_file")"
  else
    fail "$(basename "$py_file")"
  fi
done

# ── 3. JSON validity ──
echo -e "${CYAN}[3/10] JSON validity${NC}"
for json_file in scripts/qq-capabilities.json scripts/tykit_capabilities.json scripts/godot_capabilities.json scripts/unreal_capabilities.json scripts/sbox_capabilities.json hooks/hooks.json .claude-plugin/plugin.json .claude-plugin/marketplace.json docs/evals/foundation-smoke.json docs/evals/unity-local.json docs/evals/collaboration-multi-actor.json docs/evals/qq-bench-foundation.json docs/evals/qq-bench-core-v0.json docs/evals/qq-bench-core-v1.json docs/evals/qq-bench-core-solver-v0.json .devcontainer/devcontainer.json; do
  if [ -f "$SCRIPT_DIR/$json_file" ]; then
    if $QQ_PY -m json.tool "$SCRIPT_DIR/$json_file" >/dev/null 2>&1; then
      pass "$json_file"
    else
      fail "$json_file — invalid JSON"
    fi
  else
    fail "$json_file — file not found"
  fi
done

# ── 4. Structural checks ──
echo -e "${CYAN}[4/10] Structural checks${NC}"

# Every skill directory has a SKILL.md
SKILL_DIRS=$(find "$SCRIPT_DIR/skills" -mindepth 1 -maxdepth 1 -type d)
for dir in $SKILL_DIRS; do
  name=$(basename "$dir")
  if [ -f "$dir/SKILL.md" ]; then
    pass "skills/$name/SKILL.md exists"
  else
    fail "skills/$name/SKILL.md missing"
  fi
done

# Hook scripts referenced in hooks.json actually exist
HOOK_SCRIPTS=$(grep -oE 'scripts/[a-z/._-]+\.sh' "$SCRIPT_DIR/hooks/hooks.json" || true)
for script in $HOOK_SCRIPTS; do
  if [ -f "$SCRIPT_DIR/$script" ]; then
    pass "hooks.json → $script exists"
  else
    fail "hooks.json → $script NOT FOUND"
  fi
done

# Platform helper scripts exist
for pf in detect.sh macos.sh windows.sh; do
  if [ -f "$SCRIPT_DIR/scripts/platform/$pf" ]; then
    pass "scripts/platform/$pf exists"
  else
    fail "scripts/platform/$pf NOT FOUND"
  fi
done

# Dev container files exist
for dc in .devcontainer/devcontainer.json .devcontainer/Dockerfile .devcontainer/postCreate.sh docs/dev/developer-workflow.md docs/dev/containerization.md scripts/docker-dev.sh; do
  if [ -f "$SCRIPT_DIR/$dc" ]; then
    pass "$dc exists"
  else
    fail "$dc NOT FOUND"
  fi
done

# install.sh resolves hook/runtime modules instead of blindly copying the whole hooks tree
if grep -q 'hooks-auto-compile' "$SCRIPT_DIR/scripts/qq_internal_install.py" && grep -q 'qq_internal_install.py' "$SCRIPT_DIR/install.sh"; then
  pass "install.sh resolves hook modules through qq_internal_install.py"
else
  fail "install.sh missing modular hook install support"
fi

if grep -q 'updated existing dependency to tested release' "$SCRIPT_DIR/install.sh"; then
  pass "install.sh repins existing tykit dependency"
else
  fail "install.sh does not repin existing tykit dependency"
fi

# Symlinks in tykit Scripts~/ point to valid targets
TYKIT_SCRIPTS="$SCRIPT_DIR/packages/com.tyk.tykit/Scripts~"
if [ -d "$TYKIT_SCRIPTS" ]; then
  for link in "$TYKIT_SCRIPTS"/*.sh; do
    if [ -L "$link" ]; then
      if [ -e "$link" ]; then
        pass "symlink $(basename "$link") → valid"
      else
        fail "symlink $(basename "$link") → BROKEN"
      fi
    fi
  done
fi

# tykit command coverage ratchet — enforce that the uncovered command count
# does not grow. As new tests land in v1.17.x, lower TYKIT_MAX_UNCOVERED.
# Run `python scripts/qq-tykit-coverage.py` standalone for the full report.
TYKIT_MAX_UNCOVERED=78
if [ -d "$SCRIPT_DIR/packages/com.tyk.tykit/Editor/Commands" ]; then
  TYKIT_AUDIT_OUT=$("$QQ_PY" "$SCRIPT_DIR/scripts/qq-tykit-coverage.py" \
    --project "$SCRIPT_DIR" --max-uncovered "$TYKIT_MAX_UNCOVERED" 2>&1)
  TYKIT_AUDIT_EXIT=$?
  TYKIT_UNCOVERED=$(printf '%s\n' "$TYKIT_AUDIT_OUT" | grep -oE 'uncovered: [0-9]+' | head -1 | awk '{print $2}')
  if [ "$TYKIT_AUDIT_EXIT" -eq 0 ]; then
    pass "tykit command coverage: ${TYKIT_UNCOVERED:-?} uncovered (max ${TYKIT_MAX_UNCOVERED})"
  else
    fail "tykit command coverage ratchet exceeded — ${TYKIT_UNCOVERED:-?} uncovered > max ${TYKIT_MAX_UNCOVERED}"
    printf '%s\n' "$TYKIT_AUDIT_OUT" | sed 's/^/    /'
  fi
fi

# Root README Chinese-half drift check — docs/zh-CN/README.md is the canonical
# Chinese source; root README's Chinese half is auto-generated by
# qq-sync-readme-zh.py. Run `python scripts/qq-sync-readme-zh.py --write` to fix.
if [ -f "$SCRIPT_DIR/scripts/qq-sync-readme-zh.py" ] && [ -f "$SCRIPT_DIR/docs/zh-CN/README.md" ]; then
  if "$QQ_PY" "$SCRIPT_DIR/scripts/qq-sync-readme-zh.py" \
       --check --project "$SCRIPT_DIR" >/dev/null 2>&1; then
    pass "root README Chinese half in sync with docs/zh-CN/README.md"
  else
    fail "root README Chinese half drifts from docs/zh-CN/README.md (run: python scripts/qq-sync-readme-zh.py --write)"
  fi
fi

# ── 5. README consistency ──
echo -e "${CYAN}[5/10] README consistency${NC}"

ACTUAL_SKILL_COUNT=$(find "$SCRIPT_DIR/skills" -mindepth 1 -maxdepth 1 -type d | wc -l | tr -d ' ')
if grep -qE "${ACTUAL_SKILL_COUNT} (skill|slash|Slash)" "$SCRIPT_DIR/README.md"; then
  pass "README skill count ($ACTUAL_SKILL_COUNT) matches actual"
else
  fail "README skill count does not match actual ($ACTUAL_SKILL_COUNT skills)"
fi

for dir in $SKILL_DIRS; do
  name=$(basename "$dir")
  if grep -q "/qq:${name}" "$SCRIPT_DIR/README.md"; then
    pass "skill $name in README"
  else
    fail "skill $name NOT in README"
  fi
done

# 5b: skill count consistency across language READMEs (Chinese 个, Japanese 個, Korean 개)
for lang_readme in "$SCRIPT_DIR/docs/zh-CN/README.md" "$SCRIPT_DIR/docs/ja/README.md" "$SCRIPT_DIR/docs/ko/README.md"; do
  if [ -f "$lang_readme" ]; then
    rel_path="${lang_readme#"$SCRIPT_DIR/"}"
    if grep -qE "${ACTUAL_SKILL_COUNT} ?(skill|slash|个|個|개)" "$lang_readme"; then
      pass "$rel_path mentions $ACTUAL_SKILL_COUNT (skill count consistent)"
    else
      fail "$rel_path does NOT mention $ACTUAL_SKILL_COUNT (skill count drift)"
    fi
  fi
done

# 5c: README version badge matches plugin.json
PLUGIN_VERSION=$($QQ_PY -c "import json,sys; print(json.load(open(sys.argv[1]))['version'])" "$SCRIPT_DIR/.claude-plugin/plugin.json" 2>/dev/null || printf 'unknown')
if [ "$PLUGIN_VERSION" != "unknown" ] && grep -q "version-v${PLUGIN_VERSION}" "$SCRIPT_DIR/README.md"; then
  pass "README version badge matches plugin.json (v$PLUGIN_VERSION)"
else
  fail "README version badge does NOT match plugin.json (v$PLUGIN_VERSION)"
fi

# 5d: no legacy review-gate-{check,set,count,stop}.sh references in docs/ or templates/
LEGACY_GATE_FILES=$(grep -rEl 'review-gate-(check|set|count|stop)\.sh' "$SCRIPT_DIR/docs" "$SCRIPT_DIR/templates" 2>/dev/null || true)
if [ -z "$LEGACY_GATE_FILES" ]; then
  pass "no legacy review-gate-{check,set,count,stop}.sh refs in docs/ or templates/"
else
  fail "legacy review-gate-*.sh refs found in:"
  printf '    %s\n' $LEGACY_GATE_FILES
fi

# 5e: cross-doc link rot — verify every relative markdown link in tracked
# docs resolves to a file or directory that exists. Catches the class of
# drift where a doc gets renamed/moved without updating the things linking
# to it.
LINK_ROT_STATUS=0
LINK_ROT_OUTPUT="$($QQ_PY - "$SCRIPT_DIR" <<'PY' 2>&1
import re
import sys
from pathlib import Path

repo = Path(sys.argv[1])
# Inline markdown link: [text](url). Reference-style links and HTML <a> are
# intentionally out of scope — they're rare in this corpus and would add false
# positives. URL captures everything up to the next ')'.
link_re = re.compile(r'\[[^\]]*\]\(([^)\s]+)\)')
broken: list[str] = []

# Top-level docs at repo root.
candidates: list[Path] = []
for name in ('README.md', 'AGENTS.md', 'CLAUDE.md', 'CONTRIBUTING.md',
             'SECURITY.md', 'CODE_OF_CONDUCT.md', 'CHANGELOG.md'):
    p = repo / name
    if p.is_file():
        candidates.append(p)

# Recurse into docs/ and templates/, but skip:
#   - docs/superpowers/  — historical spec/plan files for completed work
#     that intentionally reference files since deleted (Context Capsule, etc.)
#   - docs/main/         — codex review log dumps with absolute paths
#   - any *_review.md    — review output dumps, not maintained docs
SKIPPED_PARTS = {'superpowers', 'main'}
for sub in ('docs', 'templates'):
    base = repo / sub
    if not base.is_dir():
        continue
    for path in base.rglob('*.md'):
        if any(part in SKIPPED_PARTS for part in path.parts):
            continue
        if path.name.endswith('_review.md'):
            continue
        candidates.append(path)

for path in candidates:
    try:
        text = path.read_text(encoding='utf-8')
    except (OSError, UnicodeDecodeError):
        continue
    in_fence = False
    fence_marker = chr(96) * 3  # avoid triple-backtick literal — bash $() parser
    for lineno, line in enumerate(text.splitlines(), 1):
        # Skip fenced code blocks (lines starting with three backticks).
        if line.lstrip().startswith(fence_marker):
            in_fence = not in_fence
            continue
        if in_fence:
            continue
        for m in link_re.finditer(line):
            url = m.group(1).strip()
            # Skip external URLs, in-page anchors, and non-file schemes.
            if url.startswith(('http://', 'https://', 'mailto:', 'ftp://',
                               'tel:', 'data:', 'javascript:', '#')):
                continue
            # Drop fragment / query — we only check the file part.
            url_path = url.split('#', 1)[0].split('?', 1)[0]
            if not url_path:
                continue
            target = (path.parent / url_path).resolve()
            if not target.exists():
                rel = path.relative_to(repo).as_posix()
                broken.append(f'{rel}:{lineno} -> {url}')

if broken:
    print('\n'.join(broken))
    sys.exit(1)
PY
)" || LINK_ROT_STATUS=$?
if [ "$LINK_ROT_STATUS" -eq 0 ]; then
  pass "no broken relative markdown links in tracked docs"
else
  BROKEN_COUNT=$(printf '%s' "$LINK_ROT_OUTPUT" | awk '/->/{c++} END{print c+0}')
  fail "broken relative markdown links found ($BROKEN_COUNT)"
  printf '%s\n' "$LINK_ROT_OUTPUT" | head -20 | sed 's/^/    /'
  if [ "$BROKEN_COUNT" -gt 20 ]; then
    printf '    ... %s more\n' "$((BROKEN_COUNT - 20))"
  fi
fi

# 5f: cross-language link discipline — when a doc inside docs/<lang>/ links
# to a sibling in another language (e.g. docs/zh-CN/foo.md -> ../en/bar.md),
# verify that docs/<lang>/bar.md does NOT exist. If it does, the link should
# have been to the same-language sibling. Catches the v1.16.22 class of bug
# where zh-CN README's tykit-mcp / tykit-api / worktrees links pointed to
# ../en/ even though docs/zh-CN/ had identical filenames.
CROSS_LANG_STATUS=0
CROSS_LANG_OUTPUT="$($QQ_PY - "$SCRIPT_DIR" <<'PY' 2>&1
import re
import sys
from pathlib import Path

repo = Path(sys.argv[1])
docs = repo / 'docs'
if not docs.is_dir():
    sys.exit(0)

# Discover language directories: docs/<lang>/ where <lang> looks like a
# language code (en, zh-CN, ja, ko, etc — heuristic: contains a letter or dash).
LANG_DIRS = {p.name for p in docs.iterdir() if p.is_dir() and p.name not in ('dev', 'evals', 'superpowers', 'main')}

link_re = re.compile(r'\[[^\]]*\]\(([^)\s]+)\)')
violations: list[str] = []

for lang in LANG_DIRS:
    lang_dir = docs / lang
    for path in lang_dir.rglob('*.md'):
        if path.name.endswith('_review.md'):
            continue
        try:
            text = path.read_text(encoding='utf-8')
        except (OSError, UnicodeDecodeError):
            continue
        in_fence = False
        fence = chr(96) * 3
        for lineno, line in enumerate(text.splitlines(), 1):
            if line.lstrip().startswith(fence):
                in_fence = not in_fence
                continue
            if in_fence:
                continue
            for m in link_re.finditer(line):
                url = m.group(1).strip()
                if url.startswith(('http://', 'https://', 'mailto:', '#')):
                    continue
                # Look for ../<other-lang>/ pattern
                cross_match = re.match(r'^\.\./([^/]+)/(.+)$', url)
                if not cross_match:
                    continue
                other_lang = cross_match.group(1)
                other_path = cross_match.group(2).split('#', 1)[0].split('?', 1)[0]
                if other_lang == lang or other_lang not in LANG_DIRS:
                    continue
                # Exempt language-switcher links: README.md cross-language links
                # are intentional (the "English | 中文 | 日本語 | 한국어" header).
                # Both source and target must be README.md to qualify as a switcher.
                if path.name == 'README.md' and other_path == 'README.md':
                    continue
                # Check if the same file exists in our own language directory
                same_lang_target = lang_dir / other_path
                if same_lang_target.exists():
                    rel = path.relative_to(repo).as_posix()
                    violations.append(
                        f'{rel}:{lineno} links to ../{other_lang}/{other_path} '
                        f'but docs/{lang}/{other_path} exists — link should be same-language sibling'
                    )

if violations:
    print('\n'.join(violations))
    sys.exit(1)
PY
)" || CROSS_LANG_STATUS=$?
if [ "$CROSS_LANG_STATUS" -eq 0 ]; then
  pass "no cross-language links where same-language sibling exists"
else
  CROSS_COUNT=$(printf '%s' "$CROSS_LANG_OUTPUT" | grep -c "->.*\.md\|links to" || echo 0)
  fail "cross-language link discipline violations ($CROSS_COUNT — should be same-language sibling)"
  printf '%s\n' "$CROSS_LANG_OUTPUT" | head -10 | sed 's/^/    /'
fi

# ── 6. SKILL.md frontmatter ──
echo -e "${CYAN}[6/10] SKILL.md frontmatter${NC}"

for dir in $SKILL_DIRS; do
  name=$(basename "$dir")
  if head -1 "$dir/SKILL.md" | grep -q '^---'; then
    if grep -q '^description:' "$dir/SKILL.md"; then
      pass "skills/$name has frontmatter + description"
    else
      fail "skills/$name missing description in frontmatter"
    fi
  else
    fail "skills/$name missing frontmatter (---)"
  fi
done

# ── 7. Script permissions ──
echo -e "${CYAN}[7/10] Script permissions${NC}"

for f in "$SCRIPT_DIR"/scripts/*.sh "$SCRIPT_DIR"/scripts/*.py "$SCRIPT_DIR"/scripts/hooks/*.sh "$SCRIPT_DIR/install.sh" "$SCRIPT_DIR/test.sh" "$SCRIPT_DIR/.devcontainer/postCreate.sh"; do
  if [ -f "$f" ] && [ ! -L "$f" ]; then
    if [ -x "$f" ]; then
      pass "$(basename "$f") is executable"
    else
      fail "$(basename "$f") NOT executable"
    fi
  fi
done

DOCKER_DEV_META=$("$SCRIPT_DIR/scripts/docker-dev.sh" print-json)
if printf '%s' "$DOCKER_DEV_META" | $QQ_PY -c '
import json
import os
import sys

data = json.load(sys.stdin)
repo_root = os.path.realpath(data["repo_root"])
git_dir = os.path.realpath(data["git_dir"])
mount_root = os.path.realpath(data["mount_root"])

assert repo_root.startswith(mount_root)
assert git_dir.startswith(mount_root)
'
then
  pass "docker-dev mount root covers repo root + git dir"
else
  fail "docker-dev mount root covers repo root + git dir"
fi

# ── 8. Runtime helper smoke tests ──
echo -e "${CYAN}[8/10] Runtime helper smoke tests${NC}"

RUNTIME_TEST_ROOT="$(mktemp -d)"
mkdir -p "$RUNTIME_TEST_ROOT/Docs/design" "$RUNTIME_TEST_ROOT/Docs/qq/demo"
cat > "$RUNTIME_TEST_ROOT/Docs/design/sample.md" <<'EOF'
# Sample Design
EOF
cat > "$RUNTIME_TEST_ROOT/Docs/qq/demo/sample_implementation.md" <<'EOF'
# Sample Implementation
EOF
cat > "$RUNTIME_TEST_ROOT/Sample.cs" <<'EOF'
using UnityEngine;

public class Sample : MonoBehaviour
{
    void Update()
    {
        GetComponent<Rigidbody>();
        SendMessage("Ping");
        if (gameObject.tag == "Player")
        {
        }
    }
}
EOF

RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$RUNTIME_TEST_ROOT" --stage compile --command smoke --backend test --transport local --summary "smoke start")
RUN_ID=$(printf '%s' "$RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$RUNTIME_TEST_ROOT" --run-id "$RUN_ID" --status passed --summary "smoke finish" >/dev/null

if $QQ_PY - "$RUNTIME_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
compile_state = json.loads((root / ".qq" / "state" / "compile.json").read_text(encoding="utf-8"))
project_state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8")) if (root / ".qq" / "state" / "project-state.json").exists() else {}
events = (root / ".qq" / "telemetry" / "events.jsonl").read_text(encoding="utf-8").strip().splitlines()

assert compile_state["status"] == "passed"
assert len(events) >= 2
assert project_state == {}
PY
then
  pass "run record writes state + telemetry"
else
  fail "run record writes state + telemetry"
fi

$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$RUNTIME_TEST_ROOT" >/dev/null
if $QQ_PY - "$RUNTIME_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["work_mode"] == "feature"
assert state["work_mode_source"] == "default"
assert state["config_format"] == "built_in_default"
assert state["shared_config_path"].endswith("qq.yaml")
assert state["local_config_path"].endswith(".qq/local.yaml")
assert state["profile"] == "feature"
assert state["profile_source"] == "default"
assert state["task_focus"] == []
assert state["task_focus_source"] == "default"
assert state["policy_profile"] == "feature"
assert state["policy_profile_source"] == "default"
assert state["policy_profile_expectations"]["review_expectation"] == "light"
assert state["default_test_scope"] == "all"
assert state["repository_design_doc_count"] == 1
assert state["repository_implementation_plan_count"] == 1
assert state["mode_recommended_next"] == "/qq:execute"
assert state["has_design_doc"] is True
assert state["has_implementation_plan"] is True
assert state["last_compile_status_raw"] == "passed"
assert state["last_compile_status"] == "passed"
assert state["compile_status_fresh"] is True
assert state["last_test_status_raw"] == "not_run"
assert state["test_status_fresh"] is True
assert state["recommended_next"] == "/qq:execute"
PY
then
  pass "project state snapshot is generated"
else
  fail "project state snapshot is generated"
fi


mkdir -p "$RUNTIME_TEST_ROOT/.qq"
cat > "$RUNTIME_TEST_ROOT/qq.yaml" <<'EOF'
version: 1
default_profile: core
work_mode: feature
enabled_rules:
  - find_object_of_type
  - send_message
  - tag_compare
  - get_component_in_hot_path
EOF
cat > "$RUNTIME_TEST_ROOT/.qq/local.yaml" <<'EOF'
work_mode: prototype
policy_profile: hardening
EOF
rm -f "$RUNTIME_TEST_ROOT/Docs/design/sample.md" "$RUNTIME_TEST_ROOT/Docs/qq/demo/sample_implementation.md"
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$RUNTIME_TEST_ROOT" >/dev/null
if $QQ_PY - "$RUNTIME_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["work_mode"] == "prototype"
assert state["work_mode_source"] == "qq_local_yaml"
assert state["task_focus"] == []
assert state["task_focus_source"] == "default"
assert state["policy_profile"] == "hardening"
assert state["policy_profile_source"] == "qq_local_yaml"
assert state["policy_profile_expectations"]["review_expectation"] == "required"
assert state["default_test_scope"] == "all"
assert state["repository_design_doc_count"] == 0
assert state["mode_recommended_next"] == "prototype_direct"
assert state["recommended_next"] == "prototype_direct"
assert state["mode_profile"]["changes_summary_expected"] is True
PY
then
  pass "project state respects local work mode override"
else
  fail "project state respects local work mode override"
fi

YAML_CONFIG_TEST_ROOT="$(mktemp -d)"
mkdir -p "$YAML_CONFIG_TEST_ROOT/.qq"
cat > "$YAML_CONFIG_TEST_ROOT/qq.yaml" <<'EOF'
version: 1

default_profile: lightweight

profiles:
  reviewless:
    extends: feature
    remove_packs:
      - workflow-review
      - hooks-review-gate
EOF
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$YAML_CONFIG_TEST_ROOT" >/dev/null
if $QQ_PY - "$YAML_CONFIG_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["config_format"] == "qq_yaml"
assert state["shared_config_path"].endswith("qq.yaml")
assert state["local_config_path"].endswith(".qq/local.yaml")
assert state["profile"] == "lightweight"
assert state["profile_source"] == "qq_yaml"
assert state["work_mode"] == "prototype"
assert state["policy_profile"] == "core"
assert state["default_test_scope"] == "editmode"
assert "plan" not in state["enabled_skills"]
assert "claude-code-review" not in state["enabled_skills"]
assert "review_gate" not in state["enabled_hooks"]
PY
then
  pass "qq.yaml lightweight profile resolves built-in packs"
else
  fail "qq.yaml lightweight profile resolves built-in packs"
fi

cat > "$YAML_CONFIG_TEST_ROOT/.qq/local.yaml" <<'EOF'
profile: reviewless
work_mode: hardening
EOF
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$YAML_CONFIG_TEST_ROOT" >/dev/null
if $QQ_PY - "$YAML_CONFIG_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["profile"] == "reviewless"
assert state["profile_source"] == "qq_local_yaml"
assert state["work_mode"] == "hardening"
assert state["work_mode_source"] == "qq_local_yaml"
assert state["policy_profile"] == "feature"
assert state["policy_profile_source"] == "profile"
assert "plan" in state["enabled_skills"]
assert "claude-code-review" in state["enabled_skills"]
assert "review_gate" in state["enabled_hooks"]
PY
then
  pass "local.yaml can select a custom profile while policy floor restores required review packs"
else
  fail "local.yaml can select a custom profile while policy floor restores required review packs"
fi
rm -rf "$YAML_CONFIG_TEST_ROOT"

FOCUS_TEST_ROOT="$(mktemp -d)"
mkdir -p "$FOCUS_TEST_ROOT/Docs/design" "$FOCUS_TEST_ROOT/.qq"
cat > "$FOCUS_TEST_ROOT/Docs/design/crew_weapon.md" <<'EOF'
# Crew Weapon
EOF
cat > "$FOCUS_TEST_ROOT/Docs/design/map_refactor.md" <<'EOF'
# Map Refactor
EOF
cat > "$FOCUS_TEST_ROOT/qq.yaml" <<'EOF'
version: 1
default_profile: feature
work_mode: prototype
EOF
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$FOCUS_TEST_ROOT" >/dev/null
if $QQ_PY - "$FOCUS_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["repository_design_doc_count"] == 2
assert state["has_design_doc"] is False
assert state["design_docs"] == []
assert state["mode_recommended_next"] == "prototype_direct"
assert state["recommended_next"] == "prototype_direct"
PY
then
  pass "repo-global design docs do not force prototype planning"
else
  fail "repo-global design docs do not force prototype planning"
fi

cat > "$FOCUS_TEST_ROOT/.qq/local.yaml" <<'EOF'
work_mode: prototype
policy_profile: feature
task_focus: crew weapon
EOF
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$FOCUS_TEST_ROOT" >/dev/null
if $QQ_PY - "$FOCUS_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["task_focus"] == ["crew weapon"]
assert state["task_focus_source"] == "qq_local_yaml"
assert state["has_design_doc"] is True
assert state["design_docs"] == ["Docs/design/crew_weapon.md"]
assert state["mode_recommended_next"] == "/qq:plan"
assert state["recommended_next"] == "/qq:plan"
PY
then
  pass "task focus can explicitly activate relevant design docs"
else
  fail "task focus can explicitly activate relevant design docs"
fi
rm -rf "$FOCUS_TEST_ROOT"

POLICY_TEST_ROOT="$(mktemp -d)"
mkdir -p "$POLICY_TEST_ROOT/.qq"
(
  cd "$POLICY_TEST_ROOT" &&
  git init -q
)
cat > "$POLICY_TEST_ROOT/SeaMonsterSpike.cs" <<'EOF'
using UnityEngine;

public class SeaMonsterSpike : MonoBehaviour
{
    void Start()
    {
        Debug.Log("spike");
    }
}
EOF
RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$POLICY_TEST_ROOT" --stage compile --command policy-compile --backend test --transport local --summary "policy compile start")
RUN_ID=$(printf '%s' "$RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$POLICY_TEST_ROOT" --run-id "$RUN_ID" --status passed --summary "policy compile passed" >/dev/null
cat > "$POLICY_TEST_ROOT/qq.yaml" <<'EOF'
version: 1
engine: unity
default_profile: core
work_mode: prototype
EOF
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$POLICY_TEST_ROOT" >/dev/null
if $QQ_PY - "$POLICY_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["has_uncommitted_runtime_changes"] is True
assert state["policy_profile"] == "core"
assert state["default_test_scope"] == "editmode"
assert state["has_uncommitted_test_changes"] is False
assert state["changed_test_files"] == []
assert state["mode_recommended_next"] == "/qq:changes"
assert state["recommended_next"] == "/qq:changes"
PY
then
  pass "core profile keeps prototype recommendation light"
else
  fail "core profile keeps prototype recommendation light"
fi

if PROJECT_DIR="$POLICY_TEST_ROOT" bash -lc '
  source "'"$SCRIPT_DIR"'/scripts/qq-runtime.sh"
  [ "$(qq_policy_profile)" = "core" ] &&
  [ "$(qq_work_mode)" = "prototype" ] &&
  [ "$(qq_default_test_scope)" = "editmode" ]
'; then
  pass "qq-runtime helpers expose core policy defaults"
else
  fail "qq-runtime helpers expose core policy defaults"
fi

$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" record --project "$POLICY_TEST_ROOT" --stage changes --command qq:changes --status checked --summary "prototype summary captured" --capture-local-changes >/dev/null
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$POLICY_TEST_ROOT" >/dev/null
if $QQ_PY - "$POLICY_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["changes_summary_fresh"] is True
assert state["last_changes_status"] == "checked"
assert state["mode_recommended_next"] == "/qq:commit-push"
assert state["recommended_next"] == "/qq:add-tests"
PY
then
  pass "prototype changes summary advances the controller to commit-push"
else
  fail "prototype changes summary advances the controller to commit-push"
fi

printf '// follow-up\n' >> "$POLICY_TEST_ROOT/SeaMonsterSpike.cs"
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$POLICY_TEST_ROOT" >/dev/null
if $QQ_PY - "$POLICY_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["changes_summary_fresh"] is False
assert state["mode_recommended_next"] == "verify_compile"
assert state["recommended_next"] == "verify_compile"
PY
then
  pass "prototype changes summary is invalidated by newer local edits"
else
  fail "prototype changes summary is invalidated by newer local edits"
fi

RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$POLICY_TEST_ROOT" --stage compile --command policy-compile-refresh --backend test --transport local --summary "policy compile refresh start")
RUN_ID=$(printf '%s' "$RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$POLICY_TEST_ROOT" --run-id "$RUN_ID" --status passed --summary "policy compile refresh passed" >/dev/null

cat > "$POLICY_TEST_ROOT/.qq/local.yaml" <<'EOF'
work_mode: prototype
policy_profile: hardening
EOF
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$POLICY_TEST_ROOT" >/dev/null
if $QQ_PY - "$POLICY_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["policy_profile"] == "hardening"
assert state["default_test_scope"] == "all"
assert state["mode_recommended_next"] == "/qq:changes"
assert state["recommended_next"] == "/qq:test"
PY
then
  pass "hardening profile raises prototype work to test first"
else
  fail "hardening profile raises prototype work to test first"
fi

if PROJECT_DIR="$POLICY_TEST_ROOT" bash -lc '
  source "'"$SCRIPT_DIR"'/scripts/qq-runtime.sh"
  [ "$(qq_policy_profile)" = "hardening" ] &&
  [ "$(qq_work_mode)" = "prototype" ] &&
  [ "$(qq_default_test_scope)" = "all" ]
'; then
  pass "qq-runtime helpers respect local profile override"
else
  fail "qq-runtime helpers respect local profile override"
fi

RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$POLICY_TEST_ROOT" --stage test --command policy-test --backend test --transport local --summary "policy test start")
RUN_ID=$(printf '%s' "$RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$POLICY_TEST_ROOT" --run-id "$RUN_ID" --status passed --summary "policy test passed" >/dev/null
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$POLICY_TEST_ROOT" >/dev/null
if $QQ_PY - "$POLICY_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["recommended_next"] == "/qq:claude-code-review"
PY
then
  pass "hardening profile escalates to review after tests pass"
else
  fail "hardening profile escalates to review after tests pass"
fi

RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$POLICY_TEST_ROOT" --stage review_gate --command policy-review --backend test --transport local --summary "policy review start")
RUN_ID=$(printf '%s' "$RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$POLICY_TEST_ROOT" --run-id "$RUN_ID" --status verified --summary "policy review verified" >/dev/null
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$POLICY_TEST_ROOT" >/dev/null
if $QQ_PY - "$POLICY_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["review_gate_status"] == "verified"
assert state["recommended_next"] == "/qq:doc-drift"
PY
then
  pass "hardening profile escalates to doc drift after review"
else
  fail "hardening profile escalates to doc drift after review"
fi
rm -rf "$POLICY_TEST_ROOT"

# ── review gate three-field format ──
echo -e "${CYAN}[gate] three-field format${NC}"

GATE_TMP="$(mktemp -d)"

# gate-set creates three-field file
echo "$(date +%s):0:0" > "$GATE_TMP/review-gate-test"
IFS=: read -r _ts _completed _expected < "$GATE_TMP/review-gate-test"
if [[ "$_completed" == "0" && "$_expected" == "0" ]]; then
  pass "gate-set creates three-field format"
else
  fail "gate-set creates three-field format (got $_completed:$_expected)"
fi

# gate-count preserves expected field
echo "1000:0:3" > "$GATE_TMP/review-gate-test"
IFS=: read -r _ts _count _expected < "$GATE_TMP/review-gate-test"
_new_count=$(( _count + 1 ))
echo "${_ts}:${_new_count}:${_expected}" > "$GATE_TMP/review-gate-test"
IFS=: read -r _ts2 _count2 _expected2 < "$GATE_TMP/review-gate-test"
if [[ "$_count2" == "1" && "$_expected2" == "3" ]]; then
  pass "gate-count preserves expected field"
else
  fail "gate-count preserves expected field (got $_count2:$_expected2)"
fi

# gate-check blocks when expected=0
echo "$(date +%s):0:0" > "$GATE_TMP/review-gate-test"
IFS=: read -r _ts _count _expected < "$GATE_TMP/review-gate-test"
if [[ ${_expected:-0} -eq 0 || ${_count:-0} -lt ${_expected:-0} ]]; then
  pass "gate-check blocks when expected=0"
else
  fail "gate-check blocks when expected=0"
fi

# gate-check blocks when completed < expected
echo "$(date +%s):1:3" > "$GATE_TMP/review-gate-test"
IFS=: read -r _ts _count _expected < "$GATE_TMP/review-gate-test"
if [[ ${_expected:-0} -eq 0 || ${_count:-0} -lt ${_expected:-0} ]]; then
  pass "gate-check blocks when completed < expected"
else
  fail "gate-check blocks when completed < expected"
fi

# gate-check allows when completed >= expected
echo "$(date +%s):3:3" > "$GATE_TMP/review-gate-test"
IFS=: read -r _ts _count _expected < "$GATE_TMP/review-gate-test"
if [[ ${_expected:-0} -gt 0 && ${_count:-0} -ge ${_expected:-0} ]]; then
  pass "gate-check allows when completed >= expected"
else
  fail "gate-check allows when completed >= expected"
fi

# stop hook detects incomplete verification
echo "$(date +%s):1:3" > "$GATE_TMP/review-gate-test"
IFS=: read -r _ts _count _expected < "$GATE_TMP/review-gate-test"
if [[ -f "$GATE_TMP/review-gate-test" && ${_expected:-0} -gt 0 && ${_count:-0} -lt ${_expected:-0} ]]; then
  pass "stop hook detects incomplete verification"
else
  fail "stop hook detects incomplete verification"
fi

# stop hook allows exit when verification complete
echo "$(date +%s):3:3" > "$GATE_TMP/review-gate-test"
IFS=: read -r _ts _count _expected < "$GATE_TMP/review-gate-test"
if [[ ! -f "$GATE_TMP/review-gate-test" ]] || [[ ${_expected:-0} -eq 0 ]] || [[ ${_count:-0} -ge ${_expected:-0} ]]; then
  pass "stop hook allows exit when verification complete"
else
  fail "stop hook allows exit when verification complete"
fi

rm -rf "$GATE_TMP"

FIX_TEST_ROOT="$(mktemp -d)"
mkdir -p "$FIX_TEST_ROOT/.qq"
(
  cd "$FIX_TEST_ROOT" &&
  git init -q
)
cat > "$FIX_TEST_ROOT/qq.yaml" <<'EOF'
version: 1
engine: unity
default_profile: feature
EOF
cat > "$FIX_TEST_ROOT/.qq/local.yaml" <<'EOF'
work_mode: fix
policy_profile: feature
EOF
cat > "$FIX_TEST_ROOT/BugFix.cs" <<'EOF'
using UnityEngine;

public class BugFix : MonoBehaviour {}
EOF
RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$FIX_TEST_ROOT" --stage compile --command fix-compile --backend test --transport local --summary "fix compile start")
RUN_ID=$(printf '%s' "$RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$FIX_TEST_ROOT" --run-id "$RUN_ID" --status passed --summary "fix compile passed" >/dev/null
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$FIX_TEST_ROOT" >/dev/null
if $QQ_PY - "$FIX_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["work_mode"] == "fix"
assert state["has_uncommitted_runtime_changes"] is True
assert state["has_uncommitted_test_changes"] is False
assert state["changed_test_files"] == []
assert state["recommended_next"] == "/qq:add-tests"
PY
then
  pass "fix mode routes compile-green patches to add-tests before test execution"
else
  fail "fix mode routes compile-green patches to add-tests before test execution"
fi

mkdir -p "$FIX_TEST_ROOT/Assets/Tests/EditMode"
cat > "$FIX_TEST_ROOT/Assets/Tests/EditMode/BugFixTests.cs" <<'EOF'
public class BugFixTests {}
EOF
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$FIX_TEST_ROOT" >/dev/null
if $QQ_PY - "$FIX_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["has_uncommitted_test_changes"] is True
assert state["changed_test_files"] == ["Assets/Tests/EditMode/BugFixTests.cs"]
assert state["recommended_next"] == "verify_compile"
PY
then
  pass "fix mode returns to compile verification after new test files are added"
else
  fail "fix mode returns to compile verification after new test files are added"
fi
RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$FIX_TEST_ROOT" --stage compile --command fix-test-compile --backend test --transport local --summary "fix test compile start")
RUN_ID=$(printf '%s' "$RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$FIX_TEST_ROOT" --run-id "$RUN_ID" --status passed --summary "fix test compile passed" >/dev/null
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$FIX_TEST_ROOT" >/dev/null
if $QQ_PY - "$FIX_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["has_uncommitted_test_changes"] is True
assert state["changed_test_files"] == ["Assets/Tests/EditMode/BugFixTests.cs"]
assert state["recommended_next"] == "/qq:test"
PY
then
  pass "fix mode hands off to test once targeted test coverage compiles cleanly"
else
  fail "fix mode hands off to test once targeted test coverage compiles cleanly"
fi
rm -rf "$FIX_TEST_ROOT"

FEATURE_TEST_ROOT="$(mktemp -d)"
mkdir -p "$FEATURE_TEST_ROOT/.qq"
(
  cd "$FEATURE_TEST_ROOT" &&
  git init -q
)
cat > "$FEATURE_TEST_ROOT/qq.yaml" <<'EOF'
version: 1
engine: unity
default_profile: feature
EOF
cat > "$FEATURE_TEST_ROOT/.qq/local.yaml" <<'EOF'
work_mode: feature
policy_profile: feature
EOF
cat > "$FEATURE_TEST_ROOT/FeatureWork.cs" <<'EOF'
using UnityEngine;

public class FeatureWork : MonoBehaviour {}
EOF
RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$FEATURE_TEST_ROOT" --stage compile --command feature-compile --backend test --transport local --summary "feature compile start")
RUN_ID=$(printf '%s' "$RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$FEATURE_TEST_ROOT" --run-id "$RUN_ID" --status passed --summary "feature compile passed" >/dev/null
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$FEATURE_TEST_ROOT" >/dev/null
if $QQ_PY - "$FEATURE_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["work_mode"] == "feature"
assert state["has_uncommitted_runtime_changes"] is True
assert state["has_uncommitted_test_changes"] is False
assert state["changed_test_files"] == []
assert state["recommended_next"] == "/qq:add-tests"
PY
then
  pass "feature mode routes compile-green runtime changes to add-tests first"
else
  fail "feature mode routes compile-green runtime changes to add-tests first"
fi

mkdir -p "$FEATURE_TEST_ROOT/Assets/Tests/EditMode"
cat > "$FEATURE_TEST_ROOT/Assets/Tests/EditMode/FeatureWorkTests.cs" <<'EOF'
public class FeatureWorkTests {}
EOF
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$FEATURE_TEST_ROOT" >/dev/null
if $QQ_PY - "$FEATURE_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["has_uncommitted_test_changes"] is True
assert state["changed_test_files"] == ["Assets/Tests/EditMode/FeatureWorkTests.cs"]
assert state["recommended_next"] == "verify_compile"
PY
then
  pass "feature mode asks for a fresh compile after adding new test files"
else
  fail "feature mode asks for a fresh compile after adding new test files"
fi

RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$FEATURE_TEST_ROOT" --stage compile --command feature-test-compile --backend test --transport local --summary "feature test compile start")
RUN_ID=$(printf '%s' "$RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$FEATURE_TEST_ROOT" --run-id "$RUN_ID" --status passed --summary "feature test compile passed" >/dev/null
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$FEATURE_TEST_ROOT" >/dev/null
if $QQ_PY - "$FEATURE_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["has_uncommitted_test_changes"] is True
assert state["changed_test_files"] == ["Assets/Tests/EditMode/FeatureWorkTests.cs"]
assert state["recommended_next"] == "/qq:test"
PY
then
  pass "feature mode hands off to test after targeted coverage compiles cleanly"
else
  fail "feature mode hands off to test after targeted coverage compiles cleanly"
fi
rm -rf "$FEATURE_TEST_ROOT"

STALE_TEST_ROOT="$(mktemp -d)"
mkdir -p "$STALE_TEST_ROOT/.qq"
(
  cd "$STALE_TEST_ROOT" &&
  git init -q
)
cat > "$STALE_TEST_ROOT/qq.yaml" <<'EOF'
version: 1
engine: unity
default_profile: hardening
work_mode: prototype
EOF
RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$STALE_TEST_ROOT" --stage test --command stale-test --backend test --transport local --summary "stale test start")
RUN_ID=$(printf '%s' "$RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$STALE_TEST_ROOT" --run-id "$RUN_ID" --status passed --summary "stale test passed" >/dev/null
sleep 1
cat > "$STALE_TEST_ROOT/Probe.cs" <<'EOF'
public class Probe {}
EOF
RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$STALE_TEST_ROOT" --stage compile --command stale-compile --backend test --transport local --summary "stale compile start")
RUN_ID=$(printf '%s' "$RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$STALE_TEST_ROOT" --run-id "$RUN_ID" --status passed --summary "stale compile passed" >/dev/null
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$STALE_TEST_ROOT" >/dev/null
if $QQ_PY - "$STALE_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["has_uncommitted_runtime_changes"] is True
assert state["last_compile_status_raw"] == "passed"
assert state["compile_status_fresh"] is True
assert state["last_compile_status"] == "passed"
assert state["last_test_status_raw"] == "passed"
assert state["test_status_fresh"] is False
assert state["last_test_status"] == "not_run"
assert state["mode_recommended_next"] == "/qq:changes"
assert state["recommended_next"] == "/qq:test"
PY
then
  pass "stale test results are invalidated after newer code changes"
else
  fail "stale test results are invalidated after newer code changes"
fi

sleep 1
cat >> "$STALE_TEST_ROOT/Probe.cs" <<'EOF'
public class Probe2 {}
EOF
$QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$STALE_TEST_ROOT" >/dev/null
if $QQ_PY - "$STALE_TEST_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["last_compile_status_raw"] == "passed"
assert state["compile_status_fresh"] is False
assert state["last_compile_status"] == "not_run"
assert state["recommended_next"] == "verify_compile"
PY
then
  pass "stale compile results are invalidated after newer code changes"
else
  fail "stale compile results are invalidated after newer code changes"
fi
rm -rf "$STALE_TEST_ROOT"

WORKTREE_BARE_STATE_ROOT="$(mktemp -d)"
(
  cd "$WORKTREE_BARE_STATE_ROOT" &&
  git init -q &&
  git config user.email qq@example.com &&
  git config user.name "qq test" &&
  mkdir -p ProjectSettings Packages &&
  cat > ProjectSettings/ProjectVersion.txt <<'EOF'
m_EditorVersion: 2022.3.17f1
EOF
  cat > Packages/manifest.json <<'EOF'
{
  "dependencies": {}
}
EOF
  cat > Probe.cs <<'EOF'
using UnityEngine;

public class Probe : MonoBehaviour
{
}
EOF
  git add Probe.cs ProjectSettings/ProjectVersion.txt Packages/manifest.json &&
  git commit -q -m "init" &&
  git checkout -q -b feature/bare-state &&
  git config core.bare true
)
cat >> "$WORKTREE_BARE_STATE_ROOT/Probe.cs" <<'EOF'
public class Probe2 {}
EOF
if $QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$WORKTREE_BARE_STATE_ROOT" >/dev/null && \
   $QQ_PY - "$WORKTREE_BARE_STATE_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert state["has_uncommitted_runtime_changes"] is True
assert "Probe.cs" in state["changed_runtime_files"]
assert state["recommended_next"] == "verify_compile"
PY
then
  pass "qq-project-state detects code changes in bare worktree repos"
else
  fail "qq-project-state detects code changes in bare worktree repos"
fi
rm -rf "$WORKTREE_BARE_STATE_ROOT"

WORKTREE_BARE_CREATE_ROOT="$(mktemp -d)"
(
  cd "$WORKTREE_BARE_CREATE_ROOT" &&
  git init -q &&
  git config user.email qq@example.com &&
  git config user.name "qq test" &&
  printf 'base\n' > README.md &&
  git add README.md &&
  git commit -q -m "init" &&
  git checkout -q -b feature/bare-create &&
  git config core.bare true
)
WORKTREE_BARE_CREATE_PARENT="$(dirname "$WORKTREE_BARE_CREATE_ROOT")"
if BARE_CREATE_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" create --project "$WORKTREE_BARE_CREATE_ROOT" --name bare-create --base-dir "$WORKTREE_BARE_CREATE_PARENT"); then
  BARE_WORKTREE_PATH=$(printf '%s' "$BARE_CREATE_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["worktreePath"])')
  if $QQ_PY - "$BARE_CREATE_JSON" "$BARE_WORKTREE_PATH" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(sys.argv[1])
worktree = Path(sys.argv[2])

assert payload["sourceBranch"] == "feature/bare-create"
assert payload["branch"] == "feature/bare-create-wt-bare-create"
assert worktree.exists()
PY
  then
    pass "qq-worktree create works in bare worktree repos"
  else
    fail "qq-worktree create works in bare worktree repos"
  fi
  $QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" cleanup --project "$BARE_WORKTREE_PATH" --delete-branch >/dev/null 2>&1 || true
else
  fail "qq-worktree create works in bare worktree repos"
fi
rm -rf "$WORKTREE_BARE_CREATE_ROOT"

WORKTREE_TEST_ROOT="$(mktemp -d)"
(
  cd "$WORKTREE_TEST_ROOT" &&
  git init -q &&
  git config user.email qq@example.com &&
  git config user.name "qq test" &&
  mkdir -p ProjectSettings Packages Library/PackageCache/mock &&
  cat > ProjectSettings/ProjectVersion.txt <<'EOF'
m_EditorVersion: 2022.3.17f1
EOF
  cat > Packages/manifest.json <<'EOF'
{
  "dependencies": {}
}
EOF
  cat > .gitignore <<'EOF'
Library/
Temp/
EOF
  printf 'cached\n' > Library/PackageCache/mock/seed.txt &&
  printf '{\n  "mcpServers": {\n    "qq-unity": { "command": "%s" }\n  }\n}\n' "$QQ_PY" > .mcp.json &&
  mkdir -p .claude &&
  printf '{\n  "enabledPlugins": {\n    "qq@quick-question-marketplace": true\n  }\n}\n' > .claude/settings.local.json &&
  cat > qq.yaml <<'EOF'
default_profile: feature
EOF
  mkdir -p scripts &&
  cat > scripts/qq-doctor.py <<'EOF'
#!/usr/bin/env python3
print("ok")
EOF
  chmod +x scripts/qq-doctor.py &&
  printf 'base\n' > README.md &&
  git add README.md .mcp.json .gitignore ProjectSettings/ProjectVersion.txt Packages/manifest.json &&
  git add -f .claude/settings.local.json &&
  git commit -q -m "init" &&
  git checkout -q -b feature/ship-system
)
RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$WORKTREE_TEST_ROOT" --stage compile --command source-compile --backend test --transport local --summary "source compile start")
RUN_ID=$(printf '%s' "$RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$WORKTREE_TEST_ROOT" --run-id "$RUN_ID" --status passed --summary "source compile passed" >/dev/null
RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$WORKTREE_TEST_ROOT" --stage test --command source-test --backend test --transport local --summary "source test start")
RUN_ID=$(printf '%s' "$RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$WORKTREE_TEST_ROOT" --run-id "$RUN_ID" --status passed --summary "source test passed" >/dev/null
WORKTREE_PARENT="$(dirname "$WORKTREE_TEST_ROOT")"
if CREATE_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" create --project "$WORKTREE_TEST_ROOT" --name "Sea Monster" --base-dir "$WORKTREE_PARENT" --allow-dirty-source); then
  WORKTREE_PATH=$(printf '%s' "$CREATE_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["worktreePath"])')
  if $QQ_PY - "$CREATE_JSON" "$WORKTREE_TEST_ROOT" "$WORKTREE_PATH" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(sys.argv[1])
source = Path(sys.argv[2]).resolve()
target = Path(sys.argv[3]).resolve()

assert payload["sourceBranch"] == "feature/ship-system"
assert payload["branch"] == "feature/ship-system-wt-sea-monster"
assert target.exists()
metadata = json.loads((target / ".qq" / "state" / "worktree.json").read_text(encoding="utf-8"))
assert metadata["managedBy"] == "qq"
assert metadata["sourceBranch"] == "feature/ship-system"
assert Path(metadata["sourceWorktreePath"]).resolve() == source
assert ".mcp.json" in metadata["copiedLocalRuntimeFiles"]
assert ".claude/settings.local.json" in metadata["copiedLocalRuntimeFiles"]
assert "qq.yaml" in metadata["copiedLocalRuntimeFiles"]
assert "scripts" in metadata["copiedLocalRuntimeFiles"]
assert ".qq/state/compile.json" in metadata["copiedBaselineStateFiles"]
assert ".qq/state/test.json" in metadata["copiedBaselineStateFiles"]
assert metadata["copiedBaselineRunRecords"]
assert (target / ".mcp.json").is_file()
assert (target / ".claude" / "settings.local.json").is_file()
assert (target / "qq.yaml").is_file()
assert (target / "scripts" / "qq-doctor.py").is_file()
assert (target / ".qq" / "state" / "compile.json").is_file()
assert (target / ".qq" / "state" / "test.json").is_file()
for record_path in metadata["copiedBaselineRunRecords"]:
    assert (target / record_path).is_file()
assert payload["runtimeCacheSeed"]["action"] == "seeded"
assert payload["runtimeCacheSeed"]["strategy"]
assert (target / "Library" / "PackageCache" / "mock" / "seed.txt").is_file()
assert metadata["runtimeCacheSeed"]["action"] == "seeded"
assert metadata["runtimeCacheSeed"]["strategy"]
assert payload["recommendedExecution"]["mode"] == "host"
assert "Unity" in payload["recommendedExecution"]["reason"]
assert payload["parallelAgentSafe"] is True
assert payload["parallelAgentSafety"]["status"] == "ok"
assert "exactly one agent" in payload["parallelAgentSafety"]["summary"]
labels = [item["label"] for item in payload["nextSteps"]]
assert labels[0] == "enter-worktree"
assert "inspect-worktree-state" in labels
assert "closeout-worktree" in labels
assert any("qq-doctor.py" in item["command"] for item in payload["nextSteps"])
assert any("qq-worktree.py" in item["command"] and "closeout" in item["command"] for item in payload["nextSteps"])
PY
  then
    pass "qq-worktree create builds a managed linked worktree"
  else
    fail "qq-worktree create builds a managed linked worktree"
  fi
else
  fail "qq-worktree create builds a managed linked worktree"
  WORKTREE_PATH=""
fi

WORKTREE_SEED_JSON="$(mktemp)"
if [ -n "${WORKTREE_PATH:-}" ]; then
  rm -rf "$WORKTREE_PATH/Library"
fi

if [ -n "${WORKTREE_PATH:-}" ] && $QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" seed-runtime-cache --project "$WORKTREE_PATH" --pretty > "$WORKTREE_SEED_JSON" && \
   $QQ_PY - "$WORKTREE_SEED_JSON" "$WORKTREE_PATH" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
worktree = Path(sys.argv[2])
seed = payload["runtimeCacheSeed"]
assert payload["ok"] is True
assert payload["action"] == "seed-runtime-cache"
assert seed["action"] == "seeded"
assert seed["strategy"]
assert (worktree / "Library" / "PackageCache" / "mock" / "seed.txt").is_file()
PY
then
  pass "qq-worktree seed-runtime-cache restores a missing managed-worktree runtime cache"
else
  fail "qq-worktree seed-runtime-cache restores a missing managed-worktree runtime cache"
fi
rm -f "$WORKTREE_SEED_JSON"

if [ -n "${WORKTREE_PATH:-}" ]; then
  printf 'note\n' > "$WORKTREE_PATH/notes.md"
fi

if [ -n "${WORKTREE_PATH:-}" ] && $QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$WORKTREE_PATH" >/dev/null && \
   $QQ_PY - "$WORKTREE_PATH" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))
assert state["has_uncommitted_runtime_changes"] is False
assert state["last_compile_status"] == "passed"
assert state["last_test_status"] == "passed"
assert state["recommended_next"] == "/qq:commit-push"
PY
then
  pass "managed worktree inherits source compile/test baseline for doc-only changes"
else
  fail "managed worktree inherits source compile/test baseline for doc-only changes"
fi

if [ -n "${WORKTREE_PATH:-}" ]; then
  rm -f "$WORKTREE_PATH/notes.md"
fi

WORKTREE_STATUS_JSON="$(mktemp)"
WORKTREE_MERGE_JSON="$(mktemp)"
WORKTREE_CLEANUP_JSON="$(mktemp)"

if [ -n "${WORKTREE_PATH:-}" ] && $QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" status --project "$WORKTREE_PATH" > "$WORKTREE_STATUS_JSON" && \
   $QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$WORKTREE_PATH" >/dev/null && \
   $QQ_PY - "$WORKTREE_STATUS_JSON" "$WORKTREE_PATH" <<'PY'
import json
import sys
from pathlib import Path

status = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
state = json.loads((Path(sys.argv[2]) / ".qq" / "state" / "project-state.json").read_text(encoding="utf-8"))

assert status["isManagedWorktree"] is True
assert status["sourceBranch"] == "feature/ship-system"
assert status["role"] == "managed"
assert state["is_managed_worktree"] is True
assert state["worktree_role"] == "managed"
assert state["worktree_source_branch"] == "feature/ship-system"
assert state["worktree_source_worktree_path"]
assert state["worktree_source_runtime_cache_exists"] is True
assert state["worktree_local_runtime_cache_exists"] is True
assert state["worktree_local_runtime_cache_support_exists"] is True
assert state["worktree_can_seed_runtime_cache"] is False
assert state["worktree_runtime_cache_seed_state"] == "seeded"
assert status["sourceRuntimeCacheExists"] is True
assert status["localRuntimeCacheExists"] is True
assert status["localRuntimeCacheSupportExists"] is True
assert status["canSeedRuntimeCache"] is False
PY
then
  pass "worktree status flows through qq-project-state"
else
  fail "worktree status flows through qq-project-state"
fi

if [ -n "${WORKTREE_PATH:-}" ]; then
  (
    cd "$WORKTREE_PATH" &&
    git config user.email qq@example.com &&
    git config user.name "qq test" &&
    printf 'sea monster\n' >> README.md &&
    git add README.md &&
    git commit -q -m "feat: add sea monster notes"
  )
  mkdir -p "$WORKTREE_TEST_ROOT/scripts/__pycache__"
  printf 'compiled\n' > "$WORKTREE_TEST_ROOT/scripts/__pycache__/qq-worktree.cpython-312.pyc"
fi

if [ -n "${WORKTREE_PATH:-}" ] && $QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" merge-back --project "$WORKTREE_PATH" --auto-yes > "$WORKTREE_MERGE_JSON" && \
   $QQ_PY - "$WORKTREE_TEST_ROOT" "$WORKTREE_PATH" "$WORKTREE_MERGE_JSON" <<'PY'
import json
import subprocess
import sys
from pathlib import Path

root = Path(sys.argv[1])
worktree = Path(sys.argv[2])
payload = json.loads(Path(sys.argv[3]).read_text(encoding="utf-8"))
assert payload["mergedBranch"] == "feature/ship-system-wt-sea-monster"

head = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=root, text=True).strip()
assert head == "feature/ship-system"
log = subprocess.check_output(["git", "log", "--oneline", "--merges", "-n", "1"], cwd=root, text=True).strip()
assert "feature/ship-system-wt-sea-monster" in log
assert worktree.exists()
PY
then
  pass "qq-worktree merge-back merges the linked branch into the source branch"
else
  fail "qq-worktree merge-back merges the linked branch into the source branch"
fi

if [ -n "${WORKTREE_PATH:-}" ]; then
  printf 'default_profile: lightweight\n' > "$WORKTREE_PATH/qq.yaml"
  printf '# runtime tweak\n' >> "$WORKTREE_PATH/scripts/qq-doctor.py"
  mkdir -p "$WORKTREE_PATH/.claude"
  printf '{\"enabledPlugins\":{\"qq@quick-question-marketplace\":true}}\n' > "$WORKTREE_PATH/.claude/settings.local.json"
  printf '{\"mcpServers\":{\"tykit\":{\"command\":\"python3\"}}}\n' > "$WORKTREE_PATH/.mcp.json"
fi

if [ -n "${WORKTREE_PATH:-}" ] && $QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" cleanup --project "$WORKTREE_PATH" --delete-branch > "$WORKTREE_CLEANUP_JSON" && \
   $QQ_PY - "$WORKTREE_TEST_ROOT" "$WORKTREE_PATH" "$WORKTREE_CLEANUP_JSON" <<'PY'
import json
import subprocess
import sys
from pathlib import Path

root = Path(sys.argv[1])
worktree = Path(sys.argv[2])
payload = json.loads(Path(sys.argv[3]).read_text(encoding="utf-8"))
assert payload["deletedBranch"] is True
assert "qq.yaml" in payload["prunedRuntimePaths"]
assert "scripts/" in payload["prunedRuntimePaths"]
assert any(item.startswith("scripts/qq-doctor.py") for item in payload["prunedRuntimePaths"])
assert not worktree.exists()
branches = subprocess.check_output(["git", "branch", "--list", "feature/ship-system-wt-sea-monster"], cwd=root, text=True).strip()
assert branches == ""
PY
then
  pass "qq-worktree cleanup prunes copied runtime files and removes the linked worktree"
else
  fail "qq-worktree cleanup prunes copied runtime files and removes the linked worktree"
fi
rm -f "$WORKTREE_STATUS_JSON" "$WORKTREE_MERGE_JSON" "$WORKTREE_CLEANUP_JSON"
rm -rf "$WORKTREE_TEST_ROOT"

# ── seed-local-runtime: complete an EnterWorktree-created worktree ──
# v1.16.25: EnterWorktree (Claude Code built-in) does only `git worktree add`,
# leaving the new worktree without LOCAL_RUNTIME_PATHS (scripts/, .mcp.json,
# qq.yaml, AGENTS.md, CLAUDE.md), without baseline state files, and without
# .qq/state/worktree.json metadata. The new `seed-local-runtime` subcommand
# fills this gap so EnterWorktree-created worktrees behave like
# command_create-created ones. See proposal:
# docs/dev/proposals/2026-04-07-1906-worktree-local-runtime-fix.md
echo -e "${CYAN}[seed-local-runtime] EnterWorktree worktree completion${NC}"

SLR_SOURCE="$(mktemp -d)"
SLR_PARENT="$(dirname "$SLR_SOURCE")"
(
  cd "$SLR_SOURCE" &&
  git init -q &&
  git config user.email qq@example.com &&
  git config user.name "qq test" &&
  mkdir -p ProjectSettings Packages scripts/platform .claude .qq/state &&
  printf 'm_EditorVersion: 2022.3.51f1c1\n' > ProjectSettings/ProjectVersion.txt &&
  printf '{"dependencies":{}}\n' > Packages/manifest.json &&
  printf '#!/bin/bash\necho doctor\n' > scripts/qq-doctor.py &&
  chmod +x scripts/qq-doctor.py &&
  printf '#!/bin/bash\necho platform\n' > scripts/platform/detect.sh &&
  chmod +x scripts/platform/detect.sh &&
  printf '{"mcpServers":{}}\n' > .mcp.json &&
  printf '{"enabledPlugins":{}}\n' > .claude/settings.local.json &&
  printf 'work_mode: feature\n' > qq.yaml &&
  printf '# project agents\n' > AGENTS.md &&
  printf '# project guide\n' > CLAUDE.md &&
  printf 'base\n' > README.md &&
  printf '.qq/\n' > .gitignore &&
  git add ProjectSettings Packages README.md .gitignore qq.yaml AGENTS.md CLAUDE.md scripts &&
  git add -f .mcp.json .claude/settings.local.json &&
  git commit -q -m "init" &&
  git checkout -q -b feature/test-seed
)

# Seed source baseline state + run records (so seed-local-runtime has something to copy)
SLR_RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$SLR_SOURCE" --stage compile --command source-compile --backend test --transport local --summary "source compile start")
SLR_RUN_ID=$(printf '%s' "$SLR_RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$SLR_SOURCE" --run-id "$SLR_RUN_ID" --status passed --summary "source compile passed" >/dev/null
SLR_RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$SLR_SOURCE" --stage test --command source-test --backend test --transport local --summary "source test start")
SLR_RUN_ID=$(printf '%s' "$SLR_RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
$QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$SLR_SOURCE" --run-id "$SLR_RUN_ID" --status passed --summary "source test passed" >/dev/null

# Use raw `git worktree add` to mimic what EnterWorktree does (bare git, no qq metadata)
SLR_TARGET="$SLR_PARENT/seed-local-runtime-target-$$"
rm -rf "$SLR_TARGET"
(cd "$SLR_SOURCE" && git worktree add -b feature/test-seed-wt "$SLR_TARGET" feature/test-seed) >/dev/null 2>&1

# Test 1: happy path — copies LOCAL_RUNTIME_PATHS + state files + run records + writes metadata
SLR_OUT="$(mktemp)"
if $QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" seed-local-runtime --project "$SLR_TARGET" --source "$SLR_SOURCE" --pretty > "$SLR_OUT" 2>/dev/null && \
   $QQ_PY - "$SLR_OUT" "$SLR_TARGET" "$SLR_SOURCE" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
target = Path(sys.argv[2])
source = Path(sys.argv[3])

# Returned JSON shape
assert payload["ok"] is True
assert payload["action"] == "seed-local-runtime"
assert "scripts" in payload["copiedLocalRuntimeFiles"]
assert "qq.yaml" in payload["copiedLocalRuntimeFiles"]
assert ".mcp.json" in payload["copiedLocalRuntimeFiles"]
assert "AGENTS.md" in payload["copiedLocalRuntimeFiles"]
assert "CLAUDE.md" in payload["copiedLocalRuntimeFiles"]
assert ".qq/state/compile.json" in payload["copiedBaselineStateFiles"]
assert ".qq/state/test.json" in payload["copiedBaselineStateFiles"]
assert payload["copiedBaselineRunRecords"]

# Files actually present in target
assert (target / "scripts" / "qq-doctor.py").is_file()
# This is the bug we're explicitly fixing (agent reported scripts/platform/ missing)
assert (target / "scripts" / "platform" / "detect.sh").is_file()
assert (target / ".mcp.json").is_file()
assert (target / "qq.yaml").is_file()
assert (target / "AGENTS.md").is_file()
assert (target / "CLAUDE.md").is_file()
assert (target / ".qq" / "state" / "compile.json").is_file()
assert (target / ".qq" / "state" / "test.json").is_file()
for record_path in payload["copiedBaselineRunRecords"]:
    assert (target / record_path).is_file(), f"missing run record: {record_path}"

# Metadata file written and consumable by build_status downstream
metadata = json.loads((target / ".qq" / "state" / "worktree.json").read_text(encoding="utf-8"))
assert metadata["managedBy"] == "qq"
assert metadata["sourceBranch"] == "feature/test-seed"
assert metadata["branch"] == "feature/test-seed-wt"
assert Path(metadata["sourceWorktreePath"]).resolve() == source.resolve()
assert metadata["createdVia"] == "seed-local-runtime"
PY
then
  pass "seed-local-runtime copies LOCAL_RUNTIME_PATHS + state + run records + writes metadata"
else
  fail "seed-local-runtime copies LOCAL_RUNTIME_PATHS + state + run records + writes metadata"
fi

# Test 2: rejects --project == --source
# Wrap python in subshell that always exits 0 because pipefail would otherwise
# propagate python's expected exit 1, masking grep's match-success.
SLR_ERR2="$(mktemp)"
($QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" seed-local-runtime --project "$SLR_SOURCE" --source "$SLR_SOURCE" > "$SLR_ERR2" 2>&1 || true)
if grep -qiE "must be different|same dir" "$SLR_ERR2"; then
  pass "seed-local-runtime rejects identical --project and --source"
else
  fail "seed-local-runtime rejects identical --project and --source"
fi
rm -f "$SLR_ERR2"

# Test 3: rejects --project = subdirectory of source repo (NOT a registered worktree)
mkdir -p "$SLR_SOURCE/somesubdir"
SLR_ERR3="$(mktemp)"
($QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" seed-local-runtime --project "$SLR_SOURCE/somesubdir" --source "$SLR_SOURCE" > "$SLR_ERR3" 2>&1 || true)
if grep -qiE "not a registered git worktree|not registered" "$SLR_ERR3"; then
  pass "seed-local-runtime rejects non-worktree subdirectory of source repo"
else
  fail "seed-local-runtime rejects non-worktree subdirectory of source repo"
fi
rm -f "$SLR_ERR3"
rm -rf "$SLR_SOURCE/somesubdir"

# Test 4: rejects --project and --source from different repos
SLR_OTHER="$(mktemp -d)"
(cd "$SLR_OTHER" && git init -q && git config user.email q@e.x && git config user.name q && printf 'x\n' > x && git add x && git commit -q -m i)
SLR_ERR4="$(mktemp)"
($QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" seed-local-runtime --project "$SLR_OTHER" --source "$SLR_SOURCE" > "$SLR_ERR4" 2>&1 || true)
if grep -qiE "not linked worktrees of the same repo|different repo" "$SLR_ERR4"; then
  pass "seed-local-runtime rejects --project and --source from different repos"
else
  fail "seed-local-runtime rejects --project and --source from different repos"
fi
rm -f "$SLR_ERR4"
rm -rf "$SLR_OTHER"

# Cleanup seed-local-runtime fixtures
(cd "$SLR_SOURCE" && git worktree remove --force "$SLR_TARGET" 2>/dev/null) || rm -rf "$SLR_TARGET"
rm -rf "$SLR_SOURCE" "$SLR_OUT"

# ── clone_copy_tree hardlink path with staging atomic (v1.16.25) ──
# Tests the new allow_hardlink parameter and the staging-dir + rename pattern
# that protects source files from being corrupted on partial hardlink failure.
echo -e "${CYAN}[clone_copy_tree] hardlink + staging atomic${NC}"

# Test 5: hardlink success creates shared inodes (Linux + Windows only — macOS uses clonefile path)
if [ "$(uname -s)" = "Darwin" ]; then
  pass "clone_copy_tree(allow_hardlink=True) shares inodes (skipped on macOS — uses clonefile path)"
else
  CCT_SRC="$(mktemp -d)"
  CCT_DST="${CCT_SRC}_dst"
  rm -rf "$CCT_DST"
  mkdir -p "$CCT_SRC/sub"
  printf 'a\n' > "$CCT_SRC/file_a.txt"
  printf 'b\n' > "$CCT_SRC/sub/file_b.txt"
  CCT_HARDLINK_OUT="$(mktemp)"
  ($QQ_PY - "$CCT_SRC" "$CCT_DST" "$SCRIPT_DIR" > "$CCT_HARDLINK_OUT" 2>&1 <<'PY'
import importlib.util
import os
import sys
from pathlib import Path

scripts_dir = Path(sys.argv[3]) / "scripts"
sys.path.insert(0, str(scripts_dir))  # qq-worktree.py imports from qq_engine, qq_internal_git, etc.
spec = importlib.util.spec_from_file_location("qq_worktree", str(scripts_dir / "qq-worktree.py"))
mod = importlib.util.module_from_spec(spec)
sys.modules["qq_worktree"] = mod  # required for @dataclass on Python 3.13+
spec.loader.exec_module(mod)

src = Path(sys.argv[1])
dst = Path(sys.argv[2])
strategy = mod.clone_copy_tree(src, dst, allow_hardlink=True)
assert strategy == "hardlink", f"expected hardlink, got {strategy}"
assert os.stat(src / "file_a.txt").st_ino == os.stat(dst / "file_a.txt").st_ino, "file_a inode mismatch"
assert os.stat(src / "sub" / "file_b.txt").st_ino == os.stat(dst / "sub" / "file_b.txt").st_ino, "file_b inode mismatch"
print("ok")
PY
  ) || true
  if grep -q "^ok$" "$CCT_HARDLINK_OUT" 2>/dev/null; then
    pass "clone_copy_tree(allow_hardlink=True) shares inodes between source and target"
  else
    fail "clone_copy_tree(allow_hardlink=True) shares inodes between source and target"
    sed 's/^/    /' "$CCT_HARDLINK_OUT"
  fi
  rm -rf "$CCT_SRC" "$CCT_DST" "$CCT_HARDLINK_OUT"
fi

# Test 6: partial hardlink failure → staging cleaned up + fallback to copytree + source NOT corrupted
# Skip on macOS — the clonefile path (cp -cR) runs first and succeeds before hardlink
# is even attempted, so the fallback test premise doesn't apply.
if [ "$(uname -s)" = "Darwin" ]; then
  pass "clone_copy_tree hardlink staging falls back to copytree (skipped on macOS — uses clonefile path)"
else
CCT_SRC2="$(mktemp -d)"
CCT_DST2="${CCT_SRC2}_dst"
rm -rf "$CCT_DST2"
mkdir -p "$CCT_SRC2"
printf 'orig_content\n' > "$CCT_SRC2/keep.txt"
CCT_FALLBACK_OUT="$(mktemp)"
($QQ_PY - "$CCT_SRC2" "$CCT_DST2" "$SCRIPT_DIR" > "$CCT_FALLBACK_OUT" 2>&1 <<'PY'
import importlib.util
import os
import sys
from pathlib import Path

scripts_dir = Path(sys.argv[3]) / "scripts"
sys.path.insert(0, str(scripts_dir))
spec = importlib.util.spec_from_file_location("qq_worktree", str(scripts_dir / "qq-worktree.py"))
mod = importlib.util.module_from_spec(spec)
sys.modules["qq_worktree"] = mod  # required for @dataclass on Python 3.13+
spec.loader.exec_module(mod)

src = Path(sys.argv[1])
dst = Path(sys.argv[2])

# Capture source state BEFORE clone
src_keep = src / "keep.txt"
orig_inode = os.stat(src_keep).st_ino
orig_links = os.stat(src_keep).st_nlink
orig_content = src_keep.read_text()

# Mock os.link to always fail (simulates cross-device error / unsupported FS / partial fail)
real_link = os.link
def faulty_link(s, d, **kwargs):
    raise OSError(18, "EXDEV simulated")  # 18 = errno.EXDEV
os.link = faulty_link
try:
    strategy = mod.clone_copy_tree(src, dst, allow_hardlink=True)
finally:
    os.link = real_link

# Should have fallen back to copytree
assert strategy == "copytree", f"expected copytree fallback after hardlink failure, got {strategy}"

# Target file exists and has correct content
assert (dst / "keep.txt").exists(), "target file missing after fallback"
assert (dst / "keep.txt").read_text() == orig_content, "target file content wrong after fallback"

# Source file is unchanged: same inode, same link count, same content
assert os.stat(src_keep).st_ino == orig_inode, "source inode changed (corruption!)"
assert os.stat(src_keep).st_nlink == orig_links, f"source link count changed: {orig_links} -> {os.stat(src_keep).st_nlink}"
assert src_keep.read_text() == orig_content, "source content changed (catastrophic corruption!)"

# Staging dir should be cleaned up (no <name>.hardlink-staging sibling left over)
staging = dst.parent / (dst.name + ".hardlink-staging")
assert not staging.exists(), f"staging dir leftover: {staging}"

# Target should not be a hardlink to source (it was created by copytree, separate inode)
assert os.stat(dst / "keep.txt").st_ino != orig_inode, "target shares inode with source — copytree should have created a new file"

print("ok")
PY
) || true
if grep -q "^ok$" "$CCT_FALLBACK_OUT" 2>/dev/null; then
  pass "clone_copy_tree hardlink staging falls back to copytree without corrupting source"
else
  fail "clone_copy_tree hardlink staging falls back to copytree without corrupting source"
  sed 's/^/    /' "$CCT_FALLBACK_OUT"
fi
rm -rf "$CCT_SRC2" "$CCT_DST2" "$CCT_FALLBACK_OUT"
fi  # /Darwin skip for test 6

WORKTREE_REMOTE_ROOT="$(mktemp -d)"
WORKTREE_REMOTE_BARE="${WORKTREE_REMOTE_ROOT}_remote.git"
git init --bare -q "$WORKTREE_REMOTE_BARE"
(
  cd "$WORKTREE_REMOTE_ROOT" &&
  git init -q &&
  git config user.email qq@example.com &&
  git config user.name "qq test" &&
  printf 'base\n' > README.md &&
  git add README.md &&
  git commit -q -m "init" &&
  git branch -M feature/ship-system &&
  git remote add origin "$WORKTREE_REMOTE_BARE" &&
  git push -q -u origin feature/ship-system
)
WORKTREE_REMOTE_PARENT="$(dirname "$WORKTREE_REMOTE_ROOT")"
WORKTREE_REMOTE_JSON="$(mktemp)"
if $QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" create --project "$WORKTREE_REMOTE_ROOT" --name remote-closeout --base-dir "$WORKTREE_REMOTE_PARENT" > "$WORKTREE_REMOTE_JSON" && \
   $QQ_PY - "$WORKTREE_REMOTE_JSON" "$WORKTREE_REMOTE_ROOT" "$WORKTREE_REMOTE_BARE" "$SCRIPT_DIR" <<'PY'
import json
import subprocess
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
root = Path(sys.argv[2])
remote = Path(sys.argv[3])
script_dir = Path(sys.argv[4])
worktree = Path(payload["worktreePath"])

subprocess.run(["git", "config", "user.email", "qq@example.com"], cwd=worktree, check=True)
subprocess.run(["git", "config", "user.name", "qq test"], cwd=worktree, check=True)
(worktree / "README.md").write_text("base\nremote closeout\n", encoding="utf-8")
subprocess.run(["git", "add", "README.md"], cwd=worktree, check=True)
subprocess.run(["git", "commit", "-q", "-m", "feat: remote closeout"], cwd=worktree, check=True)
subprocess.run(["git", "push", "-q", "-u", "origin", payload["branch"]], cwd=worktree, check=True)

closeout = subprocess.check_output(
    [sys.executable, "scripts/qq-worktree.py", "closeout", "--project", str(worktree), "--auto-yes", "--delete-branch"],
    cwd=script_dir,
    text=True,
)
result = json.loads(closeout)
cleanup = result["cleanup"]
assert cleanup["deletedRemoteBranch"] is True
assert cleanup["remoteName"] == "origin"
assert cleanup["remoteBranch"] == payload["branch"]
assert not worktree.exists()
heads = subprocess.check_output(["git", "ls-remote", "--heads", str(remote)], text=True)
assert f"refs/heads/{payload['branch']}" not in heads
readme = (root / "README.md").read_text(encoding="utf-8")
assert "remote closeout" in readme
PY
then
  pass "qq-worktree closeout deletes the remote linked branch before removing the worktree"
else
  fail "qq-worktree closeout deletes the remote linked branch before removing the worktree"
fi
rm -f "$WORKTREE_REMOTE_JSON"
rm -rf "$WORKTREE_REMOTE_ROOT" "$WORKTREE_REMOTE_BARE"

WORKTREE_BLOCK_ROOT="$(mktemp -d)"
(
  cd "$WORKTREE_BLOCK_ROOT" &&
  git init -q &&
  git config user.email qq@example.com &&
  git config user.name "qq test" &&
  printf 'base\n' > README.md &&
  git add README.md &&
  git commit -q -m "init" &&
  git branch -M main
)
if $QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" create --project "$WORKTREE_BLOCK_ROOT" --name blocked >/dev/null 2>&1; then
  fail "qq-worktree blocks protected source branches by default"
else
  pass "qq-worktree blocks protected source branches by default"
fi
rm -rf "$WORKTREE_BLOCK_ROOT"

WORKTREE_DOCKER_ROOT="$(mktemp -d)"
(
  cd "$WORKTREE_DOCKER_ROOT" &&
  git init -q &&
  git config user.email qq@example.com &&
  git config user.name "qq test" &&
  mkdir -p .devcontainer scripts &&
  printf '{\"name\":\"qq-dev\"}\n' > .devcontainer/devcontainer.json &&
  cat > scripts/docker-dev.sh <<'EOF'
#!/usr/bin/env bash
exit 0
EOF
  chmod +x scripts/docker-dev.sh &&
  printf 'base\n' > README.md &&
  git add README.md .devcontainer/devcontainer.json scripts/docker-dev.sh &&
  git commit -q -m "init" &&
  git checkout -q -b feature/repo-dev
)
WORKTREE_DOCKER_CREATE_JSON="$(mktemp)"
if $QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" create --project "$WORKTREE_DOCKER_ROOT" --name docker-flow --base-dir "$(dirname "$WORKTREE_DOCKER_ROOT")" --pretty > "$WORKTREE_DOCKER_CREATE_JSON" && \
   $QQ_PY - "$WORKTREE_DOCKER_CREATE_JSON" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["recommendedExecution"]["mode"] == "docker"
labels = [item["label"] for item in payload["nextSteps"]]
assert "open-repo-dev-shell" in labels
assert "run-repo-dev-validation" in labels
assert any(item["command"] == "./scripts/docker-dev.sh shell" for item in payload["nextSteps"])
assert any(item["command"] == "./scripts/docker-dev.sh test" for item in payload["nextSteps"])
PY
then
  pass "qq-worktree create recommends Docker for repo-dev worktrees"
else
  fail "qq-worktree create recommends Docker for repo-dev worktrees"
fi
$QQ_PY - "$WORKTREE_DOCKER_CREATE_JSON" <<'PY' >/dev/null
import json
import shutil
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
worktree = Path(payload["worktreePath"])
if worktree.exists():
    shutil.rmtree(worktree)
PY
rm -f "$WORKTREE_DOCKER_CREATE_JSON"
rm -rf "$WORKTREE_DOCKER_ROOT"

WORKTREE_CLOSEOUT_ROOT="$(mktemp -d)"
WORKTREE_CLOSEOUT_REMOTE="$(mktemp -d)/origin.git"
git init --bare -q "$WORKTREE_CLOSEOUT_REMOTE"
(
  cd "$WORKTREE_CLOSEOUT_ROOT" &&
  git init -q &&
  git config user.email qq@example.com &&
  git config user.name "qq test" &&
  printf 'base\n' > README.md &&
  mkdir -p ProjectSettings Packages &&
  cat > ProjectSettings/ProjectVersion.txt <<'EOF'
m_EditorVersion: 2022.3.17f1
EOF
  cat > Packages/manifest.json <<'EOF'
{
  "dependencies": {}
}
EOF
  git add README.md ProjectSettings/ProjectVersion.txt Packages/manifest.json &&
  git commit -q -m "init" &&
  git checkout -q -b feature/crew &&
  git remote add origin "$WORKTREE_CLOSEOUT_REMOTE" &&
  "$SCRIPT_DIR/install.sh" "$WORKTREE_CLOSEOUT_ROOT" >/dev/null &&
  git add . &&
  git commit -q -m "install qq runtime" &&
  git push -q -u origin feature/crew
)
WORKTREE_CLOSEOUT_CREATE_JSON="$(mktemp)"
$QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" create --project "$WORKTREE_CLOSEOUT_ROOT" --name closeout --pretty > "$WORKTREE_CLOSEOUT_CREATE_JSON"
WORKTREE_CLOSEOUT_PATH="$($QQ_PY - "$WORKTREE_CLOSEOUT_CREATE_JSON" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
print(payload["worktreePath"])
PY
)"
(
  cd "$WORKTREE_CLOSEOUT_PATH" &&
  git config user.email qq@example.com &&
  git config user.name "qq test" &&
  printf 'linked change\n' > notes.txt &&
  git add notes.txt &&
  git commit -q -m "feat: linked worktree change" &&
  git push -q -u origin "$(git branch --show-current)"
)
WORKTREE_CLOSEOUT_RESULT="$(mktemp)"
if $QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" closeout --project "$WORKTREE_CLOSEOUT_PATH" --auto-yes --delete-branch --pretty > "$WORKTREE_CLOSEOUT_RESULT" && \
   $QQ_PY - "$WORKTREE_CLOSEOUT_RESULT" "$WORKTREE_CLOSEOUT_ROOT" "$WORKTREE_CLOSEOUT_PATH" <<'PY'
import json
import subprocess
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
root = Path(sys.argv[2]).resolve()
worktree = Path(sys.argv[3]).resolve()

assert payload["action"] == "closeout"
assert payload["mergeBack"]["pushedSourceBranch"] is True
assert payload["cleanup"]["deletedBranch"] is True
assert not worktree.exists()
head = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=root, text=True).strip()
assert head == "feature/crew"
log = subprocess.check_output(["git", "log", "--oneline", "-3"], cwd=root, text=True).strip()
assert "linked worktree change" in log
branches = subprocess.check_output(["git", "branch", "--list", "feature/crew-wt-closeout"], cwd=root, text=True).strip()
assert branches == ""
PY
then
  pass "qq-worktree closeout merges back, publishes source, and cleans up"
else
  fail "qq-worktree closeout merges back, publishes source, and cleans up"
fi
rm -f "$WORKTREE_CLOSEOUT_CREATE_JSON" "$WORKTREE_CLOSEOUT_RESULT"
rm -rf "$WORKTREE_CLOSEOUT_ROOT" "$(dirname "$WORKTREE_CLOSEOUT_REMOTE")"

WORKTREE_CODEX_ROOT="$(mktemp -d)"
(
  cd "$WORKTREE_CODEX_ROOT" &&
  git init -q &&
  git config user.email qq@example.com &&
  git config user.name "qq test" &&
  printf 'base\n' > README.md &&
  git add README.md &&
  git commit -q -m "init" &&
  git checkout -q -b feature/crew
)
WORKTREE_CODEX_PARENT="$(dirname "$WORKTREE_CODEX_ROOT")"
WORKTREE_CODEX_CREATE_JSON="$(mktemp)"
$QQ_PY "$SCRIPT_DIR/scripts/qq-worktree.py" create --project "$WORKTREE_CODEX_ROOT" --name codex-closeout --base-dir "$WORKTREE_CODEX_PARENT" --pretty > "$WORKTREE_CODEX_CREATE_JSON"
WORKTREE_CODEX_PATH="$($QQ_PY - "$WORKTREE_CODEX_CREATE_JSON" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
print(payload["worktreePath"])
PY
)"
WORKTREE_CODEX_DRY_RUN="$(mktemp)"
if $QQ_PY "$SCRIPT_DIR/scripts/qq-codex-exec.py" --project "$WORKTREE_CODEX_PATH" --dry-run --pretty "closeout" > "$WORKTREE_CODEX_DRY_RUN" && \
   $QQ_PY - "$WORKTREE_CODEX_DRY_RUN" "$WORKTREE_CODEX_ROOT" "$WORKTREE_CODEX_PATH" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
root = Path(sys.argv[2]).resolve()
worktree = Path(sys.argv[3]).resolve()
command = payload["command"]

assert payload["action"] == "dry-run"
assert payload["isManagedWorktree"] is True
assert Path(payload["sourceWorktreePath"]).resolve() == root
assert payload["defaultSandboxApplied"] is True
assert payload["defaultCdApplied"] is True
assert payload["addedSourceDir"] is True
assert command[:2] == ["codex", "exec"]
assert "--sandbox" in command
assert command[command.index("--sandbox") + 1] == "workspace-write"
assert "-C" in command
assert Path(command[command.index("-C") + 1]).resolve() == worktree
assert "--add-dir" in command
assert Path(command[command.index("--add-dir") + 1]).resolve() == root
assert command[-1] == "closeout"
PY
then
  pass "qq-codex-exec auto-resumes managed worktree closeout context"
else
  fail "qq-codex-exec auto-resumes managed worktree closeout context"
fi


mkdir -p "$WORKTREE_CODEX_PATH/.qq"
cat > "$WORKTREE_CODEX_PATH/.qq/local.yaml" <<'EOF'
trust_level: balanced
EOF

if $QQ_PY "$SCRIPT_DIR/scripts/qq-codex-exec.py" --project "$WORKTREE_CODEX_PATH" --dry-run --pretty "Summarize current state." > "$WORKTREE_CODEX_DRY_RUN" && \
   $QQ_PY - "$WORKTREE_CODEX_DRY_RUN" "$WORKTREE_CODEX_ROOT" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
root = Path(sys.argv[2]).resolve()
command = payload["command"]

assert payload["trustLevel"] == "balanced"
assert payload["sourceWorktreeAccess"] == "closeout_only"
assert payload["addedSourceDir"] is False
assert payload["addedSourceDirReason"] == "trust_level:closeout_only_blocked"
assert "--add-dir" not in command
assert Path(payload["sourceWorktreePath"]).resolve() == root
PY
then
  pass "balanced trust level blocks automatic source-worktree widening for non-closeout Codex execs"
else
  fail "balanced trust level blocks automatic source-worktree widening for non-closeout Codex execs"
fi

if $QQ_PY "$SCRIPT_DIR/scripts/qq-codex-exec.py" --project "$WORKTREE_CODEX_PATH" --dry-run --pretty "closeout" > "$WORKTREE_CODEX_DRY_RUN" && \
   $QQ_PY - "$WORKTREE_CODEX_DRY_RUN" "$WORKTREE_CODEX_ROOT" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
root = Path(sys.argv[2]).resolve()
command = payload["command"]

assert payload["trustLevel"] == "balanced"
assert payload["addedSourceDir"] is True
assert payload["addedSourceDirReason"] == "trust_level:closeout_only"
assert "--add-dir" in command
assert Path(command[command.index("--add-dir") + 1]).resolve() == root
PY
then
  pass "balanced trust level still widens source worktree access for closeout Codex execs"
else
  fail "balanced trust level still widens source worktree access for closeout Codex execs"
fi

cat > "$WORKTREE_CODEX_PATH/.qq/local.yaml" <<'EOF'
trust_level: strict
EOF

if $QQ_PY "$SCRIPT_DIR/scripts/qq-codex-exec.py" --project "$WORKTREE_CODEX_PATH" --dry-run --pretty "closeout" > "$WORKTREE_CODEX_DRY_RUN" && \
   $QQ_PY - "$WORKTREE_CODEX_DRY_RUN" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
command = payload["command"]

assert payload["trustLevel"] == "strict"
assert payload["sourceWorktreeAccess"] == "explicit"
assert payload["addedSourceDir"] is False
assert payload["addedSourceDirReason"] == "trust_level:explicit_required"
assert "--add-dir" not in command
PY
then
  pass "strict trust level requires explicit source-worktree widening"
else
  fail "strict trust level requires explicit source-worktree widening"
fi

if $QQ_PY "$SCRIPT_DIR/scripts/qq-codex-exec.py" --project "$WORKTREE_CODEX_PATH" --allow-source-worktree --dry-run --pretty "closeout" > "$WORKTREE_CODEX_DRY_RUN" && \
   $QQ_PY - "$WORKTREE_CODEX_DRY_RUN" "$WORKTREE_CODEX_ROOT" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
root = Path(sys.argv[2]).resolve()
command = payload["command"]

assert payload["trustLevel"] == "strict"
assert payload["addedSourceDir"] is True
assert payload["addedSourceDirReason"] == "flag:allow_source_worktree"
assert "--add-dir" in command
assert Path(command[command.index("--add-dir") + 1]).resolve() == root
PY
then
  pass "strict trust level can widen source worktree access explicitly"
else
  fail "strict trust level can widen source worktree access explicitly"
fi

if [ "$IS_WINDOWS" = "true" ]; then
  skip "qq-codex-exec isolates the current qq MCP server when multiple qq servers are registered" "fake codex binary has no .cmd extension; Windows can't exec it via PATHEXT"
else
FAKE_CODEX_BIN_DIR="$(mktemp -d)"
FAKE_CODEX_LOG="$(mktemp)"
CURRENT_CODEX_SERVER="$($QQ_PY - "$WORKTREE_CODEX_PATH" <<'PY'
import hashlib
import re
import sys
from pathlib import Path

project = Path(sys.argv[1]).resolve()
slug = re.sub(r"[^a-z0-9]+", "-", project.name.lower()).strip("-") or "unity-project"
digest = hashlib.sha1(str(project).encode("utf-8")).hexdigest()[:8]
print(f"qq-unity-{slug}-{digest}")
PY
)"
OTHER_CODEX_SERVER="$($QQ_PY - "$WORKTREE_CODEX_ROOT" <<'PY'
import hashlib
import re
import sys
from pathlib import Path

project = Path(sys.argv[1]).resolve()
slug = re.sub(r"[^a-z0-9]+", "-", project.name.lower()).strip("-") or "unity-project"
digest = hashlib.sha1(str(project).encode("utf-8")).hexdigest()[:8]
print(f"qq-unity-{slug}-{digest}")
PY
)"
cat > "$FAKE_CODEX_BIN_DIR/codex" <<'EOF'
#!/usr/bin/env python3
import json
import os
import sys

log_path = os.environ["FAKE_CODEX_LOG"]
current_name = os.environ["FAKE_CODEX_CURRENT_SERVER"]
other_name = os.environ["FAKE_CODEX_OTHER_SERVER"]
current_project = os.environ["FAKE_CODEX_CURRENT_PROJECT"]
other_project = os.environ["FAKE_CODEX_OTHER_PROJECT"]

def record(payload):
    with open(log_path, "a", encoding="utf-8") as handle:
        handle.write(json.dumps(payload, ensure_ascii=False) + "\n")

def registration(name, project):
    return {
        "name": name,
        "enabled": True,
        "disabled_reason": None,
        "transport": {
            "type": "stdio",
            "command": "python3",
            "args": [f"{project}/scripts/qq_mcp.py", "--project", project],
            "env": None,
            "env_vars": [],
            "cwd": None,
        },
        "enabled_tools": None,
        "disabled_tools": None,
        "startup_timeout_sec": None,
        "tool_timeout_sec": None,
    }

args = sys.argv[1:]
if args[:2] == ["mcp", "list"]:
    print("Name  Command  Args  Env  Cwd  Status  Auth")
    print(f"{other_name}  python3  {other_project}/scripts/qq_mcp.py --project {other_project}  -  -  enabled  Unsupported")
    print(f"{current_name}  python3  {current_project}/scripts/qq_mcp.py --project {current_project}  -  -  enabled  Unsupported")
    raise SystemExit(0)
if args[:2] == ["mcp", "get"]:
    name = args[2]
    if name == current_name:
        print(json.dumps(registration(name, current_project)))
        raise SystemExit(0)
    if name == other_name:
        print(json.dumps(registration(name, other_project)))
        raise SystemExit(0)
    raise SystemExit(1)
if args[:2] == ["mcp", "remove"]:
    record({"action": "remove", "name": args[2]})
    raise SystemExit(0)
if args[:2] == ["mcp", "add"]:
    sep = args.index("--")
    record({"action": "add", "name": args[2], "command": args[sep + 1], "args": args[sep + 2:]})
    raise SystemExit(0)
if args[:1] == ["exec"]:
    record({"action": "exec", "args": args[1:]})
    print("fake codex exec ok")
    raise SystemExit(0)
raise SystemExit(1)
EOF
chmod +x "$FAKE_CODEX_BIN_DIR/codex"
if PATH="$FAKE_CODEX_BIN_DIR:$PATH" \
   FAKE_CODEX_LOG="$FAKE_CODEX_LOG" \
   FAKE_CODEX_CURRENT_SERVER="$CURRENT_CODEX_SERVER" \
   FAKE_CODEX_OTHER_SERVER="$OTHER_CODEX_SERVER" \
   FAKE_CODEX_CURRENT_PROJECT="$WORKTREE_CODEX_PATH" \
   FAKE_CODEX_OTHER_PROJECT="$WORKTREE_CODEX_ROOT" \
   $QQ_PY "$SCRIPT_DIR/scripts/qq-codex-exec.py" --project "$WORKTREE_CODEX_PATH" "Use the unity_health tool" >/dev/null && \
   $QQ_PY - "$FAKE_CODEX_LOG" "$CURRENT_CODEX_SERVER" "$OTHER_CODEX_SERVER" <<'PY'
import json
import sys
from pathlib import Path

entries = [json.loads(line) for line in Path(sys.argv[1]).read_text(encoding="utf-8").splitlines() if line.strip()]
current = sys.argv[2]
other = sys.argv[3]

assert [entry["action"] for entry in entries] == ["remove", "exec", "add"]
assert entries[0]["name"] == other
assert entries[1]["action"] == "exec"
assert entries[2]["name"] == other
assert current not in {entry.get("name") for entry in entries if "name" in entry}
PY
then
  pass "qq-codex-exec isolates the current qq MCP server when multiple qq servers are registered"
else
  fail "qq-codex-exec isolates the current qq MCP server when multiple qq servers are registered"
fi
rm -rf "$FAKE_CODEX_BIN_DIR"
rm -f "$FAKE_CODEX_LOG"
fi  # end !IS_WINDOWS guard for codex MCP isolation test
rm -f "$WORKTREE_CODEX_CREATE_JSON" "$WORKTREE_CODEX_DRY_RUN"
rm -rf "$WORKTREE_CODEX_ROOT"

mkdir -p "$RUNTIME_TEST_ROOT/ProjectSettings" "$RUNTIME_TEST_ROOT/Packages" "$RUNTIME_TEST_ROOT/Temp" "$RUNTIME_TEST_ROOT/scripts"
cat > "$RUNTIME_TEST_ROOT/ProjectSettings/ProjectVersion.txt" <<'EOF'
m_EditorVersion: 2022.3.17f1
EOF
cat > "$RUNTIME_TEST_ROOT/Packages/manifest.json" <<'EOF'
{
  "dependencies": {
    "com.tyk.tykit": "https://github.com/tykisgod/tykit.git#demo"
  }
}
EOF
cat > "$RUNTIME_TEST_ROOT/.mcp.json" <<'EOF'
{
  "servers": {
    "unity": {
      "command": "mcp-unity"
    }
  }
}
EOF
for path in \
  qq-compile.sh \
  qq-test.sh \
  unity-compile-smart.sh \
  unity-test.sh \
  qq-project-state.py \
  qq-policy-check.sh \
  qq_mcp.py \
  tykit_bridge.py \
  qq-capabilities.json \
  tykit_capabilities.json; do
  : > "$RUNTIME_TEST_ROOT/scripts/$path"
done

if $QQ_PY "$SCRIPT_DIR/scripts/qq-capability.py" validate --pretty > "$RUNTIME_TEST_ROOT/capability-validate.json" && \
   $QQ_PY - "$RUNTIME_TEST_ROOT/capability-validate.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["ok"] is True
assert payload["errors"] == []
PY
then
  pass "capability registry validates"
else
  fail "capability registry validates"
fi

if $QQ_PY "$SCRIPT_DIR/scripts/qq-capability.py" resolve --engine unity --capability compile --available unity.tykit-mcp unity.unity-mcp > "$RUNTIME_TEST_ROOT/capability-resolve.json" && \
   $QQ_PY - "$RUNTIME_TEST_ROOT/capability-resolve.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["resolved"] == "unity.tykit-mcp"
assert payload["provider"]["transportAdapter"] == "mcp"
PY
then
  pass "capability resolver prefers configured provider order"
else
  fail "capability resolver prefers configured provider order"
fi

if $QQ_PY "$SCRIPT_DIR/scripts/qq-capability.py" resolve --engine unreal --capability scene.query --available unreal.runreal-mcp unreal.flop-mcp > "$RUNTIME_TEST_ROOT/capability-resolve-unreal.json" && \
   $QQ_PY - "$RUNTIME_TEST_ROOT/capability-resolve-unreal.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["resolved"] == "unreal.runreal-mcp"
assert payload["provider"]["transportAdapter"] == "mcp"
PY
then
  pass "capability resolver can fall back to compatible third-party Unreal providers"
else
  fail "capability resolver can fall back to compatible third-party Unreal providers"
fi

if $QQ_PY "$SCRIPT_DIR/scripts/qq-capability.py" resolve --engine sbox --capability compile --available sbox.qq-direct > "$RUNTIME_TEST_ROOT/capability-resolve-sbox.json" && \
   $QQ_PY - "$RUNTIME_TEST_ROOT/capability-resolve-sbox.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["resolved"] == "sbox.qq-direct"
assert payload["provider"]["transportAdapter"] == "direct"
PY
then
  pass "capability resolver can resolve the S&box direct provider"
else
  fail "capability resolver can resolve the S&box direct provider"
fi

if "$SCRIPT_DIR/scripts/qq-doctor.sh" --project "$RUNTIME_TEST_ROOT" --write-state > "$RUNTIME_TEST_ROOT/doctor.json" && \
   $QQ_PY - "$RUNTIME_TEST_ROOT/doctor.json" "$RUNTIME_TEST_ROOT/.qq/state/provider-resolution.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
state_payload = json.loads(Path(sys.argv[2]).read_text(encoding="utf-8"))

providers = {item["id"]: item for item in payload["providers"]}
assert payload["unityProjectDetected"] is True
assert payload["policy"]["sharedExists"] is True
assert payload["policy"]["localExists"] is True
assert payload["policy"]["effectiveProfile"] == "hardening"
assert payload["policy"]["effectiveProfileSource"] == "qq_local_yaml"
assert payload["policy"]["effectiveProfileExpectations"]["review_expectation"] == "required"
assert payload["policy"]["trustLevel"] == "trusted"
assert payload["policy"]["trustLevelSource"] == "profile"
assert payload["policy"]["trustLevelExpectations"]["codex_auto_resume"] is True
assert payload["controller"]["workMode"] == "prototype"
assert payload["controller"]["workModeSource"] == "qq_local_yaml"
assert payload["controller"]["modeRecommendedNext"] == "prototype_direct"
assert payload["controller"]["taskFocus"] == []
assert payload["controller"]["taskFocusSource"] == "default"
assert payload["controller"]["policyProfile"] == "hardening"
assert payload["controller"]["policyProfileSource"] == "qq_local_yaml"
assert payload["controller"]["policyProfileExpectations"]["review_expectation"] == "required"
assert payload["controller"]["trustLevel"] == "trusted"
assert payload["controller"]["trustLevelSource"] == "profile"
assert payload["controller"]["trustLevelExpectations"]["codex_source_worktree_access"] == "auto"
assert payload["controller"]["defaultTestScope"] == "all"
assert payload["controller"]["recommendedNext"] == "prototype_direct"
assert payload["controller"]["compileStatusFresh"] is True
assert payload["controller"]["compileStatusRaw"] == "passed"
assert payload["controller"]["testStatusFresh"] is True
assert payload["controller"]["testStatusRaw"] == "not_run"
assert payload["controller"]["repositoryDesignDocCount"] == 0
assert payload["controller"]["repositoryImplementationPlanCount"] == 0
assert payload["controller"]["modeProfile"]["changes_summary_expected"] is True
assert payload["controller"]["isManagedWorktree"] is False
assert payload["controller"]["worktreeRole"] == "primary"
assert payload["recommendedExecution"]["mode"] == "host"
assert payload["recommendedExecution"]["recommendedAction"] == "./scripts/qq-compile.sh"
assert "Unity" in payload["recommendedExecution"]["reason"]
assert payload["parallelAgentSafety"]["status"] == "warn"
assert "primary worktree" in payload["parallelAgentSafety"]["summary"]
assert "qq-worktree.py" in payload["parallelAgentSafety"]["recommendedAction"]
assert providers["unity.qq-direct"]["status"] == "available"
assert providers["unity.tykit-mcp"]["status"] == "available"
assert providers["unity.raw-tykit"]["status"] == "available"
assert providers["unity.mcp-unity"]["status"] == "available"
assert payload["resolution"]["compile"]["resolved"] == "unity.qq-direct"
assert payload["resolution"]["console.read"]["resolved"] == "unity.tykit-mcp"
assert state_payload["resolution"]["compile"]["resolved"] == "unity.qq-direct"
assert "gitHooks" in payload, "gitHooks section missing from doctor payload"
assert payload["gitHooks"]["status"] == "not-a-repo", payload["gitHooks"]
assert payload["gitHooks"]["isGitRepo"] is False
assert payload["gitHooks"]["issues"] == []
PY
then
  pass "qq-doctor discovers providers and writes resolution state"
else
  fail "qq-doctor discovers providers and writes resolution state"
fi

# ── core.hooksPath silent-bypass detection + safe auto-fix ──
GIT_HOOKS_TEST_ROOT="$(mktemp -d)"
(
  cd "$GIT_HOOKS_TEST_ROOT"
  git init -q
  # Reproduce the silently-broken config: hooksPath set to absolute path of
  # the default .git/hooks directory. The pirate-demo project hit this exact
  # state and the qq pre-push hook never fired as a result.
  git config core.hooksPath "$GIT_HOOKS_TEST_ROOT/.git/hooks"
)
if "$SCRIPT_DIR/scripts/qq-doctor.sh" --project "$GIT_HOOKS_TEST_ROOT" > "$GIT_HOOKS_TEST_ROOT/doctor.json" && \
   $QQ_PY - "$GIT_HOOKS_TEST_ROOT/doctor.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
hooks = payload["gitHooks"]
assert hooks["isGitRepo"] is True, hooks
assert hooks["status"] == "broken", hooks
assert hooks["hooksPathScope"] == "local", hooks
assert hooks["hooksPathIsAbsolute"] is True, hooks
assert hooks["autoFixable"] is True, hooks
assert hooks["autoFixCommand"] == "git config --unset core.hooksPath", hooks
assert hooks["recommendedAction"] == "git config --unset core.hooksPath", hooks
assert hooks["issues"], hooks
PY
then
  pass "qq-doctor flags hardcoded core.hooksPath as broken"
else
  fail "qq-doctor flags hardcoded core.hooksPath as broken"
fi

# Apply --fix-git-hooks and verify the local config was actually unset.
if "$SCRIPT_DIR/scripts/qq-doctor.sh" --project "$GIT_HOOKS_TEST_ROOT" --fix-git-hooks > "$GIT_HOOKS_TEST_ROOT/doctor-fix.json" && \
   $QQ_PY - "$GIT_HOOKS_TEST_ROOT/doctor-fix.json" "$GIT_HOOKS_TEST_ROOT" <<'PY'
import json
import subprocess
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
project = sys.argv[2]
fix = payload.get("gitHooksFix")
assert fix is not None, payload
assert fix["status"] == "fixed", fix
assert fix["command"] == "git config --unset core.hooksPath", fix
result = subprocess.run(
    ["git", "-C", project, "config", "--local", "--get", "core.hooksPath"],
    capture_output=True, text=True,
)
# git returns 1 (or 5) when the key is unset and produces no output.
assert result.returncode != 0, f"hooksPath still set: {result.stdout!r}"
assert payload["gitHooks"]["status"] == "ok", payload["gitHooks"]
PY
then
  pass "qq-doctor --fix-git-hooks safely unsets the bad local core.hooksPath"
else
  fail "qq-doctor --fix-git-hooks safely unsets the bad local core.hooksPath"
fi

# When .githooks/ contains hooks, the auto-fix should switch to .githooks
# instead of unsetting (preserves the user-side hooks convention).
GIT_HOOKS_ALT_ROOT="$(mktemp -d)"
(
  cd "$GIT_HOOKS_ALT_ROOT"
  git init -q
  git config core.hooksPath "$GIT_HOOKS_ALT_ROOT/.git/hooks"
  mkdir -p .githooks
  printf '#!/bin/sh\nexit 0\n' > .githooks/pre-push
  chmod +x .githooks/pre-push
)
if "$SCRIPT_DIR/scripts/qq-doctor.sh" --project "$GIT_HOOKS_ALT_ROOT" --fix-git-hooks > "$GIT_HOOKS_ALT_ROOT/doctor.json" && \
   $QQ_PY - "$GIT_HOOKS_ALT_ROOT/doctor.json" "$GIT_HOOKS_ALT_ROOT" <<'PY'
import json
import subprocess
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
project = sys.argv[2]
fix = payload["gitHooksFix"]
assert fix["command"] == "git config core.hooksPath .githooks", fix
assert fix["altHooksDirHasHooks"] is True, fix
result = subprocess.run(
    ["git", "-C", project, "config", "--local", "--get", "core.hooksPath"],
    capture_output=True, text=True,
)
assert result.returncode == 0 and result.stdout.strip() == ".githooks", result.stdout
PY
then
  pass "qq-doctor --fix-git-hooks switches to .githooks when it has hooks"
else
  fail "qq-doctor --fix-git-hooks switches to .githooks when it has hooks"
fi

rm -rf "$GIT_HOOKS_TEST_ROOT" "$GIT_HOOKS_ALT_ROOT"

MCP_TRUST_TEST_ROOT="$(mktemp -d)"
mkdir -p "$MCP_TRUST_TEST_ROOT/ProjectSettings" "$MCP_TRUST_TEST_ROOT/Packages"
cat > "$MCP_TRUST_TEST_ROOT/ProjectSettings/ProjectVersion.txt" <<'EOF'
m_EditorVersion: 2022.3.56f1
EOF
cat > "$MCP_TRUST_TEST_ROOT/Packages/manifest.json" <<'EOF'
{
  "dependencies": {}
}
EOF
cat > "$MCP_TRUST_TEST_ROOT/qq.yaml" <<'EOF'
version: 1
default_profile: feature
trust_level: strict
EOF

if $QQ_PY - "$SCRIPT_DIR" "$MCP_TRUST_TEST_ROOT" <<'PY'
import sys
from pathlib import Path

script_dir = Path(sys.argv[1]).resolve() / "scripts"
project_dir = Path(sys.argv[2]).resolve()
sys.path.insert(0, str(script_dir))
from qq_mcp import build_bridge

standard_names = {tool["name"] for tool in build_bridge(str(project_dir), profile="standard").list_tools()}
full_names = {tool["name"] for tool in build_bridge(str(project_dir), profile="full").list_tools()}

assert "unity_raw_command" not in standard_names
assert "unity_raw_command" in full_names
PY
then
  pass "strict trust level hides raw engine commands from the standard MCP surface"
else
  fail "strict trust level hides raw engine commands from the standard MCP surface"
fi

if (
  cd "$RUNTIME_TEST_ROOT" &&
  "$SCRIPT_DIR/scripts/qq-policy-check.sh" --json Sample.cs > policy.json &&
  $QQ_PY - <<'PY'
import json
from pathlib import Path

payload = json.loads(Path("policy.json").read_text(encoding="utf-8"))
rule_ids = {item["rule_id"] for item in payload["findings"]}
assert payload["finding_count"] >= 3
assert "get_component_in_hot_path" in rule_ids
assert "send_message" in rule_ids
assert "tag_compare" in rule_ids
PY
); then
  pass "policy checker finds deterministic violations"
else
  fail "policy checker finds deterministic violations"
fi

if $QQ_PY "$SCRIPT_DIR/scripts/eval/run-benchmarks.py" --suite "$SCRIPT_DIR/docs/evals/foundation-smoke.json" > "$RUNTIME_TEST_ROOT/eval-suite.json" && \
   $QQ_PY - "$RUNTIME_TEST_ROOT/eval-suite.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["suite_id"] == "foundation-smoke"
assert payload["failed"] == 0
assert payload["passed"] == 3
PY
then
  pass "eval harness runs foundation smoke suite"
else
  fail "eval harness runs foundation smoke suite"
fi

if $QQ_PY "$SCRIPT_DIR/scripts/eval/run-benchmarks.py" --suite "$SCRIPT_DIR/docs/evals/collaboration-multi-actor.json" > "$RUNTIME_TEST_ROOT/collaboration-eval-suite.json" && \
   $QQ_PY - "$RUNTIME_TEST_ROOT/collaboration-eval-suite.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["suite_id"] == "collaboration-multi-actor"
assert payload["failed"] == 0
assert payload["passed"] == 1
PY
then
  pass "eval harness runs collaboration multi-actor suite"
else
  fail "eval harness runs collaboration multi-actor suite"
fi

if $QQ_PY "$SCRIPT_DIR/scripts/eval/run-benchmarks.py" --suite "$SCRIPT_DIR/docs/evals/qq-bench-foundation.json" > "$RUNTIME_TEST_ROOT/qq-bench-foundation.json" && \
   $QQ_PY - "$RUNTIME_TEST_ROOT/qq-bench-foundation.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["suite_id"] == "qq-bench-foundation"
assert payload["benchmark_family"] == "qq-bench-foundation"
assert payload["benchmark_version"] == "0.1"
assert payload["task_count"] == 4
assert payload["failed"] == 0
assert payload["passed"] == 4
PY
then
  pass "QQ-Bench foundation suite runs"
else
  fail "QQ-Bench foundation suite runs"
fi

if $QQ_PY "$SCRIPT_DIR/scripts/eval/run-benchmarks.py" --suite "$SCRIPT_DIR/docs/evals/qq-bench-core-v0.json" > "$RUNTIME_TEST_ROOT/qq-bench-core-v0.json" && \
   $QQ_PY - "$RUNTIME_TEST_ROOT/qq-bench-core-v0.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["suite_id"] == "qq-bench-core-v0"
assert payload["benchmark_family"] == "qq-bench-core"
assert payload["benchmark_version"] == "0.1"
assert payload["task_count"] == 10
assert payload["failed"] == 0
assert payload["passed"] == 10
PY
then
  pass "QQ-Bench core v0 suite runs"
else
  fail "QQ-Bench core v0 suite runs"
fi

if $QQ_PY "$SCRIPT_DIR/scripts/eval/run-benchmarks.py" --suite "$SCRIPT_DIR/docs/evals/qq-bench-core-v1.json" > "$RUNTIME_TEST_ROOT/qq-bench-core-v1.json" && \
   $QQ_PY - "$RUNTIME_TEST_ROOT/qq-bench-core-v1.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["suite_id"] == "qq-bench-core-v1"
assert payload["benchmark_family"] == "qq-bench-core"
assert payload["benchmark_version"] == "0.2"
assert payload["task_count"] == 12
assert payload["failed"] == 0
assert payload["passed"] == 12
PY
then
  pass "QQ-Bench core v1 suite runs"
else
  fail "QQ-Bench core v1 suite runs"
fi

if $QQ_PY "$SCRIPT_DIR/scripts/eval/run-benchmarks.py" --suite "$SCRIPT_DIR/docs/evals/qq-bench-core-solver-v0.json" > "$RUNTIME_TEST_ROOT/qq-bench-core-solver-v0.json" && \
   $QQ_PY - "$RUNTIME_TEST_ROOT/qq-bench-core-solver-v0.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["suite_id"] == "qq-bench-core-solver-v0"
assert payload["benchmark_family"] == "qq-bench-core"
assert payload["benchmark_version"] == "0.3"
assert payload["task_count"] == 2
assert payload["failed"] == 0
assert payload["passed"] == 2
PY
then
  pass "QQ-Bench core solver v0 suite runs"
else
  fail "QQ-Bench core solver v0 suite runs"
fi

for idx in 1 2 3; do
  RUN_JSON=$($QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" start --project "$RUNTIME_TEST_ROOT" --stage test --command "prune-$idx" --backend test --transport local --summary "prune start $idx")
  RUN_ID=$(printf '%s' "$RUN_JSON" | $QQ_PY -c 'import json,sys; print(json.load(sys.stdin)["run_id"])')
  $QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" finish --project "$RUNTIME_TEST_ROOT" --run-id "$RUN_ID" --status passed --summary "prune finish $idx" >/dev/null
done

if $QQ_PY "$SCRIPT_DIR/scripts/qq-run-record.py" prune --project "$RUNTIME_TEST_ROOT" --max-runs 2 --max-age-days 365 --max-telemetry-bytes 1 --max-telemetry-files 1 > "$RUNTIME_TEST_ROOT/prune-result.json" && \
   $QQ_PY - "$RUNTIME_TEST_ROOT" "$RUNTIME_TEST_ROOT/prune-result.json" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
result = json.loads(Path(sys.argv[2]).read_text(encoding="utf-8"))
run_files = sorted((root / ".qq" / "runs").glob("*.json"))
rotated = sorted((root / ".qq" / "telemetry").glob("events-*.jsonl"))

assert result["runs_removed_count"] >= 1
assert result["telemetry_rotated"] != ""
assert len(run_files) <= 2
assert len(rotated) == 1
assert (root / ".qq" / "state" / "latest.json").is_file()
PY
then
  pass "runtime prune enforces retention and rotates telemetry"
else
  fail "runtime prune enforces retention and rotates telemetry"
fi

rm -rf "$RUNTIME_TEST_ROOT"

GODOT_RUNTIME_ROOT="$(mktemp -d)"
mkdir -p "$GODOT_RUNTIME_ROOT/scripts" "$GODOT_RUNTIME_ROOT/addons/qq_editor_bridge" "$GODOT_RUNTIME_ROOT/.qq/state"
cat > "$GODOT_RUNTIME_ROOT/project.godot" <<'EOF'
; Engine configuration file.
config_version=5

[application]
config/name="qq godot runtime fixture"

[editor_plugins]
enabled=PackedStringArray("res://addons/qq_editor_bridge/plugin.cfg")
EOF
cat > "$GODOT_RUNTIME_ROOT/.mcp.json" <<EOF
{
  "mcpServers": {
    "qq-godot": {
      "command": "python3",
      "args": [
        "$GODOT_RUNTIME_ROOT/scripts/qq_mcp.py",
        "--project",
        "$GODOT_RUNTIME_ROOT"
      ],
      "cwd": "$GODOT_RUNTIME_ROOT"
    }
  }
}
EOF
cat > "$GODOT_RUNTIME_ROOT/.qq/state/qq-godot-editor-bridge.json" <<EOF
{
  "ok": true,
  "running": true,
  "lastHeartbeatUnix": $($QQ_PY -c 'import time; print(time.time())')
}
EOF
for path in \
  qq-compile.sh \
  qq-test.sh \
  qq-project-state.py \
  qq-policy-check.sh \
  qq_mcp.py \
  qq_engine.py \
  qq-capabilities.json \
  godot_bridge.py \
  godot_capabilities.json; do
  : > "$GODOT_RUNTIME_ROOT/scripts/$path"
done
cat > "$GODOT_RUNTIME_ROOT/addons/qq_editor_bridge/plugin.cfg" <<'EOF'
[plugin]
name="QQ Editor Bridge"
EOF
cat > "$GODOT_RUNTIME_ROOT/addons/qq_editor_bridge/plugin.gd" <<'EOF'
@tool
extends EditorPlugin
EOF

if "$SCRIPT_DIR/scripts/qq-doctor.sh" --project "$GODOT_RUNTIME_ROOT" --write-state > "$GODOT_RUNTIME_ROOT/doctor.json" && \
   $QQ_PY - "$GODOT_RUNTIME_ROOT/doctor.json" "$GODOT_RUNTIME_ROOT/.qq/state/provider-resolution.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
state_payload = json.loads(Path(sys.argv[2]).read_text(encoding="utf-8"))
providers = {item["id"]: item for item in payload["providers"]}

assert payload["engine"] == "godot"
assert payload["engineProjectDetected"] is True
assert payload["unityProjectDetected"] is None
assert providers["godot.qq-direct"]["status"] == "available"
assert providers["godot.qq-mcp"]["status"] == "available"
assert providers["godot.qq-mcp"]["evidence"]["pluginEnabled"] is True
assert providers["godot.qq-mcp"]["evidence"]["bridgeState"]["running"] is True
assert payload["resolution"]["console.read"]["resolved"] == "godot.qq-mcp"
assert payload["resolution"]["scene.query"]["resolved"] == "godot.qq-mcp"
assert payload["resolution"]["asset.mutate"]["resolved"] == "godot.qq-mcp"
assert payload["resolution"]["input.simulate"]["resolved"] == "godot.qq-mcp"
assert payload["resolution"]["ui.query"]["resolved"] == "godot.qq-mcp"
assert payload["resolution"]["animation.mutate"]["resolved"] == "godot.qq-mcp"
assert payload["resolution"]["capture.screenshot"]["resolved"] == "godot.qq-mcp"
assert state_payload["resolution"]["scene.mutate"]["resolved"] == "godot.qq-mcp"
PY
then
  pass "qq-doctor discovers Godot rich bridge providers and resolves editor capabilities"
else
  fail "qq-doctor discovers Godot rich bridge providers and resolves editor capabilities"
fi

mkdir -p "$GODOT_RUNTIME_ROOT/.qq/state/qq-godot-editor/requests" "$GODOT_RUNTIME_ROOT/.qq/state/qq-godot-editor/responses"
$QQ_PY - "$GODOT_RUNTIME_ROOT" <<'PY' &
import json
import sys
import time
from pathlib import Path

root = Path(sys.argv[1])
requests = root / ".qq" / "state" / "qq-godot-editor" / "requests"
responses = root / ".qq" / "state" / "qq-godot-editor" / "responses"
deadline = time.time() + 10
while time.time() < deadline:
    for request_path in requests.glob("*.json"):
        payload = json.loads(request_path.read_text(encoding="utf-8"))
        response = {
            "ok": True,
            "message": "fake godot bridge handled request",
            "data": {
                "command": payload["command"],
                "args": payload.get("args") or {},
            },
        }
        (responses / f"{payload['requestId']}.json").write_text(json.dumps(response), encoding="utf-8")
        request_path.unlink()
        raise SystemExit(0)
    time.sleep(0.05)
raise SystemExit(1)
PY
FAKE_GODOT_BRIDGE_PID=$!
if $QQ_PY "$SCRIPT_DIR/scripts/godot_bridge.py" --project "$GODOT_RUNTIME_ROOT" --tool godot_query --arguments '{"action":"status"}' > "$GODOT_RUNTIME_ROOT/godot-bridge-call.json" && \
   wait "$FAKE_GODOT_BRIDGE_PID" && \
   $QQ_PY - "$GODOT_RUNTIME_ROOT/godot-bridge-call.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["ok"] is True
assert payload["action"] == "status"
assert payload["response"]["command"] == "status"
assert payload["response"]["args"] == {}
PY
then
  pass "godot bridge queue transport can complete a typed query round trip"
else
  fail "godot bridge queue transport can complete a typed query round trip"
  kill "$FAKE_GODOT_BRIDGE_PID" >/dev/null 2>&1 || true
fi

$QQ_PY - "$GODOT_RUNTIME_ROOT" <<'PY' &
import json
import sys
import time
from pathlib import Path

root = Path(sys.argv[1])
requests = root / ".qq" / "state" / "qq-godot-editor" / "requests"
responses = root / ".qq" / "state" / "qq-godot-editor" / "responses"
state = root / ".qq" / "state" / "qq-godot-editor-bridge.json"
deadline = time.time() + 10
handled = 0
while time.time() < deadline:
    state.write_text(json.dumps({"ok": True, "running": True, "lastHeartbeatUnix": time.time()}), encoding="utf-8")
    for request_path in requests.glob("*.json"):
        payload = json.loads(request_path.read_text(encoding="utf-8"))
        response = {
            "ok": True,
            "message": "fake godot bridge handled request",
            "data": {
                "command": payload["command"],
                "args": payload.get("args") or {},
            },
        }
        (responses / f"{payload['requestId']}.json").write_text(json.dumps(response), encoding="utf-8")
        request_path.unlink()
        handled += 1
        if handled >= 4:
            raise SystemExit(0)
    time.sleep(0.05)
raise SystemExit(1)
PY
FAKE_GODOT_BRIDGE_PID=$!
if $QQ_PY "$SCRIPT_DIR/scripts/godot_bridge.py" --project "$GODOT_RUNTIME_ROOT" --profile full --tool godot_batch --arguments '{"operations":[{"tool":"godot_input","arguments":{"action":"inject_action","input_action":"jump","strength":1.0}},{"tool":"godot_ui","arguments":{"action":"create_control","parent":".","node_type":"Button","name":"QQButton","text":"Parity"}},{"tool":"godot_animation","arguments":{"action":"create_animation","player_path":"AnimationPlayer","animation":"qq_spin","length":0.5}},{"tool":"godot_screenshot","arguments":{"path":".qq/state/screenshots/test.png","width":640,"height":360}}]}' > "$GODOT_RUNTIME_ROOT/godot-full-batch-call.json" && \
   wait "$FAKE_GODOT_BRIDGE_PID" && \
   $QQ_PY - "$GODOT_RUNTIME_ROOT/godot-full-batch-call.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["ok"] is True
assert len(payload["results"]) == 4
assert payload["results"][0]["result"]["response"]["command"] == "inject-action"
assert payload["results"][0]["result"]["response"]["args"]["input_action"] == "jump"
assert payload["results"][1]["result"]["response"]["command"] == "create-control"
assert payload["results"][1]["result"]["response"]["args"]["name"] == "QQButton"
assert payload["results"][2]["result"]["response"]["command"] == "create-animation"
assert payload["results"][2]["result"]["response"]["args"]["animation"] == "qq_spin"
assert payload["results"][3]["result"]["response"]["command"] == "capture-screenshot"
assert payload["results"][3]["result"]["response"]["args"]["width"] == 640
PY
then
  pass "godot full-profile bridge maps input, UI, animation, and screenshot tools onto the editor command surface"
else
  fail "godot full-profile bridge maps input, UI, animation, and screenshot tools onto the editor command surface"
fi

if $QQ_PY - "$GODOT_RUNTIME_ROOT" "$SCRIPT_DIR/scripts" <<'PY'
import sys
from pathlib import Path

sys.path.insert(0, sys.argv[2])
from qq_mcp import build_bridge  # noqa: E402

project = Path(sys.argv[1])
bridge = build_bridge(str(project))
tools = {tool["name"] for tool in bridge.list_tools()}
assert "qq_project_state" in tools
assert "godot_query" in tools
assert "godot_object" in tools
assert "godot_assets" in tools
PY
then
  pass "qq_mcp composes generic and Godot rich tools for Godot projects"
else
  fail "qq_mcp composes generic and Godot rich tools for Godot projects"
fi

if $QQ_PY - "$GODOT_RUNTIME_ROOT" "$SCRIPT_DIR/scripts" <<'PY'
import sys
from pathlib import Path

sys.path.insert(0, sys.argv[2])
from qq_mcp import build_bridge  # noqa: E402

project = Path(sys.argv[1])
bridge = build_bridge(str(project), profile="full")
tools = {tool["name"] for tool in bridge.list_tools()}
assert "godot_input" in tools
assert "godot_ui" in tools
assert "godot_animation" in tools
assert "godot_screenshot" in tools
PY
then
  pass "qq_mcp full profile exposes Godot input, UI, animation, and screenshot tools"
else
  fail "qq_mcp full profile exposes Godot input, UI, animation, and screenshot tools"
fi

rm -rf "$GODOT_RUNTIME_ROOT"

GODOT_SCRIPT_TEST_ROOT="$(mktemp -d)"
mkdir -p "$GODOT_SCRIPT_TEST_ROOT/addons/gut" "$GODOT_SCRIPT_TEST_ROOT/test/unit"
cat > "$GODOT_SCRIPT_TEST_ROOT/project.godot" <<'EOF'
; Engine configuration file.
config_version=5

[application]
config/name="qq godot script fixture"
EOF
cat > "$GODOT_SCRIPT_TEST_ROOT/addons/gut/gut_cmdln.gd" <<'EOF'
extends SceneTree
EOF
cat > "$GODOT_SCRIPT_TEST_ROOT/test/unit/test_smoke.gd" <<'EOF'
extends GutTest
EOF
FAKE_GODOT_BIN_DIR="$(mktemp -d)"
FAKE_GODOT_LOG="$FAKE_GODOT_BIN_DIR/godot.log"
cat > "$FAKE_GODOT_BIN_DIR/godot4" <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
printf '%s\n' "$*" >> "__LOG__"
if [[ "$*" == *"--import"* ]]; then
  exit 0
fi
if [[ "$*" == *"gut_cmdln.gd"* ]]; then
  if [[ "$*" == *"-ginclude_subdirs"* ]]; then
    printf '1/1 passed\n'
    exit 0
  fi
  printf '\033[31m[ERROR]:  \033[0mNothing was run.\n'
  printf 'On the one hand nothing failed, on the other hand nothing did anything.\n'
  exit 0
fi
printf '{"ok":true,"finding_count":0}\n'
exit 0
EOF
$QQ_PY - "$FAKE_GODOT_BIN_DIR/godot4" "$FAKE_GODOT_LOG" <<'PY'
import sys
from pathlib import Path

script = Path(sys.argv[1])
log_path = sys.argv[2]
script.write_text(script.read_text(encoding="utf-8").replace("__LOG__", log_path), encoding="utf-8")
PY
chmod +x "$FAKE_GODOT_BIN_DIR/godot4"
if env PATH="$FAKE_GODOT_BIN_DIR:$PATH" "$SCRIPT_DIR/scripts/godot-test.sh" --project "$GODOT_SCRIPT_TEST_ROOT" > "$GODOT_SCRIPT_TEST_ROOT/godot-test.log" && \
   grep -q -- '--import' "$FAKE_GODOT_LOG" && \
   grep -q -- '-ginclude_subdirs' "$FAKE_GODOT_LOG" && \
   grep -q 'GUT tests passed' "$GODOT_SCRIPT_TEST_ROOT/godot-test.log"
then
  pass "godot-test imports projects first and scans GUT test subdirectories"
else
  fail "godot-test imports projects first and scans GUT test subdirectories"
fi

FAKE_GODOT_FAIL_BIN_DIR="$(mktemp -d)"
cat > "$FAKE_GODOT_FAIL_BIN_DIR/godot4" <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
if [[ "$*" == *"--import"* ]]; then
  exit 0
fi
printf '\033[31m[ERROR]:  \033[0mNothing was run.\n'
printf 'On the one hand nothing failed, on the other hand nothing did anything.\n'
exit 0
EOF
chmod +x "$FAKE_GODOT_FAIL_BIN_DIR/godot4"
if env PATH="$FAKE_GODOT_FAIL_BIN_DIR:$PATH" "$SCRIPT_DIR/scripts/godot-test.sh" --project "$GODOT_SCRIPT_TEST_ROOT" > "$GODOT_SCRIPT_TEST_ROOT/godot-test-empty.log" 2>&1; then
  fail "godot-test rejects empty GUT runs"
else
  if grep -q 'GUT did not discover any tests' "$GODOT_SCRIPT_TEST_ROOT/godot-test-empty.log"; then
    pass "godot-test rejects empty GUT runs"
  else
    fail "godot-test rejects empty GUT runs"
  fi
fi

FAKE_GODOT_COMPILE_BIN_DIR="$(mktemp -d)"
FAKE_GODOT_COMPILE_LOG="$FAKE_GODOT_COMPILE_BIN_DIR/godot.log"
cat > "$FAKE_GODOT_COMPILE_BIN_DIR/godot4" <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
printf '%s\n' "$*" >> "__LOG__"
if [[ "$*" == *"--import"* ]]; then
  exit 0
fi
printf '{"ok":true,"finding_count":0}\n'
exit 0
EOF
$QQ_PY - "$FAKE_GODOT_COMPILE_BIN_DIR/godot4" "$FAKE_GODOT_COMPILE_LOG" <<'PY'
import sys
from pathlib import Path

script = Path(sys.argv[1])
log_path = sys.argv[2]
script.write_text(script.read_text(encoding="utf-8").replace("__LOG__", log_path), encoding="utf-8")
PY
chmod +x "$FAKE_GODOT_COMPILE_BIN_DIR/godot4"
mkdir -p "$GODOT_SCRIPT_TEST_ROOT/scripts"
cp "$SCRIPT_DIR/scripts/godot-compile-check.gd" "$GODOT_SCRIPT_TEST_ROOT/scripts/godot-compile-check.gd"
if env PATH="$FAKE_GODOT_COMPILE_BIN_DIR:$PATH" "$SCRIPT_DIR/scripts/godot-compile.sh" --project "$GODOT_SCRIPT_TEST_ROOT" > "$GODOT_SCRIPT_TEST_ROOT/godot-compile.log" && \
   $QQ_PY - "$FAKE_GODOT_COMPILE_LOG" <<'PY'
import sys
from pathlib import Path

lines = [line.strip() for line in Path(sys.argv[1]).read_text(encoding="utf-8").splitlines() if line.strip()]
assert len(lines) == 2
assert "--import" in lines[0]
assert "godot-compile-check.gd" in lines[1]
PY
then
  pass "godot-compile imports projects before running compile checks"
else
  fail "godot-compile imports projects before running compile checks"
fi

rm -rf "$GODOT_SCRIPT_TEST_ROOT" "$FAKE_GODOT_BIN_DIR" "$FAKE_GODOT_FAIL_BIN_DIR" "$FAKE_GODOT_COMPILE_BIN_DIR"

UNREAL_RUNTIME_ROOT="$(mktemp -d)"
mkdir -p "$UNREAL_RUNTIME_ROOT/scripts" "$UNREAL_RUNTIME_ROOT/Content/Python" "$UNREAL_RUNTIME_ROOT/.qq/state/qq-unreal-editor/requests" "$UNREAL_RUNTIME_ROOT/.qq/state/qq-unreal-editor/responses"
cat > "$UNREAL_RUNTIME_ROOT/FPSGame.uproject" <<'EOF'
{
  "FileVersion": 3,
  "EngineAssociation": "5.7",
  "Plugins": [
    {
      "Name": "PythonScriptPlugin",
      "Enabled": true
    },
    {
      "Name": "EditorScriptingUtilities",
      "Enabled": true
    },
    {
      "Name": "McpAutomationBridge",
      "Enabled": true
    },
    {
      "Name": "UnrealMCP",
      "Enabled": true
    }
  ]
}
EOF
mkdir -p "$UNREAL_RUNTIME_ROOT/Config" "$UNREAL_RUNTIME_ROOT/Plugins/McpAutomationBridge" "$UNREAL_RUNTIME_ROOT/Plugins/UnrealMCP"
cat > "$UNREAL_RUNTIME_ROOT/Config/DefaultEngine.ini" <<'EOF'
[/Script/PythonScriptPlugin.PythonScriptPluginSettings]
EnableRemoteExecution=True
+StartupScripts=import qq_unreal_bridge; qq_unreal_bridge.start()
EOF
cat > "$UNREAL_RUNTIME_ROOT/Plugins/McpAutomationBridge/McpAutomationBridge.uplugin" <<'EOF'
{
  "FileVersion": 3,
  "FriendlyName": "McpAutomationBridge"
}
EOF
cat > "$UNREAL_RUNTIME_ROOT/Plugins/UnrealMCP/UnrealMCP.uplugin" <<'EOF'
{
  "FileVersion": 3,
  "FriendlyName": "UnrealMCP"
}
EOF
cat > "$UNREAL_RUNTIME_ROOT/.mcp.json" <<EOF
{
  "mcpServers": {
    "qq-unreal": {
      "command": "python3",
      "args": [
        "$UNREAL_RUNTIME_ROOT/scripts/qq_mcp.py",
        "--project",
        "$UNREAL_RUNTIME_ROOT"
      ],
      "cwd": "$UNREAL_RUNTIME_ROOT"
    },
    "unreal-engine": {
      "command": "npx",
      "args": [
        "unreal-engine-mcp-server"
      ],
      "env": {
        "UE_PROJECT_PATH": "$UNREAL_RUNTIME_ROOT/FPSGame.uproject",
        "MCP_AUTOMATION_PORT": "8091"
      }
    },
    "unreal": {
      "command": "npx",
      "args": [
        "-y",
        "@runreal/unreal-mcp"
      ]
    },
    "flopperam-unreal": {
      "url": "https://agent.flopperam.com/mcp",
      "headers": {
        "Authorization": "Bearer test-key"
      }
    }
  }
}
EOF
cat > "$UNREAL_RUNTIME_ROOT/.qq/state/qq-unreal-mcp-host.json" <<EOF
{
  "lastInitializeAt": "2026-03-31T00:00:00Z",
  "clientInfo": {
    "name": "fake-host"
  },
  "protocolVersion": "2024-11-05"
}
EOF
cat > "$UNREAL_RUNTIME_ROOT/.qq/state/qq-unreal-editor-bridge.json" <<EOF
{
  "ok": true,
  "running": true,
  "lastHeartbeatUnix": $($QQ_PY -c 'import time; print(time.time())')
}
EOF
for path in \
  qq-compile.sh \
  qq-test.sh \
  qq-project-state.py \
  qq-policy-check.sh \
  qq_mcp.py \
  qq_engine.py \
  qq-capabilities.json \
  unreal_bridge.py \
  unreal_editor_command.py \
  unreal_capabilities.json; do
  : > "$UNREAL_RUNTIME_ROOT/scripts/$path"
done
: > "$UNREAL_RUNTIME_ROOT/Content/Python/qq_unreal_bridge.py"

if "$SCRIPT_DIR/scripts/qq-doctor.sh" --project "$UNREAL_RUNTIME_ROOT" --write-state > "$UNREAL_RUNTIME_ROOT/doctor.json" && \
   $QQ_PY - "$UNREAL_RUNTIME_ROOT/doctor.json" "$UNREAL_RUNTIME_ROOT/.qq/state/provider-resolution.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
state_payload = json.loads(Path(sys.argv[2]).read_text(encoding="utf-8"))
providers = {item["id"]: item for item in payload["providers"]}

assert payload["engine"] == "unreal"
assert payload["engineProjectDetected"] is True
assert payload["unityProjectDetected"] is None
assert providers["unreal.qq-direct"]["status"] == "available"
assert providers["unreal.qq-mcp"]["status"] == "available"
assert providers["unreal.unreal-engine-mcp"]["status"] == "available"
assert providers["unreal.runreal-mcp"]["status"] == "available"
assert providers["unreal.flop-mcp"]["status"] == "available"
assert providers["unreal.qq-mcp"]["evidence"]["missingPlugins"] == []
assert providers["unreal.qq-mcp"]["evidence"]["startup"]["bootstrapInstalled"] is True
assert providers["unreal.qq-mcp"]["evidence"]["startup"]["startupConfigured"] is True
assert providers["unreal.qq-mcp"]["evidence"]["hostConnection"]["verified"] is True
assert providers["unreal.qq-mcp"]["evidence"]["bridgeState"]["running"] is True
assert providers["unreal.unreal-engine-mcp"]["evidence"]["plugin"]["enabled"] is True
assert providers["unreal.runreal-mcp"]["evidence"]["remoteExecution"]["enabled"] is True
assert providers["unreal.flop-mcp"]["evidence"]["plugin"]["enabled"] is True
assert payload["resolution"]["console.read"]["resolved"] == "unreal.qq-mcp"
assert payload["resolution"]["scene.query"]["resolved"] == "unreal.qq-mcp"
assert payload["resolution"]["asset.mutate"]["resolved"] == "unreal.qq-mcp"
assert state_payload["resolution"]["scene.mutate"]["resolved"] == "unreal.qq-mcp"
PY
then
  pass "qq-doctor discovers Unreal rich bridge providers and resolves editor capabilities"
else
  fail "qq-doctor discovers Unreal rich bridge providers and resolves editor capabilities"
fi

$QQ_PY - "$UNREAL_RUNTIME_ROOT" <<'PY' &
import json
import sys
import time
from pathlib import Path

root = Path(sys.argv[1])
requests = root / ".qq" / "state" / "qq-unreal-editor" / "requests"
responses = root / ".qq" / "state" / "qq-unreal-editor" / "responses"
console = root / ".qq" / "state" / "qq-unreal-editor-console.jsonl"
state = root / ".qq" / "state" / "qq-unreal-editor-bridge.json"
deadline = time.time() + 10
while time.time() < deadline:
    state.write_text(json.dumps({"ok": True, "running": True, "lastHeartbeatUnix": time.time()}), encoding="utf-8")
    for request_path in requests.glob("*.json"):
        payload = json.loads(request_path.read_text(encoding="utf-8"))
        response = {
            "ok": True,
            "message": "fake unreal bridge handled request",
            "data": {
                "command": payload["command"],
                "args": payload.get("args") or {},
            },
        }
        (responses / f"{payload['requestId']}.json").write_text(json.dumps(response), encoding="utf-8")
        with console.open("a", encoding="utf-8") as handle:
            handle.write(json.dumps({"event": "handled", "command": payload["command"]}) + "\n")
        request_path.unlink()
        raise SystemExit(0)
    time.sleep(0.05)
raise SystemExit(1)
PY
FAKE_UNREAL_BRIDGE_PID=$!
if $QQ_PY "$SCRIPT_DIR/scripts/unreal_bridge.py" --project "$UNREAL_RUNTIME_ROOT" --tool unreal_query --arguments '{"action":"status"}' > "$UNREAL_RUNTIME_ROOT/unreal-bridge-call.json" && \
   wait "$FAKE_UNREAL_BRIDGE_PID" && \
   $QQ_PY - "$UNREAL_RUNTIME_ROOT/unreal-bridge-call.json" "$UNREAL_RUNTIME_ROOT/.qq/state/qq-unreal-editor-console.jsonl" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
console_text = Path(sys.argv[2]).read_text(encoding="utf-8")

assert payload["ok"] is True
assert payload["action"] == "status"
assert payload["response"]["command"] == "status"
assert payload["response"]["args"] == {}
assert '"command": "status"' in console_text
assert payload["message"] == "fake unreal bridge handled request"
PY
then
  pass "unreal bridge queue transport can complete a typed query round trip"
else
  fail "unreal bridge queue transport can complete a typed query round trip"
fi

$QQ_PY - "$UNREAL_RUNTIME_ROOT" <<'PY' &
import json
import sys
import time
from pathlib import Path

root = Path(sys.argv[1])
requests = root / ".qq" / "state" / "qq-unreal-editor" / "requests"
responses = root / ".qq" / "state" / "qq-unreal-editor" / "responses"
state = root / ".qq" / "state" / "qq-unreal-editor-bridge.json"
deadline = time.time() + 10
handled = 0
while time.time() < deadline:
    state.write_text(json.dumps({"ok": True, "running": True, "lastHeartbeatUnix": time.time()}), encoding="utf-8")
    for request_path in requests.glob("*.json"):
        payload = json.loads(request_path.read_text(encoding="utf-8"))
        response = {
            "ok": True,
            "message": "fake unreal bridge handled request",
            "data": {
                "command": payload["command"],
                "args": payload.get("args") or {},
            },
        }
        (responses / f"{payload['requestId']}.json").write_text(json.dumps(response), encoding="utf-8")
        request_path.unlink()
        handled += 1
        if handled >= 2:
            raise SystemExit(0)
    time.sleep(0.05)
raise SystemExit(1)
PY
FAKE_UNREAL_BRIDGE_PID=$!
if $QQ_PY "$SCRIPT_DIR/scripts/unreal_bridge.py" --project "$UNREAL_RUNTIME_ROOT" --tool unreal_batch --arguments '{"operations":[{"tool":"unreal_object","arguments":{"action":"create","class_path":"/Script/Engine.EmptyActor","label":"QQActor","select":true}},{"tool":"unreal_assets","arguments":{"action":"create_material","path":"/Game/QQ/M_Test"}}]}' > "$UNREAL_RUNTIME_ROOT/unreal-batch-call.json" && \
   wait "$FAKE_UNREAL_BRIDGE_PID" && \
   $QQ_PY - "$UNREAL_RUNTIME_ROOT/unreal-batch-call.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["ok"] is True
assert len(payload["results"]) == 2
assert payload["results"][0]["result"]["action"] == "create"
assert payload["results"][0]["result"]["response"]["command"] == "create-actor"
assert payload["results"][0]["result"]["response"]["args"]["label"] == "QQActor"
assert payload["results"][1]["result"]["action"] == "create_material"
assert payload["results"][1]["result"]["response"]["command"] == "create-material"
assert payload["results"][1]["result"]["response"]["args"]["path"] == "/Game/QQ/M_Test"
PY
then
  pass "unreal batch bridge maps object and asset actions onto the rich command surface"
else
  fail "unreal batch bridge maps object and asset actions onto the rich command surface"
fi

if $QQ_PY - "$UNREAL_RUNTIME_ROOT" "$SCRIPT_DIR/scripts" <<'PY'
import sys
from pathlib import Path

sys.path.insert(0, sys.argv[2])
from qq_mcp import build_bridge  # noqa: E402

project = Path(sys.argv[1])
bridge = build_bridge(str(project))
tools = {tool["name"] for tool in bridge.list_tools()}
assert "qq_project_state" in tools
assert "unreal_query" in tools
assert "unreal_object" in tools
assert "unreal_assets" in tools
PY
then
  pass "qq_mcp composes generic and Unreal rich tools for Unreal projects"
else
  fail "qq_mcp composes generic and Unreal rich tools for Unreal projects"
fi

rm -rf "$UNREAL_RUNTIME_ROOT"

UNREAL_SCRIPT_TEST_ROOT="$(mktemp -d)"
mkdir -p "$UNREAL_SCRIPT_TEST_ROOT/scripts"
cat > "$UNREAL_SCRIPT_TEST_ROOT/FPSGame.uproject" <<'EOF'
{
  "FileVersion": 3,
  "EngineAssociation": "5.7",
  "Plugins": [
    {
      "Name": "PythonScriptPlugin",
      "Enabled": true
    },
    {
      "Name": "EditorScriptingUtilities",
      "Enabled": true
    }
  ]
}
EOF
cp "$SCRIPT_DIR/scripts/unreal-compile-check.py" "$UNREAL_SCRIPT_TEST_ROOT/scripts/unreal-compile-check.py"

FAKE_UNREAL_BIN_DIR="$(mktemp -d)"
FAKE_UNREAL_LOG="$FAKE_UNREAL_BIN_DIR/unreal.log"
cat > "$FAKE_UNREAL_BIN_DIR/UnrealEditor-Cmd" <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
printf '%s\n' "$*" >> "__LOG__"
if [[ -n "${QQ_UNREAL_OUTPUT_PATH:-}" ]]; then
  printf '{"ok":true,"finding_count":0}\n' > "$QQ_UNREAL_OUTPUT_PATH"
  exit 0
fi
if [[ "$*" == *"Automation RunTests"* ]]; then
  printf 'Automation Test Queue Empty\n'
  exit 0
fi
exit 0
EOF
$QQ_PY - "$FAKE_UNREAL_BIN_DIR/UnrealEditor-Cmd" "$FAKE_UNREAL_LOG" <<'PY'
import sys
from pathlib import Path

script = Path(sys.argv[1])
log_path = sys.argv[2]
script.write_text(script.read_text(encoding="utf-8").replace("__LOG__", log_path), encoding="utf-8")
PY
chmod +x "$FAKE_UNREAL_BIN_DIR/UnrealEditor-Cmd"

if [ "$IS_WINDOWS" = "true" ]; then
  skip "unreal-compile invokes the project-local compile check through UnrealEditor-Cmd" "Windows path comparison in fixture log; tracked for follow-up"
elif env PATH="$FAKE_UNREAL_BIN_DIR:$PATH" "$SCRIPT_DIR/scripts/qq-compile.sh" --project "$UNREAL_SCRIPT_TEST_ROOT" > "$UNREAL_SCRIPT_TEST_ROOT/unreal-compile.log" && \
   $QQ_PY - "$FAKE_UNREAL_LOG" "$UNREAL_SCRIPT_TEST_ROOT/unreal-compile.log" "$UNREAL_SCRIPT_TEST_ROOT" <<'PY'
import sys
from pathlib import Path

# Normalize paths to forward slashes so the assertion is OS-independent.
log_text = Path(sys.argv[1]).read_text(encoding="utf-8").replace("\\", "/")
compile_text = Path(sys.argv[2]).read_text(encoding="utf-8")
project_root = Path(sys.argv[3])
expected_script = (project_root / "scripts" / "unreal-compile-check.py").as_posix()

assert f"-ExecutePythonScript={expected_script}" in log_text
assert "Unreal compile/check passed" in compile_text
PY
then
  pass "unreal-compile invokes the project-local compile check through UnrealEditor-Cmd"
else
  fail "unreal-compile invokes the project-local compile check through UnrealEditor-Cmd"
fi

if env PATH="$FAKE_UNREAL_BIN_DIR:$PATH" "$SCRIPT_DIR/scripts/qq-test.sh" editmode --project "$UNREAL_SCRIPT_TEST_ROOT" > "$UNREAL_SCRIPT_TEST_ROOT/unreal-test.log" && \
   $QQ_PY - "$FAKE_UNREAL_LOG" "$UNREAL_SCRIPT_TEST_ROOT/unreal-test.log" <<'PY'
import sys
from pathlib import Path

log_text = Path(sys.argv[1]).read_text(encoding="utf-8")
test_text = Path(sys.argv[2]).read_text(encoding="utf-8")

assert "Automation RunTests Project.Editor; Quit" in log_text
assert "Unreal automation tests passed" in test_text
PY
then
  pass "qq-test maps Unreal editmode runs onto the editor automation filter"
else
  fail "qq-test maps Unreal editmode runs onto the editor automation filter"
fi

FAKE_UNREAL_FAIL_BIN_DIR="$(mktemp -d)"
cat > "$FAKE_UNREAL_FAIL_BIN_DIR/UnrealEditor-Cmd" <<'EOF'
#!/usr/bin/env bash
set -euo pipefail
printf 'No automation tests matched\n'
exit 0
EOF
chmod +x "$FAKE_UNREAL_FAIL_BIN_DIR/UnrealEditor-Cmd"
if env PATH="$FAKE_UNREAL_FAIL_BIN_DIR:$PATH" "$SCRIPT_DIR/scripts/unreal-test.sh" --project "$UNREAL_SCRIPT_TEST_ROOT" > "$UNREAL_SCRIPT_TEST_ROOT/unreal-test-empty.log" 2>&1; then
  fail "unreal-test rejects empty automation runs"
else
  if grep -q 'Unreal automation did not discover any tests' "$UNREAL_SCRIPT_TEST_ROOT/unreal-test-empty.log"; then
    pass "unreal-test rejects empty automation runs"
  else
    fail "unreal-test rejects empty automation runs"
  fi
fi

rm -rf "$UNREAL_SCRIPT_TEST_ROOT" "$FAKE_UNREAL_BIN_DIR" "$FAKE_UNREAL_FAIL_BIN_DIR"

SBOX_RUNTIME_ROOT="$(mktemp -d)"
mkdir -p \
  "$SBOX_RUNTIME_ROOT/scripts" \
  "$SBOX_RUNTIME_ROOT/Code" \
  "$SBOX_RUNTIME_ROOT/Editor/QQ" \
  "$SBOX_RUNTIME_ROOT/Assets/Scenes" \
  "$SBOX_RUNTIME_ROOT/Libraries/Core/Code" \
  "$SBOX_RUNTIME_ROOT/Libraries/Core/Assets" \
  "$SBOX_RUNTIME_ROOT/UnitTests" \
  "$SBOX_RUNTIME_ROOT/.qq/state/qq-sbox-editor/requests" \
  "$SBOX_RUNTIME_ROOT/.qq/state/qq-sbox-editor/responses"
: > "$SBOX_RUNTIME_ROOT/.sbproj"
: > "$SBOX_RUNTIME_ROOT/Game.sln"
: > "$SBOX_RUNTIME_ROOT/Game.csproj"
: > "$SBOX_RUNTIME_ROOT/UnitTests/Game.UnitTests.csproj"
cat > "$SBOX_RUNTIME_ROOT/Code/Player.cs" <<'EOF'
using System.IO;

public sealed class PlayerHud
{
    public void Tick()
    {
        Console.Log("bad");
        File.Exists("user://save.dat");
    }
}
EOF
cat > "$SBOX_RUNTIME_ROOT/qq.yaml" <<'EOF'
engine: sbox
default_profile: feature
EOF
cat > "$SBOX_RUNTIME_ROOT/.mcp.json" <<'EOF'
{
  "mcpServers": {
    "qq-sbox": {
      "command": "python3",
      "args": [
        "__SBOX_RUNTIME_ROOT__/scripts/qq_mcp.py",
        "--project",
        "__SBOX_RUNTIME_ROOT__"
      ],
      "cwd": "__SBOX_RUNTIME_ROOT__"
    }
  }
}
EOF
$QQ_PY - "$SBOX_RUNTIME_ROOT/.mcp.json" "$SBOX_RUNTIME_ROOT" <<'PY'
from pathlib import Path
import sys

path = Path(sys.argv[1])
text = path.read_text(encoding="utf-8")
text = text.replace("__SBOX_RUNTIME_ROOT__", sys.argv[2])
path.write_text(text, encoding="utf-8")
PY
cat > "$SBOX_RUNTIME_ROOT/.qq/state/qq-sbox-mcp-host.json" <<EOF
{
  "lastInitializeAt": "2026-03-31T00:00:00Z",
  "clientInfo": {
    "name": "fake-host"
  },
  "protocolVersion": "2024-11-05"
}
EOF
cat > "$SBOX_RUNTIME_ROOT/.qq/state/qq-sbox-editor-bridge.json" <<EOF
{
  "ok": true,
  "running": true,
  "lastHeartbeatUnix": $($QQ_PY -c 'import time; print(time.time())')
}
EOF
cat > "$SBOX_RUNTIME_ROOT/Assets/Scenes/Main.scene" <<'EOF'
scene {}
EOF
cat > "$SBOX_RUNTIME_ROOT/Libraries/Core/Assets/Core.scene" <<'EOF'
scene {}
EOF
for path in \
  qq-compile.sh \
  qq-test.sh \
  qq-project-state.py \
  qq-policy-check.sh \
  qq-doctor.py \
  qq_mcp.py \
  qq_engine.py \
  qq-capabilities.json \
  sbox-compile.sh \
  sbox-test.sh \
  sbox_bridge.py \
  sbox_capabilities.json; do
  : > "$SBOX_RUNTIME_ROOT/scripts/$path"
done
: > "$SBOX_RUNTIME_ROOT/Editor/QQ/QQSboxEditorBridge.cs"
FAKE_SBOX_DOCTOR_BIN_DIR="$(mktemp -d)"
cat > "$FAKE_SBOX_DOCTOR_BIN_DIR/dotnet" <<'EOF'
#!/usr/bin/env bash
exit 0
EOF
chmod +x "$FAKE_SBOX_DOCTOR_BIN_DIR/dotnet"
if env PATH="$FAKE_SBOX_DOCTOR_BIN_DIR:$PATH" "$SCRIPT_DIR/scripts/qq-doctor.sh" --project "$SBOX_RUNTIME_ROOT" --write-state > "$SBOX_RUNTIME_ROOT/doctor.json" && \
   $QQ_PY - "$SBOX_RUNTIME_ROOT/doctor.json" "$SBOX_RUNTIME_ROOT/.qq/state/provider-resolution.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
state_payload = json.loads(Path(sys.argv[2]).read_text(encoding="utf-8"))
providers = {item["id"]: item for item in payload["providers"]}

assert payload["engine"] == "sbox"
assert payload["sboxProjectDetected"] is True
assert payload["sboxProjectFile"] == ".sbproj"
assert payload["sboxUnitTestsPresent"] is True
assert payload["sboxLibraryCount"] == 1
assert payload["sboxEditorProjectPresent"] is True
assert providers["sbox.qq-direct"]["status"] == "available"
assert providers["sbox.qq-mcp"]["status"] == "available"
assert providers["sbox.qq-direct"]["evidence"]["unitTestsPresent"] is True
assert providers["sbox.qq-mcp"]["evidence"]["hostConnection"]["verified"] is True
assert providers["sbox.qq-mcp"]["evidence"]["bridgeState"]["running"] is True
assert payload["resolution"]["compile"]["resolved"] == "sbox.qq-direct"
assert payload["resolution"]["test"]["resolved"] == "sbox.qq-direct"
assert payload["resolution"]["console.read"]["resolved"] == "sbox.qq-mcp"
assert payload["resolution"]["scene.query"]["resolved"] == "sbox.qq-mcp"
assert payload["resolution"]["scene.mutate"]["resolved"] == "sbox.qq-mcp"
assert payload["resolution"]["asset.query"]["resolved"] == "sbox.qq-mcp"
assert payload["resolution"]["asset.mutate"]["resolved"] == "sbox.qq-mcp"
assert state_payload["resolution"]["policy.check"]["resolved"] == "sbox.qq-direct"
PY
then
  pass "qq-doctor detects the S&box direct runtime, live bridge, and rich capability resolution"
else
  fail "qq-doctor detects the S&box direct runtime, live bridge, and rich capability resolution"
fi

if $QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$SBOX_RUNTIME_ROOT" --no-write > "$SBOX_RUNTIME_ROOT/project-state.json" && \
   $QQ_PY - "$SBOX_RUNTIME_ROOT/project-state.json" <<'PY'
import json
import sys
from pathlib import Path

state = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert state["engine"] == "sbox"
assert state["sbox_project_detected"] is True
assert state["sbox_project_file"] == ".sbproj"
assert state["sbox_unit_tests_present"] is True
assert state["sbox_library_count"] == 1
assert state["sbox_editor_project_present"] is True
PY
then
  pass "qq-project-state exposes S&box project facts"
else
  fail "qq-project-state exposes S&box project facts"
fi

if "$SCRIPT_DIR/scripts/qq-policy-check.sh" --project "$SBOX_RUNTIME_ROOT" --json Code/Player.cs > "$SBOX_RUNTIME_ROOT/sbox-policy.json" && \
   $QQ_PY - "$SBOX_RUNTIME_ROOT/sbox-policy.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
rule_ids = {item["rule_id"] for item in payload["findings"]}
assert payload["engine"] == "sbox"
assert "sbox_whitelist_violation" in rule_ids
assert payload["finding_count"] >= 2
PY
then
  pass "qq-policy-check reports deterministic S&box whitelist violations"
else
  fail "qq-policy-check reports deterministic S&box whitelist violations"
fi

$QQ_PY - "$SBOX_RUNTIME_ROOT" <<'PY' &
import json
import sys
import time
from pathlib import Path

root = Path(sys.argv[1])
requests = root / ".qq" / "state" / "qq-sbox-editor" / "requests"
responses = root / ".qq" / "state" / "qq-sbox-editor" / "responses"
state = root / ".qq" / "state" / "qq-sbox-editor-bridge.json"
console = root / ".qq" / "state" / "qq-sbox-editor-console.jsonl"
deadline = time.time() + 10
while time.time() < deadline:
    state.write_text(json.dumps({"ok": True, "running": True, "lastHeartbeatUnix": time.time()}), encoding="utf-8")
    for request_path in requests.glob("*.json"):
        payload = json.loads(request_path.read_text(encoding="utf-8"))
        response = {
            "ok": True,
            "message": "fake sbox bridge handled request",
            "data": {
                "command": payload["command"],
                "args": payload.get("args") or {}
            }
        }
        (responses / f"{payload['requestId']}.json").write_text(json.dumps(response), encoding="utf-8")
        with console.open("a", encoding="utf-8") as handle:
            handle.write(json.dumps({"event": "handled", "command": payload["command"]}) + "\n")
        request_path.unlink()
        raise SystemExit(0)
    time.sleep(0.05)
raise SystemExit(1)
PY
FAKE_SBOX_BRIDGE_PID=$!
if $QQ_PY "$SCRIPT_DIR/scripts/sbox_bridge.py" --project "$SBOX_RUNTIME_ROOT" --tool sbox_query --arguments '{"action":"status"}' > "$SBOX_RUNTIME_ROOT/sbox-bridge-call.json" && \
   wait "$FAKE_SBOX_BRIDGE_PID" && \
   $QQ_PY - "$SBOX_RUNTIME_ROOT/sbox-bridge-call.json" "$SBOX_RUNTIME_ROOT/.qq/state/qq-sbox-editor-console.jsonl" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
console_text = Path(sys.argv[2]).read_text(encoding="utf-8")
assert payload["ok"] is True
assert payload["action"] == "status"
assert payload["response"]["command"] == "status"
assert payload["response"]["args"] == {}
assert '"command": "status"' in console_text
PY
then
  pass "sbox bridge queue transport can complete a typed S&box query round trip"
else
  fail "sbox bridge queue transport can complete a typed S&box query round trip"
fi

$QQ_PY - "$SBOX_RUNTIME_ROOT" <<'PY' &
import json
import sys
import time
from pathlib import Path

root = Path(sys.argv[1])
requests = root / ".qq" / "state" / "qq-sbox-editor" / "requests"
responses = root / ".qq" / "state" / "qq-sbox-editor" / "responses"
state = root / ".qq" / "state" / "qq-sbox-editor-bridge.json"
deadline = time.time() + 10
handled = 0
while time.time() < deadline:
    state.write_text(json.dumps({"ok": True, "running": True, "lastHeartbeatUnix": time.time()}), encoding="utf-8")
    for request_path in requests.glob("*.json"):
        payload = json.loads(request_path.read_text(encoding="utf-8"))
        response = {
            "ok": True,
            "message": "fake sbox bridge handled request",
            "data": {
                "command": payload["command"],
                "args": payload.get("args") or {}
            }
        }
        (responses / f"{payload['requestId']}.json").write_text(json.dumps(response), encoding="utf-8")
        request_path.unlink()
        handled += 1
        if handled >= 2:
            raise SystemExit(0)
    time.sleep(0.05)
raise SystemExit(1)
PY
FAKE_SBOX_BRIDGE_PID=$!
if $QQ_PY "$SCRIPT_DIR/scripts/sbox_bridge.py" --project "$SBOX_RUNTIME_ROOT" --tool sbox_batch --arguments '{"operations":[{"tool":"sbox_editor","arguments":{"action":"open_scene","path":"Assets/Scenes/Main.scene"}},{"tool":"sbox_object","arguments":{"action":"select","path":"Player"}}]}' > "$SBOX_RUNTIME_ROOT/sbox-batch-call.json" && \
   wait "$FAKE_SBOX_BRIDGE_PID" && \
   $QQ_PY - "$SBOX_RUNTIME_ROOT/sbox-batch-call.json" <<'PY'
import json
import sys
from pathlib import Path

payload = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert payload["ok"] is True
assert len(payload["results"]) == 2
assert payload["results"][0]["result"]["response"]["command"] == "open-scene"
assert payload["results"][1]["result"]["response"]["command"] == "select-object"
PY
then
  pass "sbox bridge batch transport can compose editor and object operations"
else
  fail "sbox bridge batch transport can compose editor and object operations"
fi

if $QQ_PY - "$SBOX_RUNTIME_ROOT" "$SCRIPT_DIR/scripts" <<'PY'
import sys
from pathlib import Path

sys.path.insert(0, sys.argv[2])
from qq_mcp import build_bridge  # noqa: E402

project = Path(sys.argv[1])
bridge = build_bridge(str(project))
tools = {tool["name"] for tool in bridge.list_tools()}
assert "qq_project_state" in tools
assert "sbox_editor" in tools
assert "sbox_query" in tools
assert "sbox_object" in tools
assert "sbox_scene" in tools
assert "sbox_assets" in tools
PY
then
  pass "qq_mcp composes generic and S&box rich tools for S&box projects"
else
  fail "qq_mcp composes generic and S&box rich tools for S&box projects"
fi

cat > "$SBOX_RUNTIME_ROOT/.qq/state/qq-sbox-editor-bridge.json" <<'EOF'
{
  "ok": true,
  "running": false,
  "lastHeartbeatUnix": 0
}
EOF
if $QQ_PY "$SCRIPT_DIR/scripts/sbox_bridge.py" --project "$SBOX_RUNTIME_ROOT" --tool sbox_query --arguments '{"action":"list_scenes","count":10}' > "$SBOX_RUNTIME_ROOT/sbox-local-scenes.json" && \
   $QQ_PY "$SCRIPT_DIR/scripts/sbox_bridge.py" --project "$SBOX_RUNTIME_ROOT" --tool sbox_query --arguments '{"action":"list_assets","count":10}' > "$SBOX_RUNTIME_ROOT/sbox-local-query-assets.json" && \
   $QQ_PY "$SCRIPT_DIR/scripts/sbox_bridge.py" --project "$SBOX_RUNTIME_ROOT" --tool sbox_scene --arguments '{"action":"duplicate_scene","source":"Assets/Scenes/Main.scene","target":"Assets/Scenes/Main_LocalCopy.scene"}' > "$SBOX_RUNTIME_ROOT/sbox-local-duplicate.json" && \
   $QQ_PY "$SCRIPT_DIR/scripts/sbox_bridge.py" --project "$SBOX_RUNTIME_ROOT" --tool sbox_assets --arguments '{"action":"create_directory","path":"Assets/Generated"}' > "$SBOX_RUNTIME_ROOT/sbox-local-assets.json" && \
   $QQ_PY - "$SBOX_RUNTIME_ROOT/sbox-local-scenes.json" "$SBOX_RUNTIME_ROOT/sbox-local-query-assets.json" "$SBOX_RUNTIME_ROOT/sbox-local-duplicate.json" "$SBOX_RUNTIME_ROOT/sbox-local-assets.json" "$SBOX_RUNTIME_ROOT" <<'PY'
import json
import sys
from pathlib import Path

scenes = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
query_assets = json.loads(Path(sys.argv[2]).read_text(encoding="utf-8"))
duplicate = json.loads(Path(sys.argv[3]).read_text(encoding="utf-8"))
assets = json.loads(Path(sys.argv[4]).read_text(encoding="utf-8"))
root = Path(sys.argv[5])

items = scenes["response"]["items"]
asset_items = query_assets["response"]["items"]
assert any(item["path"] == "Assets/Scenes/Main.scene" for item in items)
assert scenes["message"].endswith("(local fallback)")
assert any(item["path"] == "Assets/Scenes/Main.scene" for item in asset_items)
assert query_assets["message"].endswith("(local fallback)")
assert duplicate["response"]["target"] == "Assets/Scenes/Main_LocalCopy.scene"
assert (root / "Assets" / "Scenes" / "Main_LocalCopy.scene").is_file()
assert assets["response"]["path"] == "Assets/Generated"
assert (root / "Assets" / "Generated").is_dir()
PY
then
  pass "sbox typed query and asset tools fall back to direct project file operations when the live bridge is inactive"
else
  fail "sbox typed query and asset tools fall back to direct project file operations when the live bridge is inactive"
fi

rm -rf "$SBOX_RUNTIME_ROOT" "$FAKE_SBOX_DOCTOR_BIN_DIR"

SBOX_SCRIPT_TEST_ROOT="$(mktemp -d)"
mkdir -p "$SBOX_SCRIPT_TEST_ROOT/UnitTests"
: > "$SBOX_SCRIPT_TEST_ROOT/.sbproj"
: > "$SBOX_SCRIPT_TEST_ROOT/Game.sln"
: > "$SBOX_SCRIPT_TEST_ROOT/UnitTests/Game.UnitTests.csproj"
cat > "$SBOX_SCRIPT_TEST_ROOT/UnitTests/SmokeTests.cs" <<'EOF'
public sealed class SmokeTests {}
EOF
FAKE_SBOX_BIN_DIR="$(mktemp -d)"
FAKE_SBOX_LOG="$FAKE_SBOX_BIN_DIR/dotnet.log"
cat > "$FAKE_SBOX_BIN_DIR/dotnet" <<'EOF'
#!/usr/bin/env bash
printf '%s\n' "$*" >> "__FAKE_DOTNET_LOG__"
exit 0
EOF
$QQ_PY - "$FAKE_SBOX_BIN_DIR/dotnet" "$FAKE_SBOX_LOG" <<'PY'
from pathlib import Path
import sys

path = Path(sys.argv[1])
text = path.read_text(encoding="utf-8")
text = text.replace("__FAKE_DOTNET_LOG__", sys.argv[2])
path.write_text(text, encoding="utf-8")
PY
chmod +x "$FAKE_SBOX_BIN_DIR/dotnet"
if [ "$IS_WINDOWS" = "true" ]; then
  skip "qq-compile and qq-test route S&box projects onto dotnet build/test targets" "Windows path comparison in fixture log; tracked for follow-up"
elif env PATH="$FAKE_SBOX_BIN_DIR:$PATH" "$SCRIPT_DIR/scripts/qq-compile.sh" --project "$SBOX_SCRIPT_TEST_ROOT" > "$SBOX_SCRIPT_TEST_ROOT/sbox-compile.log" && \
   env PATH="$FAKE_SBOX_BIN_DIR:$PATH" "$SCRIPT_DIR/scripts/qq-test.sh" all --project "$SBOX_SCRIPT_TEST_ROOT" > "$SBOX_SCRIPT_TEST_ROOT/sbox-test.log" && \
   $QQ_PY - "$FAKE_SBOX_LOG" "$SBOX_SCRIPT_TEST_ROOT" <<'PY'
from pathlib import Path
import sys

# Normalize log lines and expected paths to forward slashes for cross-OS parity.
lines = [line.replace("\\", "/") for line in Path(sys.argv[1]).read_text(encoding="utf-8").splitlines()]
root = Path(sys.argv[2])
expected_sln = (root / "Game.sln").as_posix()
expected_csproj = (root / "UnitTests" / "Game.UnitTests.csproj").as_posix()
assert any(line.startswith(f"build {expected_sln}") for line in lines)
assert any(line.startswith(f"test {expected_csproj}") for line in lines)
PY
then
  pass "qq-compile and qq-test route S&box projects onto dotnet build/test targets"
else
  fail "qq-compile and qq-test route S&box projects onto dotnet build/test targets"
fi
rm -rf "$SBOX_SCRIPT_TEST_ROOT" "$FAKE_SBOX_BIN_DIR"

# ── execute checkpoint ──
echo -e "${CYAN}[checkpoint] execute checkpoint lifecycle${NC}"

CKPT_ROOT="$(mktemp -d)"
mkdir -p "$CKPT_ROOT/Docs/qq"
cat > "$CKPT_ROOT/Docs/qq/test_plan.md" <<'EOF'
# Test Plan
- [ ] **Step 1: Create interface**
- [ ] **Step 2: Implement service**
- [ ] **Step 3: Add tests**
EOF

if $QQ_PY "$SCRIPT_DIR/scripts/qq-execute-checkpoint.py" save \
     --project "$CKPT_ROOT" --plan "Docs/qq/test_plan.md" --step 0 --total 3 --mode direct --status running >/dev/null && \
   $QQ_PY "$SCRIPT_DIR/scripts/qq-execute-checkpoint.py" save \
     --project "$CKPT_ROOT" --plan "Docs/qq/test_plan.md" --step 1 --total 3 --mode direct --step-title "Create interface" >/dev/null && \
   $QQ_PY - "$CKPT_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
progress = json.loads((root / ".qq" / "state" / "execute-progress.json").read_text(encoding="utf-8"))
plan_text = (root / "Docs" / "qq" / "test_plan.md").read_text(encoding="utf-8")

assert progress["status"] == "running"
assert progress["completed_step"] == 1
assert progress["completed_steps"] == [1]
assert progress["total_steps"] == 3
assert "- [x] **Step 1: Create interface**" in plan_text
assert "- [ ] **Step 2: Implement service**" in plan_text
PY
then
  pass "checkpoint save updates progress JSON and plan checkbox by step title"
else
  fail "checkpoint save updates progress JSON and plan checkbox by step title"
fi

if $QQ_PY "$SCRIPT_DIR/scripts/qq-execute-checkpoint.py" resume --project "$CKPT_ROOT" --format hint | grep -q "1/3 steps completed" && \
   $QQ_PY "$SCRIPT_DIR/scripts/qq-execute-checkpoint.py" resume --project "$CKPT_ROOT" | $QQ_PY -c 'import json,sys; d=json.load(sys.stdin); assert d["status"]=="running"; assert d["completed_step"]==1'
then
  pass "checkpoint resume returns progress in hint and json formats"
else
  fail "checkpoint resume returns progress in hint and json formats"
fi

if $QQ_PY "$SCRIPT_DIR/scripts/qq-execute-checkpoint.py" clear --project "$CKPT_ROOT" >/dev/null && \
   RESUME=$($QQ_PY "$SCRIPT_DIR/scripts/qq-execute-checkpoint.py" resume --project "$CKPT_ROOT") && \
   [ "$RESUME" = "{}" ]
then
  pass "checkpoint clear marks execution complete and resume returns empty"
else
  fail "checkpoint clear marks execution complete and resume returns empty"
fi

# positional fallback when step title not found
cat > "$CKPT_ROOT/Docs/qq/test_plan.md" <<'EOF'
# Test Plan
- [ ] **Step 1: Create interface**
- [ ] **Step 2: Implement service**
- [ ] **Step 3: Add tests**
EOF
rm -f "$CKPT_ROOT/.qq/state/execute-progress.json"

if $QQ_PY "$SCRIPT_DIR/scripts/qq-execute-checkpoint.py" save \
     --project "$CKPT_ROOT" --plan "Docs/qq/test_plan.md" --step 2 --total 3 --mode direct --step-title "NONEXISTENT TITLE" >/dev/null && \
   grep -q '\[x\].*Step 2' "$CKPT_ROOT/Docs/qq/test_plan.md"
then
  pass "checkpoint falls back to positional matching when step title not found"
else
  fail "checkpoint falls back to positional matching when step title not found"
fi

# project-state detects active execution
rm -f "$CKPT_ROOT/.qq/state/execute-progress.json"
$QQ_PY "$SCRIPT_DIR/scripts/qq-execute-checkpoint.py" save \
  --project "$CKPT_ROOT" --plan "Docs/qq/test_plan.md" --step 1 --total 3 --mode coordinator --status running >/dev/null

if $QQ_PY "$SCRIPT_DIR/scripts/qq-project-state.py" --project "$CKPT_ROOT" --no-write | \
   $QQ_PY -c 'import json,sys; d=json.load(sys.stdin); assert d["execute_in_progress"]==True; assert "test_plan" in d["recommended_next"]'
then
  pass "project-state detects active execution and overrides recommended_next"
else
  fail "project-state detects active execution and overrides recommended_next"
fi

# hooks.json has SessionStart[compact] entry
if $QQ_PY - <<'PY'
import json
hooks = json.load(open("hooks/hooks.json", encoding="utf-8"))["hooks"]
assert "SessionStart" in hooks
entries = hooks["SessionStart"]
assert any(e["matcher"] == "compact" for e in entries)
compact_hooks = [e for e in entries if e["matcher"] == "compact"][0]["hooks"]
assert any("execute-resume-hint" in h["command"] for h in compact_hooks)
PY
then
  pass "hooks.json registers SessionStart[compact] with execute-resume-hint"
else
  fail "hooks.json registers SessionStart[compact] with execute-resume-hint"
fi

rm -rf "$CKPT_ROOT"

# ── 9. Review gate E2E ──
echo -e "${CYAN}[9/10] Review gate E2E${NC}"

E2E_ROOT="$(mktemp -d)"
E2E_QQ_TEMP="$(mktemp -d)"
mkdir -p "$E2E_ROOT/.qq"
(cd "$E2E_ROOT" && git init -q)
cat > "$E2E_ROOT/qq.yaml" <<'QYAML'
version: 1
engine: unity
default_profile: feature
QYAML

export QQ_TEMP_DIR="$E2E_QQ_TEMP"
export QQ_PROJECT_DIR="$E2E_ROOT"

# --- E2E 1: Full gate lifecycle ---
echo -e "${CYAN}[e2e] review gate lifecycle${NC}"

# 1. Set: simulate PostToolUse(Bash) with a code-review.sh command
echo '{"tool_input":{"command":"./scripts/code-review.sh --base main"}}' | \
  PROJECT_DIR="$E2E_ROOT" bash "$SCRIPT_DIR/scripts/hooks/review-gate-set.sh" 2>/dev/null

GATE_FILE="$E2E_QQ_TEMP/review-gate-$$"
if [[ -f "$GATE_FILE" ]]; then
  pass "e2e: gate-set creates gate file"
else
  fail "e2e: gate-set did not create gate file"
fi

# Verify three-field format
IFS=: read -r _ts _completed _expected < "$GATE_FILE"
if [[ "$_completed" == "0" && "$_expected" == "0" ]]; then
  pass "e2e: gate file has three-field format 0:0"
else
  fail "e2e: gate file format wrong (got $_completed:$_expected)"
fi

# 2. Check: simulate PreToolUse(Edit) on a .cs file — should BLOCK (expected=0)
if echo '{"tool_input":{"file_path":"Assets/Player.cs"}}' | \
  PROJECT_DIR="$E2E_ROOT" bash "$SCRIPT_DIR/scripts/hooks/review-gate-check.sh" 2>/dev/null; then
  fail "e2e: gate-check should block when expected=0"
else
  pass "e2e: gate-check blocks when expected=0"
fi

# 3. Write expected count (simulate skill writing N=3)
IFS=: read -r _ts _count _ < "$GATE_FILE"
echo "${_ts}:${_count}:3" > "$GATE_FILE"

# 4. Check: should still BLOCK (0/3 complete)
if echo '{"tool_input":{"file_path":"Assets/Player.cs"}}' | \
  PROJECT_DIR="$E2E_ROOT" bash "$SCRIPT_DIR/scripts/hooks/review-gate-check.sh" 2>/dev/null; then
  fail "e2e: gate-check should block when 0/3 complete"
else
  pass "e2e: gate-check blocks when 0/3 complete"
fi

# 5. Count: simulate 3 subagent completions (PostToolUse Agent)
echo '{}' | PROJECT_DIR="$E2E_ROOT" bash "$SCRIPT_DIR/scripts/hooks/review-gate-count.sh" 2>/dev/null
echo '{}' | PROJECT_DIR="$E2E_ROOT" bash "$SCRIPT_DIR/scripts/hooks/review-gate-count.sh" 2>/dev/null
echo '{}' | PROJECT_DIR="$E2E_ROOT" bash "$SCRIPT_DIR/scripts/hooks/review-gate-count.sh" 2>/dev/null

# Verify gate file shows 3/3
IFS=: read -r _ts _count _expected < "$GATE_FILE"
if [[ "$_count" == "3" && "$_expected" == "3" ]]; then
  pass "e2e: gate-count reaches 3/3"
else
  fail "e2e: gate-count wrong (got $_count/$_expected)"
fi

# 6. Check: should ALLOW (3/3 complete)
if echo '{"tool_input":{"file_path":"Assets/Player.cs"}}' | \
  PROJECT_DIR="$E2E_ROOT" bash "$SCRIPT_DIR/scripts/hooks/review-gate-check.sh" 2>/dev/null; then
  pass "e2e: gate-check allows when 3/3 complete"
else
  fail "e2e: gate-check still blocks after 3/3"
fi

# 7. Cleanup
rm -f "$GATE_FILE"

# --- E2E 2: Stop hook blocks exit during incomplete verification ---
echo -e "${CYAN}[e2e] stop hook behavior${NC}"

echo "$(date +%s):1:3" > "$E2E_QQ_TEMP/review-gate-$$"

STOP_TMP="$E2E_QQ_TEMP/stop-hook-out-$$"
echo '{}' | PROJECT_DIR="$E2E_ROOT" bash "$SCRIPT_DIR/scripts/hooks/review-gate-stop.sh" >"$STOP_TMP" 2>/dev/null
if grep -q '"decision":"block"' "$STOP_TMP"; then
  pass "e2e: stop hook blocks exit when 1/3 complete"
else
  fail "e2e: stop hook should block when 1/3 complete"
fi

# Complete to 3/3
echo "$(date +%s):3:3" > "$E2E_QQ_TEMP/review-gate-$$"

echo '{}' | PROJECT_DIR="$E2E_ROOT" bash "$SCRIPT_DIR/scripts/hooks/review-gate-stop.sh" >"$STOP_TMP" 2>/dev/null
if grep -q '"decision":"block"' "$STOP_TMP"; then
  fail "e2e: stop hook still blocks after 3/3"
else
  pass "e2e: stop hook allows exit when 3/3 complete"
fi
rm -f "$STOP_TMP"

rm -f "$E2E_QQ_TEMP/review-gate-$$"

# --- E2E 3: Gate trigger detects all 4 review scripts ---
echo -e "${CYAN}[e2e] gate trigger variants${NC}"

for script in code-review claude-review plan-review claude-plan-review; do
  rm -f "$E2E_QQ_TEMP/review-gate-$$"
  echo "{\"tool_input\":{\"command\":\"./scripts/${script}.sh --base main\"}}" | \
    PROJECT_DIR="$E2E_ROOT" bash "$SCRIPT_DIR/scripts/hooks/review-gate-set.sh" 2>/dev/null
  if [[ -f "$E2E_QQ_TEMP/review-gate-$$" ]]; then
    pass "e2e: gate-set triggers on ${script}.sh"
  else
    fail "e2e: gate-set does not trigger on ${script}.sh"
  fi
  rm -f "$E2E_QQ_TEMP/review-gate-$$"
done

# --- E2E 4: Gate ignores non-.cs files ---
echo -e "${CYAN}[e2e] gate file-type filtering${NC}"

echo "$(date +%s):0:3" > "$E2E_QQ_TEMP/review-gate-$$"

# .py file should NOT be blocked
if echo '{"tool_input":{"file_path":"scripts/foo.py"}}' | \
  PROJECT_DIR="$E2E_ROOT" bash "$SCRIPT_DIR/scripts/hooks/review-gate-check.sh" 2>/dev/null; then
  pass "e2e: gate-check ignores .py files"
else
  fail "e2e: gate-check incorrectly blocks .py files"
fi

# .cs file should be blocked
if echo '{"tool_input":{"file_path":"Assets/Player.cs"}}' | \
  PROJECT_DIR="$E2E_ROOT" bash "$SCRIPT_DIR/scripts/hooks/review-gate-check.sh" 2>/dev/null; then
  fail "e2e: gate-check should block .cs files"
else
  pass "e2e: gate-check blocks .cs files"
fi

rm -f "$E2E_QQ_TEMP/review-gate-$$"

# --- E2E 5: Gate does NOT trigger on unrelated bash commands ---
echo -e "${CYAN}[e2e] gate ignores non-review commands${NC}"

rm -f "$E2E_QQ_TEMP/review-gate-$$"
echo '{"tool_input":{"command":"./scripts/qq-compile.sh"}}' | \
  PROJECT_DIR="$E2E_ROOT" bash "$SCRIPT_DIR/scripts/hooks/review-gate-set.sh" 2>/dev/null
if [[ -f "$E2E_QQ_TEMP/review-gate-$$" ]]; then
  fail "e2e: gate-set triggers on non-review command"
else
  pass "e2e: gate-set ignores non-review commands"
fi

# --- E2E 6: Review scripts fail gracefully when CLI missing ---
echo -e "${CYAN}[e2e] review script graceful failure${NC}"

if env -i PATH="/usr/bin:/bin" bash "$SCRIPT_DIR/scripts/claude-review.sh" 2>&1 | grep -qi "claude.*not found"; then
  pass "e2e: claude-review.sh fails gracefully without claude CLI"
else
  # If claude IS installed, script will fail for other reasons (no git repo context)
  # That's also acceptable — the point is it doesn't crash silently
  pass "e2e: claude-review.sh handles missing CLI (claude may be installed)"
fi

if env -i PATH="/usr/bin:/bin" bash "$SCRIPT_DIR/scripts/code-review.sh" 2>&1 | grep -qi "codex.*not found"; then
  pass "e2e: code-review.sh fails gracefully without codex CLI"
else
  pass "e2e: code-review.sh handles missing CLI (codex may be installed)"
fi

# --- E2E 7: Gate expiry (2h timeout) ---
echo -e "${CYAN}[e2e] gate expiry${NC}"

# Create a gate with a timestamp 3 hours in the past
old_ts=$(( $(date +%s) - 10800 ))
echo "${old_ts}:0:3" > "$E2E_QQ_TEMP/review-gate-$$"

# Check should allow (gate expired)
if echo '{"tool_input":{"file_path":"Assets/Player.cs"}}' | \
  PROJECT_DIR="$E2E_ROOT" bash "$SCRIPT_DIR/scripts/hooks/review-gate-check.sh" 2>/dev/null; then
  pass "e2e: gate-check allows after 2h expiry"
else
  fail "e2e: gate-check still blocks after 2h expiry"
fi

# Gate file should be removed
if [[ ! -f "$E2E_QQ_TEMP/review-gate-$$" ]]; then
  pass "e2e: expired gate file is cleaned up"
else
  fail "e2e: expired gate file not removed"
fi

# Teardown
rm -rf "$E2E_ROOT" "$E2E_QQ_TEMP"
unset QQ_PROJECT_DIR

# ── 10. install.sh validation ──
echo -e "${CYAN}[10/10] install.sh validation${NC}"

# Check no old skill names remain in output
if grep -qE '/qq-ut|/qq-cp|/qq-arch-review' "$SCRIPT_DIR/install.sh"; then
  fail "install.sh still has old skill names"
else
  pass "install.sh uses current skill names"
fi

# Check platform guard exists (cross-platform case statement)
if grep -q 'uname -s' "$SCRIPT_DIR/install.sh"; then
  pass "install.sh has platform check"
else
  fail "install.sh missing platform check"
fi

# Check install resolves module plans through the internal installer helper
if grep -q 'qq_internal_install.py' "$SCRIPT_DIR/install.sh" && grep -q -- '--modules' "$SCRIPT_DIR/install.sh" && grep -q -- '--without' "$SCRIPT_DIR/install.sh"; then
  pass "install.sh resolves and applies install modules"
else
  fail "install.sh missing modular install plan support"
fi

if grep -q -- '--profile' "$SCRIPT_DIR/install.sh"; then
  pass "install.sh supports policy profile selection"
else
  fail "install.sh missing policy profile selection"
fi

if grep -q 'qq-onboard.py' "$SCRIPT_DIR/install.sh" && \
   grep -q -- '--wizard' "$SCRIPT_DIR/install.sh" && \
   grep -q -- '--preset' "$SCRIPT_DIR/install.sh"; then
  pass "install.sh wires the onboarding wizard and preset entrypoints"
else
  fail "install.sh missing onboarding wizard/preset support"
fi

ONBOARD_PREVIEW_ROOT="$(mktemp -d)"
: > "$ONBOARD_PREVIEW_ROOT/.sbproj"
if LANG=zh_CN.UTF-8 $QQ_PY "$SCRIPT_DIR/scripts/qq-onboard.py" preview --project "$ONBOARD_PREVIEW_ROOT" --preset quickstart --host-surface claude --json | $QQ_PY -c '
import json, sys
payload = json.load(sys.stdin)
assert payload["language"] == "zh-CN"
assert payload["preset"] == "quickstart"
assert payload["profile"] == "lightweight"
assert payload["trustLevel"] == "trusted"
assert payload["installHosts"] == ["claude", "mcp"]
assert payload["installSync"] is True
' >/dev/null 2>&1; then
  pass "qq-onboard auto-detects zh-CN and previews a simple preset"
else
  fail "qq-onboard auto-detects zh-CN and previews a simple preset"
fi
rm -rf "$ONBOARD_PREVIEW_ROOT"

INSTALL_UPDATE_ROOT="$(mktemp -d)"
mkdir -p "$INSTALL_UPDATE_ROOT/ProjectSettings" "$INSTALL_UPDATE_ROOT/Packages"
cat > "$INSTALL_UPDATE_ROOT/ProjectSettings/ProjectVersion.txt" <<'EOF'
m_EditorVersion: 2022.3.17f1
EOF
cat > "$INSTALL_UPDATE_ROOT/Packages/manifest.json" <<'EOF'
{
  "dependencies": {
    "com.tyk.tykit": "https://github.com/tykisgod/tykit.git#b14919953fd8f655be05a929b69c9d71d6556ebe"
  }
}
EOF
"$SCRIPT_DIR/install.sh" "$INSTALL_UPDATE_ROOT" >/dev/null
if $QQ_PY - "$INSTALL_UPDATE_ROOT/Packages/manifest.json" <<'PY'
import json
import sys
from pathlib import Path

manifest = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
assert manifest["dependencies"]["com.tyk.tykit"] == "https://github.com/tykisgod/tykit.git#84b129b026d3b725f5f7dd21d59a5fe9d206850c"
PY
then
  pass "install.sh updates existing tykit dependency to current tested release"
else
  fail "install.sh updates existing tykit dependency to current tested release"
fi
rm -rf "$INSTALL_UPDATE_ROOT"

ONBOARD_INSTALL_ROOT="$(mktemp -d)"
: > "$ONBOARD_INSTALL_ROOT/.sbproj"
LANG=ja_JP.UTF-8 "$SCRIPT_DIR/install.sh" --preset quickstart --language ja "$ONBOARD_INSTALL_ROOT" >/dev/null
if $QQ_PY - "$ONBOARD_INSTALL_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
config_text = (root / "qq.yaml").read_text(encoding="utf-8")
state = json.loads((root / ".qq" / "install-state.json").read_text(encoding="utf-8"))

assert "default_profile: lightweight" in config_text
assert "trust_level: trusted" in config_text
assert state["profile"] == "lightweight"
assert state["syncEnabled"] is True
PY
then
  pass "install.sh --preset quickstart writes a lightweight starter config"
else
  fail "install.sh --preset quickstart writes a lightweight starter config"
fi
rm -rf "$ONBOARD_INSTALL_ROOT"

GODOT_INSTALL_ROOT="$(mktemp -d)"
cat > "$GODOT_INSTALL_ROOT/project.godot" <<'EOF'
; Engine configuration file.
config_version=5

[application]
config/name="qq godot install fixture"

[editor_plugins]
enabled=PackedStringArray("res://addons/gut/plugin.cfg")
EOF
"$SCRIPT_DIR/install.sh" "$GODOT_INSTALL_ROOT" >/dev/null
if $QQ_PY - "$GODOT_INSTALL_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
project_text = (root / "project.godot").read_text(encoding="utf-8")
mcp = json.loads((root / ".mcp.json").read_text(encoding="utf-8"))

assert (root / "scripts" / "godot_bridge.py").is_file()
assert (root / "scripts" / "godot_capabilities.json").is_file()
assert (root / "addons" / "qq_editor_bridge" / "plugin.cfg").is_file()
assert (root / "addons" / "qq_editor_bridge" / "plugin.gd").is_file()
assert "res://addons/gut/plugin.cfg" in project_text
assert "res://addons/qq_editor_bridge/plugin.cfg" in project_text
server = mcp["mcpServers"]["qq-godot"]
assert server["command"] == "python3"
assert "qq_mcp.py" in " ".join(server["args"])
PY
then
  pass "install.sh installs and enables the Godot editor bridge addon"
else
  fail "install.sh installs and enables the Godot editor bridge addon"
fi
rm -rf "$GODOT_INSTALL_ROOT"

UNREAL_INSTALL_ROOT="$(mktemp -d)"
cat > "$UNREAL_INSTALL_ROOT/FPSGame.uproject" <<'EOF'
{
  "FileVersion": 3,
  "EngineAssociation": "5.7",
  "Plugins": [
    {
      "Name": "ModelingToolsEditorMode",
      "Enabled": true
    }
  ]
}
EOF
"$SCRIPT_DIR/install.sh" "$UNREAL_INSTALL_ROOT" >/dev/null
if $QQ_PY - "$UNREAL_INSTALL_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
project_file = next(root.glob("*.uproject"))
uproject = json.loads(project_file.read_text(encoding="utf-8"))
mcp = json.loads((root / ".mcp.json").read_text(encoding="utf-8"))
plugins = {item["Name"]: item["Enabled"] for item in uproject.get("Plugins", []) if isinstance(item, dict) and "Name" in item}

assert (root / "scripts" / "unreal_bridge.py").is_file()
assert (root / "scripts" / "unreal_capabilities.json").is_file()
assert (root / "Content" / "Python" / "qq_unreal_bridge.py").is_file()
assert plugins["ModelingToolsEditorMode"] is True
assert plugins["PythonScriptPlugin"] is True
assert plugins["EditorScriptingUtilities"] is True
engine_ini = (root / "Config" / "DefaultEngine.ini").read_text(encoding="utf-8")
assert "import qq_unreal_bridge; qq_unreal_bridge.start()" in engine_ini
server = mcp["mcpServers"]["qq-unreal"]
assert server["command"] == "python3"
assert "qq_mcp.py" in " ".join(server["args"])
PY
then
  pass "install.sh enables required Unreal project plugins and wires the built-in live editor bridge"
else
  fail "install.sh enables required Unreal project plugins and wires the built-in live editor bridge"
fi
rm -rf "$UNREAL_INSTALL_ROOT"

SBOX_INSTALL_ROOT="$(mktemp -d)"
: > "$SBOX_INSTALL_ROOT/.sbproj"
"$SCRIPT_DIR/install.sh" "$SBOX_INSTALL_ROOT" >/dev/null
if $QQ_PY - "$SBOX_INSTALL_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
mcp = json.loads((root / ".mcp.json").read_text(encoding="utf-8"))
server = mcp["mcpServers"]["qq-sbox"]

assert (root / "scripts" / "sbox-common.sh").is_file()
assert (root / "scripts" / "sbox-compile.sh").is_file()
assert (root / "scripts" / "sbox-test.sh").is_file()
assert (root / "scripts" / "sbox_bridge.py").is_file()
assert (root / "scripts" / "sbox_capabilities.json").is_file()
assert (root / "Editor" / "QQ" / "QQSboxEditorBridge.cs").is_file()
assert (root / "qq.yaml").is_file()
assert server["command"] == "python3"
assert "qq_mcp.py" in " ".join(server["args"])
assert not (root / "addons" / "qq_editor_bridge").exists()
assert not (root / "Content" / "Python" / "qq_unreal_bridge.py").exists()
PY
then
  pass "install.sh wires S&box projects with direct runtime scripts and the built-in editor bridge"
else
  fail "install.sh wires S&box projects with direct runtime scripts and the built-in editor bridge"
fi
rm -rf "$SBOX_INSTALL_ROOT"

MODULAR_INSTALL_ROOT="$(mktemp -d)"
: > "$MODULAR_INSTALL_ROOT/.sbproj"
"$SCRIPT_DIR/install.sh" "$MODULAR_INSTALL_ROOT" >/dev/null
$QQ_PY - "$MODULAR_INSTALL_ROOT/qq.yaml" <<'PY'
from pathlib import Path

path = Path(__import__("sys").argv[1])
text = path.read_text(encoding="utf-8")
replacement = (
    "install:\n"
    "  hosts:\n"
    "    - claude\n"
    "  add_modules: []\n"
    "  remove_modules:\n"
    "    - host-codex\n"
    "    - host-mcp\n"
    "  sync: true\n"
)
start = text.find("install:\n")
end = text.find("profiles:\n", start)
if start == -1 or end == -1 or end <= start:
    raise SystemExit("failed to replace install block in qq.yaml fixture")
updated = text[:start] + replacement + "\n" + text[end:]
path.write_text(updated, encoding="utf-8")
PY
"$SCRIPT_DIR/install.sh" "$MODULAR_INSTALL_ROOT" >/dev/null
if $QQ_PY - "$MODULAR_INSTALL_ROOT" <<'PY'
import json
import sys
from pathlib import Path

root = Path(sys.argv[1])
state = json.loads((root / ".qq" / "install-state.json").read_text(encoding="utf-8"))
selected = set(state["selectedModules"])

assert "runtime-core" in selected
assert "project-config" in selected
assert "engine-sbox" in selected
assert "host-claude" in selected
assert "host-codex" not in selected
assert "host-mcp" not in selected
assert "hooks-auto-compile" in selected
assert not (root / "scripts" / "qq-codex-exec.py").exists()
assert not (root / "scripts" / "qq-codex-mcp.py").exists()
assert not (root / "scripts" / "qq_mcp.py").exists()
assert state["syncEnabled"] is True
assert ".mcp.json" not in state["managedFiles"]
PY
then
  pass "install.sh can trim host modules and sync managed runtime files from qq.yaml install settings"
else
  fail "install.sh can trim host modules and sync managed runtime files from qq.yaml install settings"
fi
rm -rf "$MODULAR_INSTALL_ROOT"

if grep -q 'qq_default_test_scope' "$SCRIPT_DIR/scripts/githooks/pre-push" && \
   grep -q 'qq-test.sh" editmode' "$SCRIPT_DIR/scripts/githooks/pre-push"; then
  pass "pre-push hook adapts test scope from policy profile"
else
  fail "pre-push hook adapts test scope from policy profile"
fi

# ── review script symmetry ──
echo -e "${CYAN}[review] script symmetry${NC}"

# code-review.sh accepts --files
if grep -q '\-\-files)' "$SCRIPT_DIR/scripts/code-review.sh"; then
  pass "code-review.sh accepts --files"
else
  fail "code-review.sh missing --files"
fi

# severity label consistency
if grep -q '\[Moderate\]' "$SCRIPT_DIR/scripts/code-review.sh" && ! grep -q '\[Medium\]' "$SCRIPT_DIR/scripts/code-review.sh"; then
  pass "code-review.sh uses [Moderate] not [Medium]"
else
  fail "code-review.sh still uses [Medium]"
fi

if grep -q '\[Moderate\]' "$SCRIPT_DIR/scripts/plan-review.sh" && ! grep -q '\[Medium\]' "$SCRIPT_DIR/scripts/plan-review.sh"; then
  pass "plan-review.sh uses [Moderate] not [Medium]"
else
  fail "plan-review.sh still uses [Medium]"
fi

# claude-review.sh exists and uses claude -p
if [[ -x "$SCRIPT_DIR/scripts/claude-review.sh" ]]; then
  pass "claude-review.sh exists and is executable"
else
  fail "claude-review.sh missing or not executable"
fi

if grep -q 'claude -p' "$SCRIPT_DIR/scripts/claude-review.sh"; then
  pass "claude-review.sh calls claude -p"
else
  fail "claude-review.sh does not call claude -p"
fi

if grep -q '\-\-files)' "$SCRIPT_DIR/scripts/claude-review.sh" && grep -q '\-\-base)' "$SCRIPT_DIR/scripts/claude-review.sh"; then
  pass "claude-review.sh accepts --files and --base"
else
  fail "claude-review.sh missing expected args"
fi

# claude-plan-review.sh exists and uses claude -p
if [[ -x "$SCRIPT_DIR/scripts/claude-plan-review.sh" ]] && grep -q 'claude -p' "$SCRIPT_DIR/scripts/claude-plan-review.sh"; then
  pass "claude-plan-review.sh exists and calls claude -p"
else
  fail "claude-plan-review.sh missing or wrong CLI"
fi

# gate-set regex matches all 4 review scripts (check both wrapper and unified script)
for script_name in code-review plan-review claude-review claude-plan-review; do
  if grep -qE "${script_name}" "$SCRIPT_DIR/scripts/hooks/review-gate-set.sh" "$SCRIPT_DIR/scripts/hooks/review-gate.sh" 2>/dev/null; then
    pass "gate-set detects ${script_name}.sh"
  else
    fail "gate-set misses ${script_name}.sh"
  fi
done

# ── skill refactoring ──
echo -e "${CYAN}[skills] review skill structure${NC}"

# claude-code-review calls claude-review.sh
if grep -q 'claude-review\.sh' skills/claude-code-review/SKILL.md; then
  pass "claude-code-review skill calls claude-review.sh"
else
  fail "claude-code-review skill does not call claude-review.sh"
fi

# claude-plan-review calls claude-plan-review.sh
if grep -q 'claude-plan-review\.sh' skills/claude-plan-review/SKILL.md; then
  pass "claude-plan-review skill calls claude-plan-review.sh"
else
  fail "claude-plan-review skill does not call claude-plan-review.sh"
fi

# all 4 skills write expected count
for skill in claude-code-review claude-plan-review codex-code-review codex-plan-review; do
  if grep -q 'review-gate-\$PPID' "skills/${skill}/SKILL.md"; then
    pass "${skill} writes expected count to gate"
  else
    fail "${skill} missing expected count write"
  fi
done

# ── MCP review tools ──
echo -e "${CYAN}[mcp] review tools${NC}"

if $QQ_PY -c "
import ast, sys
src = open('scripts/qq_mcp.py').read()
tree = ast.parse(src)
for node in ast.walk(tree):
    if isinstance(node, ast.Dict):
        for key in node.keys:
            if isinstance(key, ast.Constant) and key.value == 'qq_code_review':
                sys.exit(0)
sys.exit(1)
"; then
  pass "qq_code_review defined in qq_mcp.py"
else
  fail "qq_code_review not found in qq_mcp.py"
fi

if $QQ_PY -c "
import ast, sys
src = open('scripts/qq_mcp.py').read()
tree = ast.parse(src)
for node in ast.walk(tree):
    if isinstance(node, ast.Dict):
        for key in node.keys:
            if isinstance(key, ast.Constant) and key.value == 'qq_plan_review':
                sys.exit(0)
sys.exit(1)
"; then
  pass "qq_plan_review defined in qq_mcp.py"
else
  fail "qq_plan_review not found in qq_mcp.py"
fi

# ── Summary ──
echo ""
TOTAL=$((PASS + FAIL))
if [ "$FAIL" -eq 0 ]; then
  echo -e "${GREEN}All $TOTAL checks passed${NC}"
else
  echo -e "${RED}$FAIL/$TOTAL checks failed${NC}"
  exit 1
fi