claude-dev-env 1.93.0 → 1.94.0

package/skills/pr-converge/scripts/test_check_convergence_contract.py

@@ -0,0 +1,321 @@
+"""Contract-pin and flag tests for check_convergence.
+
+::
+
+    check_all(all gates passing)       -> exit 0, "All pre-conditions met ..."
+    check_all(one gate failing)        -> exit 1, "One or more ... do not mark ready."
+    _get_pr_head_sha raises SystemExit -> exit 2 propagates
+    parse_arguments([... --bugteam-post-blocked]) -> bugteam_post_blocked True
+
+The pin tests fix the stdout the four consumers parse (converge.mjs, pr-converge,
+bugteam, qbug) byte-for-byte, plus the exit codes and CLI surface. The flag tests
+drive the ``--bugteam-post-blocked`` bypass.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+import _pr_converge_path_setup  # noqa: F401
+from pr_converge_skill_constants.constants import EXIT_CODE_GH_ERROR
+
+_SCRIPTS_DIRECTORY = Path(__file__).absolute().parent
+_PR_CONVERGE_DIRECTORY = _SCRIPTS_DIRECTORY.parent
+
+CURRENT_HEAD_SHA = "abcdef1234567890abcdef1234567890abcdef12"
+
+_ALL_LEAF_GATE_NAMES = [
+    "_check_bugbot",
+    "_check_bugbot_not_dirty",
+    "_check_bugteam_clean",
+    "_check_bot_review",
+    "_count_unresolved_bot_threads",
+    "_get_mergeable",
+    "_check_no_pending_reviews",
+]
+
+EXPECTED_ALL_PASS_STDOUT = (
+    "HEAD: abcdef1\n\n"
+    "1. bugbot_clean_at == current_head: PASS — clean\n"
+    "2. bugbot review body clean: PASS — clean\n"
+    "3. bugteam_clean_at == current_head: PASS — clean\n"
+    "4. copilot_clean_at == current_head: PASS — clean\n"
+    "5. zero unresolved bot threads: PASS — clean\n"
+    "6. PR is mergeable: PASS — clean\n"
+    "7. no pending requested reviews: PASS — clean\n\n"
+    "All pre-conditions met — PR is ready to mark ready.\n"
+)
+
+EXPECTED_BUGBOT_DOWN_STDOUT = (
+    "HEAD: abcdef1\n\n"
+    "1. bugbot_clean_at == current_head: PASS — bypassed (bugbot_down)\n"
+    "2. bugteam_clean_at == current_head: PASS — clean\n"
+    "3. copilot_clean_at == current_head: PASS — clean\n"
+    "4. zero unresolved bot threads: PASS — clean\n"
+    "5. PR is mergeable: PASS — clean\n"
+    "6. no pending requested reviews: PASS — clean\n\n"
+    "All pre-conditions met — PR is ready to mark ready.\n"
+)
+
+EXPECTED_COPILOT_DOWN_STDOUT = (
+    "HEAD: abcdef1\n\n"
+    "1. bugbot_clean_at == current_head: PASS — clean\n"
+    "2. bugbot review body clean: PASS — clean\n"
+    "3. bugteam_clean_at == current_head: PASS — clean\n"
+    "4. copilot_clean_at == current_head: PASS — bypassed (copilot_down)\n"
+    "5. zero unresolved bot threads: PASS — clean\n"
+    "6. PR is mergeable: PASS — clean\n"
+    "7. no pending requested reviews: PASS — bypassed (copilot_down)\n\n"
+    "All pre-conditions met — PR is ready to mark ready.\n"
+)
+
+EXPECTED_FAIL_SUMMARY = "One or more pre-conditions not met — do not mark ready.\n"
+
+
+def _load_check_convergence() -> ModuleType:
+    if str(_PR_CONVERGE_DIRECTORY) not in sys.path:
+        sys.path.insert(0, str(_PR_CONVERGE_DIRECTORY))
+    if str(_SCRIPTS_DIRECTORY) not in sys.path:
+        sys.path.insert(0, str(_SCRIPTS_DIRECTORY))
+    module_path = _SCRIPTS_DIRECTORY / "check_convergence.py"
+    spec = importlib.util.spec_from_file_location(
+        "check_convergence_contract_under_test", module_path
+    )
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+check_convergence = _load_check_convergence()
+
+
+def _clean_head(**_call_keywords: object) -> str:
+    return CURRENT_HEAD_SHA
+
+
+def _clean_gate(**_call_keywords: object) -> tuple[bool, str]:
+    return True, "clean"
+
+
+def _refuse_bugteam_clean(**_call_keywords: object) -> tuple[bool, str]:
+    raise AssertionError(
+        "_check_bugteam_clean must not run when is_bugteam_post_blocked=True"
+    )
+
+
+def _patch_gates_clean(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(check_convergence, "_get_pr_head_sha", _clean_head)
+    for each_gate_name in _ALL_LEAF_GATE_NAMES:
+        monkeypatch.setattr(check_convergence, each_gate_name, _clean_gate)
+
+
+def test_all_pass_stdout_and_exit_code_match_the_pinned_contract(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    _patch_gates_clean(monkeypatch)
+    exit_code = check_convergence.check_all(
+        owner="o", repo="r", number=1, is_bugbot_down=False, is_copilot_down=False
+    )
+    assert capsys.readouterr().out == EXPECTED_ALL_PASS_STDOUT
+    assert exit_code == 0
+
+
+def test_bugbot_down_bypass_line_matches_the_pinned_contract(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    _patch_gates_clean(monkeypatch)
+    exit_code = check_convergence.check_all(
+        owner="o", repo="r", number=1, is_bugbot_down=True, is_copilot_down=False
+    )
+    assert capsys.readouterr().out == EXPECTED_BUGBOT_DOWN_STDOUT
+    assert exit_code == 0
+
+
+def test_copilot_down_bypass_lines_match_the_pinned_contract(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    _patch_gates_clean(monkeypatch)
+    exit_code = check_convergence.check_all(
+        owner="o", repo="r", number=1, is_bugbot_down=False, is_copilot_down=True
+    )
+    assert capsys.readouterr().out == EXPECTED_COPILOT_DOWN_STDOUT
+    assert exit_code == 0
+
+
+def test_a_failing_gate_yields_exit_one_and_the_fail_summary(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    _patch_gates_clean(monkeypatch)
+
+    def _blocked_mergeable(**_call_keywords: object) -> tuple[bool, str]:
+        return False, "blocked"
+
+    monkeypatch.setattr(check_convergence, "_get_mergeable", _blocked_mergeable)
+    exit_code = check_convergence.check_all(
+        owner="o", repo="r", number=1, is_bugbot_down=False, is_copilot_down=False
+    )
+    captured_stdout = capsys.readouterr().out
+    assert "6. PR is mergeable: FAIL — blocked\n" in captured_stdout
+    assert captured_stdout.endswith(EXPECTED_FAIL_SUMMARY)
+    assert exit_code == 1
+
+
+def test_gh_error_exit_code_is_two_and_propagates_from_head_fetch(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def _raise_gh_error(**_call_keywords: object) -> str:
+        raise SystemExit(EXIT_CODE_GH_ERROR)
+
+    monkeypatch.setattr(check_convergence, "_get_pr_head_sha", _raise_gh_error)
+    with pytest.raises(SystemExit) as raised:
+        check_convergence.check_all(
+            owner="o", repo="r", number=1, is_bugbot_down=False, is_copilot_down=False
+        )
+    assert EXIT_CODE_GH_ERROR == 2
+    assert raised.value.code == 2
+
+
+def test_existing_cli_flags_stay_on_the_argument_surface() -> None:
+    arguments = check_convergence.parse_arguments(
+        [
+            "--owner",
+            "o",
+            "--repo",
+            "r",
+            "--pr-number",
+            "1",
+            "--bugbot-down",
+            "--copilot-down",
+        ]
+    )
+    assert arguments.owner == "o"
+    assert arguments.repo == "r"
+    assert getattr(arguments, "pr_number") == 1
+    assert arguments.bugbot_down is True
+    assert arguments.copilot_down is True
+
+
+def test_skip_bugteam_gate_when_bugteam_post_blocked_is_true(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    _patch_gates_clean(monkeypatch)
+    monkeypatch.setattr(
+        check_convergence, "_check_bugteam_clean", _refuse_bugteam_clean
+    )
+    exit_code = check_convergence.check_all(
+        owner="o",
+        repo="r",
+        number=1,
+        is_bugbot_down=False,
+        is_copilot_down=False,
+        is_bugteam_post_blocked=True,
+    )
+    assert "bypassed (bugteam_post_blocked)" in capsys.readouterr().out
+    assert exit_code == 0
+
+
+def test_run_bugteam_gate_when_bugteam_post_blocked_is_false(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    invoked_gate_names: list[str] = []
+
+    def _recording_bugteam_clean(**_call_keywords: object) -> tuple[bool, str]:
+        invoked_gate_names.append("_check_bugteam_clean")
+        return True, "clean"
+
+    _patch_gates_clean(monkeypatch)
+    monkeypatch.setattr(
+        check_convergence, "_check_bugteam_clean", _recording_bugteam_clean
+    )
+    exit_code = check_convergence.check_all(
+        owner="o",
+        repo="r",
+        number=1,
+        is_bugbot_down=False,
+        is_copilot_down=False,
+        is_bugteam_post_blocked=False,
+    )
+    assert "_check_bugteam_clean" in invoked_gate_names
+    assert "bypassed (bugteam_post_blocked)" not in capsys.readouterr().out
+    assert exit_code == 0
+
+
+def test_bugteam_post_blocked_flag_round_trips_through_parse_arguments() -> None:
+    arguments = check_convergence.parse_arguments(
+        ["--owner", "o", "--repo", "r", "--pr-number", "1", "--bugteam-post-blocked"]
+    )
+    assert arguments.bugteam_post_blocked is True
+
+
+def test_bugteam_post_blocked_defaults_to_false_when_flag_absent() -> None:
+    arguments = check_convergence.parse_arguments(
+        ["--owner", "o", "--repo", "r", "--pr-number", "1"]
+    )
+    assert arguments.bugteam_post_blocked is False
+
+
+def test_resolve_bugteam_post_blocked_true_when_flag_set(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("CLAUDE_REVIEWS_DISABLED", raising=False)
+    assert check_convergence._resolve_bugteam_post_blocked(True) is True
+
+
+def test_resolve_bugteam_post_blocked_true_when_env_disables_bugteam(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("CLAUDE_REVIEWS_DISABLED", "bugteam")
+    assert check_convergence._resolve_bugteam_post_blocked(False) is True
+
+
+def test_resolve_bugteam_post_blocked_false_when_flag_unset_and_env_empty(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("CLAUDE_REVIEWS_DISABLED", raising=False)
+    assert check_convergence._resolve_bugteam_post_blocked(False) is False
+
+
+def test_resolve_bugteam_post_blocked_false_when_env_disables_only_copilot(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("CLAUDE_REVIEWS_DISABLED", "copilot")
+    assert check_convergence._resolve_bugteam_post_blocked(False) is False
+
+
+def test_env_bugteam_token_does_not_disable_copilot_or_bugbot_opt_out(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("CLAUDE_REVIEWS_DISABLED", "bugteam")
+    assert check_convergence._resolve_copilot_down(False) is False
+    assert check_convergence._resolve_bugteam_post_blocked(False) is True
+
+
+def test_main_derives_bugteam_post_blocked_from_env_when_flag_omitted(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("CLAUDE_REVIEWS_DISABLED", "bugteam")
+    captured_bugteam_post_blocked: list[bool] = []
+
+    def stub_check_all(
+        *,
+        owner: str,
+        repo: str,
+        number: int,
+        is_bugbot_down: bool,
+        is_copilot_down: bool,
+        is_bugteam_post_blocked: bool = False,
+    ) -> int:
+        captured_bugteam_post_blocked.append(is_bugteam_post_blocked)
+        return 0
+
+    monkeypatch.setattr(check_convergence, "check_all", stub_check_all)
+    exit_code = check_convergence.main(["--owner", "o", "--repo", "r", "--pr-number", "1"])
+    assert exit_code == 0
+    assert captured_bugteam_post_blocked == [True]

package/skills/pr-converge/scripts/test_check_convergence_gates.py

@@ -0,0 +1,68 @@
+"""Behavioral tests for the review and Bugbot convergence gate leaves.
+
+::
+
+    _flatten_paginated_reviews(two pages) -> newest-first flat list
+    _bugbot_run_conclusion_detail(success) -> (True, "check run ...")
+    _check_bugbot(named complete run) -> (True, "check run ...")
+
+Each test drives the real leaf, stubbing only the ``gh`` transport helpers.
+"""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+import check_convergence_gates as gates
+
+
+def test_flatten_paginated_reviews_flattens_and_sorts_newest_first() -> None:
+    pages = [
+        [{"id": 1, "submitted_at": "2026-01-01T00:00:00Z"}],
+        [{"id": 2, "submitted_at": "2026-03-01T00:00:00Z"}],
+    ]
+    flattened = gates._flatten_paginated_reviews(json.dumps(pages))
+    assert flattened is not None
+    assert [each_review["id"] for each_review in flattened] == [2, 1]
+
+
+def test_flatten_paginated_reviews_returns_none_for_non_list_payload() -> None:
+    assert (
+        gates._flatten_paginated_reviews(json.dumps({"message": "Not Found"})) is None
+    )
+
+
+def test_bugbot_run_conclusion_detail_passes_on_a_complete_conclusion() -> None:
+    complete_conclusion = gates.ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS[0]
+    passed, detail = gates._bugbot_run_conclusion_detail(
+        {"id": 55, "conclusion": complete_conclusion, "html_url": ""}
+    )
+    assert passed is True
+    assert "check run 55" in detail
+
+
+def test_check_bugbot_reports_success_when_the_named_run_is_complete(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    complete_conclusion = gates.ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS[0]
+    run_name = f"x {gates.BUGBOT_CHECK_RUN_NAME_SUBSTRING} y"
+    payload = {
+        "check_runs": [
+            {
+                "name": run_name,
+                "id": 9,
+                "conclusion": complete_conclusion,
+                "html_url": "",
+            }
+        ]
+    }
+
+    def _stub_gh_api(endpoint_path: str) -> tuple[int, str]:
+        return 0, json.dumps(payload)
+
+    monkeypatch.setattr(gates, "_gh_api", _stub_gh_api)
+    passed, detail = gates._check_bugbot(owner="o", repo="r", sha="abc")
+    assert passed is True
+    assert "check run 9" in detail

package/skills/pr-converge/scripts/test_check_convergence_thread_gates.py

@@ -0,0 +1,75 @@
+"""Behavioral tests for the review-thread and pending-reviewer gate leaves.
+
+::
+
+    _is_unresolved_bot_thread(cursor, unresolved) -> True
+    _count_unresolved_bot_threads(one cursor thread) -> (False, "1 unresolved ...")
+    _format_unresolved_detail(over limit) -> "... and N more"
+
+Each test drives the real leaf, stubbing only the ``gh`` transport helpers.
+"""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+import check_convergence_thread_gates as thread_gates
+
+
+def test_is_unresolved_bot_thread_true_for_cursor_authored_open_thread() -> None:
+    thread = {
+        "isResolved": False,
+        "isOutdated": False,
+        "comments": {"nodes": [{"author": {"login": "cursor[bot]"}}]},
+    }
+    logins = (thread_gates.CURSOR_LOGIN_FILTER_SUBSTRING,)
+    assert thread_gates._is_unresolved_bot_thread(thread, logins) is True
+
+
+def test_is_unresolved_bot_thread_false_for_resolved_thread() -> None:
+    thread = {
+        "isResolved": True,
+        "isOutdated": False,
+        "comments": {"nodes": [{"author": {"login": "cursor[bot]"}}]},
+    }
+    logins = (thread_gates.CURSOR_LOGIN_FILTER_SUBSTRING,)
+    assert thread_gates._is_unresolved_bot_thread(thread, logins) is False
+
+
+def test_count_unresolved_bot_threads_counts_a_single_cursor_thread(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    thread = {
+        "isResolved": False,
+        "isOutdated": False,
+        "path": "src/app.py",
+        "comments": {"nodes": [{"author": {"login": "cursor[bot]"}}]},
+    }
+    review_threads = {
+        "nodes": [thread],
+        "pageInfo": {"hasNextPage": False, "endCursor": None},
+    }
+    graphql_payload = {
+        "data": {"repository": {"pullRequest": {"reviewThreads": review_threads}}}
+    }
+
+    def _stub_gh_graphql(query: str, variables: dict[str, object]) -> tuple[int, str]:
+        return 0, json.dumps(graphql_payload)
+
+    monkeypatch.setattr(thread_gates, "_gh_graphql", _stub_gh_graphql)
+    passed, detail = thread_gates._count_unresolved_bot_threads(
+        owner="o", repo="r", number=1
+    )
+    assert passed is False
+    assert detail.startswith("1 unresolved")
+    assert "src/app.py" in detail
+
+
+def test_format_unresolved_detail_bounds_the_listed_paths() -> None:
+    over_limit = thread_gates.UNRESOLVED_THREAD_DETAIL_MAX + 2
+    all_threads = [{"path": f"file{each_index}.py"} for each_index in range(over_limit)]
+    detail = thread_gates._format_unresolved_detail(all_threads)
+    assert detail.startswith(f"{over_limit} unresolved")
+    assert "more" in detail

package/skills/privacy-hygiene/SKILL.md

@@ -22,9 +22,9 @@ Find and remove personal data and high-confidence secrets before they land in gi
 
 | Category | Blocked examples | Allowed residual |
 |---|---|---|
-| Email | `person@company.io` | `user@example.com`, `user@example.org`, `user@example.net` |
-| Home path | `C:/Users/realname/...`, `/Users/realname/...`, `/home/realname/...` | `C:/Users/example/...`, `C:/Users/<you>/...`, `/Users/alice/...` |
-| LAN address | Unlisted `10.x` / `172.16–31.x` / `192.168.x` | Public addresses; product NAS `192.168.1.100`; other entries in `ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES` |
+| Email | `user@example.com` | `user@example.com`, `user@example.org`, `user@example.net` |
+| Home path | `C:/Users/example/...`, `/Users/example/...`, `/home/example/...` | `C:/Users/example/...`, `C:/Users/<you>/...`, `/Users/alice/...` |
+| LAN address | Unlisted `10.x` / `172.16–31.x` / `192.168.x` | Public addresses; your NAS host from `CLAUDE_NAS_HOST` or `~/.claude/local-identity.json`; entries in `ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES` |
 | Secret | `ghp_…`, `github_pat_…`, `AKIA…`, PEM private-key headers | Public keys, redacted `***`, env var names without values |
 
 Surfaces:
@@ -55,7 +55,7 @@ git diff --name-only origin/main...HEAD
 Run from the repo root (PowerShell-friendly example):
 
 ```
-rg -n --hidden -g '!node_modules' -g '!.git' -e '@[A-Za-z0-9.-]+\.[A-Za-z]{2,}' -e 'Users[/\\][^/\\]+' -e '/home/[^/]+' -e '\b(10\.\d+\.\d+\.\d+|192\.168\.\d+\.\d+|172\.(1[6-9]|2\d|3[0-1])\.\d+\.\d+)\b' -e '\b(ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{20,}\b' -e '\bgithub_pat_[A-Za-z0-9_]{20,}\b' -e '\bAKIA[0-9A-Z]{16}\b' -e '-----BEGIN [A-Z ]*PRIVATE KEY-----'
+rg -n --hidden -g '!node_modules' -g '!.git' -e '@[A-Za-z0-9.-]+\.[A-Za-z]{2,}' -e 'Users[/\\][^/\\]+' -e '[/]home/[^/]+' -e '\b(10\.\d+\.\d+\.\d+|192\.168\.\d+\.\d+|172\.(1[6-9]|2\d|3[0-1])\.\d+\.\d+)\b' -e '\b(ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9_]{20,}\b' -e '\bgithub_pat_[A-Za-z0-9_]{20,}\b' -e '\bAKIA[0-9A-Z]{16}\b' -e '-----BEGIN [A-Z ]*PRIVATE KEY-----'
 ```
 
 Review each hit. Ignore:
@@ -71,7 +71,7 @@ Review each hit. Ignore:
 |---|---|
 | Real email | Replace with `user@example.com` or remove |
 | Home path | Use `Path.home()`, `~`, or `C:/Users/<you>/` |
-| LAN address | Remove, use a hostname, or add to `ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES` only when tooling requires it |
+| LAN address | Remove, use a hostname, or — for your own NAS — set the host in `CLAUDE_NAS_HOST` or `~/.claude/local-identity.json`, both of which stay out of git |
 | Credential material | Remove from the tree; rotate the credential; load from env/secret store |
 | Already committed | Rewrite is not enough if already pushed — rotate secrets; scrub history only with explicit user approval |
 
@@ -87,7 +87,7 @@ Review each hit. Ignore:
 - Intentional public maintainer identity published on purpose
 - Example domains reserved for documentation (`example.com` and siblings)
 - Placeholder home users (`example`, `user`, `alice`, `<you>`, `YOUR_USER`)
-- Product NAS host `192.168.1.100` (allowlisted for the NAS SSH rule/hook)
+- The NAS host you configure locally (allowlisted at scan time, never committed)
 - Public addresses and docs that name private ranges without a live host (still prefer hostnames)
 
 ## Enable on any machine / public repository
@@ -103,7 +103,8 @@ Hooks register via `hooks/hooks.json` into `~/.claude/settings.json`. Once insta
 
 ## Open knobs
 
-- **NAS / LAN allowlist:** Unlisted private IPs are blocked. `192.168.1.100` is allowlisted for the NAS SSH enforcer. Add further hosts to `ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES` only when tooling requires them.
+- **NAS / LAN allowlist:** Unlisted private IPs are blocked. The scanner resolves your NAS host from `CLAUDE_NAS_HOST`, then `~/.claude/local-identity.json` (`nas.host`), and allowlists it when it is a private address, so the committed tree holds no real host. `ALL_ALLOWLISTED_PRIVATE_IP_ADDRESSES` in `hooks_constants` holds the static allowlist for any host every machine must share.
+- **Commit-scan exempt repositories:** named owner/repo slugs skip the staged-commit PII scan only. Set `CLAUDE_PII_EXEMPT_REPOS` (comma-separated `owner/repo` values) or list them under `pii_exempt_repositories` in `~/.claude/local-identity.json`. Matching uses the repository's `remote.origin.url` and accepts only the exact host `github.com` (https, ssh scheme, or scp-style). A repository with no readable origin is never exempt (fail-closed to scanning). Write / Edit / MultiEdit and durable post bodies still scan in every repository.
 - **Public maintainer identity:** when a real email or name is intentional product surface, keep it and note that in the PR body so reviewers do not treat it as a leak.
 
 ## What this skill does not do

package/skills/reviewer-gates/SKILL.md

@@ -61,26 +61,44 @@ Run the pre-check once per run, not per tick or per round. Every later tick read
 
 ## Gate 3: Bugbot trigger, acknowledge, and CI-detect
 
-Cursor Bugbot signals through CI check runs, not always through a posted review. The decision tree runs against `<current_head>` with `check_bugbot_ci.py` (installed at `$HOME/.claude/skills/pr-converge/scripts/check_bugbot_ci.py`; `--help` documents every mode):
+Cursor Bugbot signals through CI check runs.
+Mode flags and exit codes for `check_bugbot_ci.py` live in the script docstring
+— run
+`python "$HOME/.claude/skills/pr-converge/scripts/check_bugbot_ci.py" --help`
+for every mode. Caller action sequence against `<current_head>`:
 
 1. **Silent-pass pre-check (always first).**
    `python "$HOME/.claude/skills/pr-converge/scripts/check_bugbot_ci.py" --check-clean --owner <O> --repo <R> --sha <current_head>`
-   - Exit 0 — Bugbot CI completed with a `success`/`neutral` conclusion and posted no review: a silent pass. Record `bugbot_clean_at = <current_head>` and stop; do not trigger.
-   - Exit 1 (not a silent pass) or exit 2 (gh CLI error, silent pass not confirmable) — continue.
+   - Silent pass confirmed → record `bugbot_clean_at = <current_head>` and stop; do not trigger.
+   - Silent pass not confirmed → continue.
 2. **Already-queued check.**
    `... check_bugbot_ci.py --check-active --owner <O> --repo <R> --sha <current_head>`
-   - Exit 0 — Bugbot is already queued on this commit. Skip posting; wait for completion (callers schedule their own wakeup).
-   - Exit 1 — continue.
-3. **Trigger.** Post exactly `bugbot run` as an issue comment (`add_issue_comment`) — no `@cursor[bot]` mention, no other text. `bugbot run` is empirically the only re-trigger Cursor Bugbot recognizes; every other phrasing silently no-ops. Wait 8 seconds with an in-turn Monitor delay, never a foreground `sleep` (blocked in headless runs).
+   - Already queued → skip posting; wait for completion (callers schedule their own wakeup).
+   - Not active → continue.
+3. **Trigger.** Post exactly `bugbot run` as an issue comment (`add_issue_comment`) — no `@cursor[bot]` mention, no other text. `bugbot run` is the only re-trigger Cursor Bugbot recognizes; every other phrasing silently no-ops. Wait 8 seconds with an in-turn Monitor delay, never a foreground `sleep` (blocked in headless runs).
 4. **Acknowledge check.**
    `... check_bugbot_ci.py --owner <O> --repo <R> --sha <current_head>`
-   - Exit 0 — a check run is present: record `bugbot_acknowledged_at = <now, ISO 8601>`; the caller polls on its own cadence.
-   - Exit non-zero — Bugbot is down: set `bugbot_down = true` and route past the Bugbot phase; the run continues on its remaining signals.
+   - Check run present → record `bugbot_acknowledged_at = <now, ISO 8601>`; the caller polls on its own cadence.
+   - Check run absent → Bugbot is down: set `bugbot_down = true` and route past the Bugbot phase; the run continues on its remaining signals.
 
 The silent-pass pre-check runs first so a bot that already finished cleanly is never re-prompted — Bugbot refuses to re-run on an evaluated commit, and without the pre-check the acknowledge step would falsely mark `bugbot_down = true`.
 
 **Flag reset rule:** `bugbot_down` resets to false whenever `<current_head>` changes — a new HEAD invalidates the old down-detection. `copilot_down` never resets mid-run; it holds until the run ends.
 
+## Convergence-check bypass flags
+
+When a reviewer is down, `check_convergence.py` must skip that reviewer's gate so the run still marks ready on its remaining signals. Each condition has one CLI flag and one matching `CLAUDE_REVIEWS_DISABLED` token:
+
+| Condition | `check_convergence.py` flag | `CLAUDE_REVIEWS_DISABLED` token |
+|---|---|---|
+| Bugbot down or off | `--bugbot-down` | `bugbot` |
+| Copilot down or opted out | `--copilot-down` | `copilot` |
+| Bugteam CLEAN post blocked | `--bugteam-post-blocked` | `bugteam` |
+
+The caller passes the flag on its own `check_convergence.py` run. The flag alone does not reach the independent mark-ready blocker hook, which re-runs `check_convergence.py` with no flags on `gh pr ready`. Each flag also honors its token: `check_convergence.py` reads the same bypass from `CLAUDE_REVIEWS_DISABLED`. So export the matching token in the same shell before `gh pr ready`, and the hook's no-flag re-check inherits the bypass through the env. Combine tokens with commas when more than one reviewer is down (`CLAUDE_REVIEWS_DISABLED="copilot,bugteam"`).
+
+The `bugteam` token here means the bugteam CLEAN-review gate is skipped for this convergence check. It does not disable the bugbot or copilot gates: each token is scoped to its own reviewer.
+
 ## Gotchas
 
 - **`bugbot run` is load-bearing text.** Alternative phrasings (`@cursor run`, `cursor review`, `bugbot please`) return no error and do nothing.

package/skills/session-log/SKILL.md

@@ -31,12 +31,14 @@ Sessions come in many shapes — convergence loops, feature builds, research div
 
 ## Backend Detection (run before Step 1)
 
-Determine which storage backend is available. First success wins.
+Determine which storage backend is available for the write path. First success wins.
 
 1. **Headless vault** — Bash `ob --version` to verify the obsidian-headless CLI is installed. Check `OBSIDIAN_VAULT_PATH` env var or `~/.claude/vault/` for a vault directory. When the CLI check succeeds AND at least one of those paths resolves to a vault directory, set `backend = "headless"`.
 2. **Local vault** — fall back to `~/.claude/vault/`. Create `~/.claude/vault/sessions` via `mkdir -p` if missing. Set `backend = "local"`.
 
-**Session-number detection:** Bash `ls` the project's session folder, parse filenames matching `[N]. *.html` or `[N]. *.md` to preserve sequence across the format migration. Highest N + 1. New project → start at 1.
+session-log writes with Write/Edit and publishes with Artifact, so it uses headless or local filesystem paths only. `/session-tidy` Phase 0 reuses this headless → local order and adds an Obsidian MCP branch for vault maintenance.
+
+**Session-number detection:** Bash `ls` the project's session folder, parse filenames matching `[N]. *.html` or `[N]. *.md`. Highest N + 1. New project → start at 1.
 
 **Output paths:**
 - headless: `$OBSIDIAN_VAULT_PATH/sessions/[Project]/[N]. [Title].html` (falls back to `~/.claude/vault/` when the env var is unset)
@@ -139,15 +141,12 @@ Only invoke `/remember` for decisions the user confirms; `/remember` writes the
 Scope: the current project's session folder only.
 
 1. **List files** in the project's vault session folder via Bash `ls`.
-2. **Quick audit** each `.html` file for:
-   - **Naming convention:** must match `[N]. [Title].html`
-   - **Frontmatter completeness:** HTML comment block at top of `<body>` contains `type`, `project`, `session`, `date`, `status`, `blocked`, `vault_context_retrieved`, `tags`
-   - **Status coherence:** `status: completed` with `blocked: true` is contradictory. `status: in-progress` or `status: blocked` on sessions older than 7 days is stale.
-3. **Auto-fix minor issues** via Edit:
-   - Missing frontmatter fields that can be inferred (e.g., `blocked: false` when status is `completed`; `vault_context_retrieved: false` when the field is absent, since the field defaults to false in pre-existing sessions)
+2. **Audit** each `.html` and `.md` session file using the audit rules in `session-tidy` Phase 1 (naming, frontmatter completeness, type, status coherence, orphaned next-steps, categorization). session-tidy SKILL.md is the single home for those rules.
+3. **Auto-fix minor HTML metadata issues** via Edit (this step's write path is HTML-oriented):
+   - Missing frontmatter fields that can be inferred (e.g., `blocked: false` when status is `completed`; `vault_context_retrieved: false` when the field is absent)
    - `type` field set to a wrong value (correct to `session-report`)
 
-   When the Edit touches the session report created in this run, call `Artifact` again with the same `file_path` and `favicon` from step 2 to redeploy — the URL captured in step 2 stays unchanged. When the Edit touches an older session report published in a prior run, call `Artifact` on that `file_path` with no `url` argument, since this skill keeps no record of that file's earlier URL — this publishes the older report at a new URL. Surface a `Session [N] republished at a new URL: <url>` line so the user can update any prior shares.
+   When the Edit touches the session report created in this run, call `Artifact` again with the same `file_path` and `favicon` from step 2 to redeploy — the URL captured in step 2 stays unchanged. When the Edit touches an older HTML session report published in a prior run, call `Artifact` on that `file_path` with no `url` argument, since this skill keeps no record of that file's earlier URL — this publishes that report at a new URL. Surface a `Session [N] republished at a new URL: <url>` line so the user can update any prior shares.
 4. **Report issues that need user input:**
    - Files with wrong naming convention (propose new name)
    - Stale statuses (propose update to `completed` or ask)
@@ -155,7 +154,7 @@ Scope: the current project's session folder only.
 
    If no issues are found, skip silently. Do not report "all clean."
 5. **Rollup check:** if the project has 5+ sessions and no `Summary.html` or `Summary.md`, mention it:
-   > "This project has [N] sessions and no summary. A rollup would help; `/session-tidy` is defined for the Markdown session format and may mis-audit or propose destructive renames against HTML sessions, so a manual rollup is the safe path."
+   > "This project has [N] sessions and no summary. Run `/session-tidy` for a project rollup."
 
 ## Step 6: Finalize
 
@@ -176,7 +175,7 @@ The primary outcome comes from the session title resolved in step 1.
 ## Run-and-report checklist
 
 - [ ] Backend detected and announced
-- [ ] Session number resolved from `[N]. *.html` and `[N]. *.md` files (both parsed to preserve sequence across the format migration)
+- [ ] Session number resolved from `[N]. *.html` and `[N]. *.md` files (highest N + 1)
 - [ ] `artifact-design` skill loaded before composing page content
 - [ ] HTML composed for this session's character (no document wrapper tags; self-contained, responsive, theme-aware)
 - [ ] Frontmatter HTML comment present as the first content line
@@ -185,7 +184,7 @@ The primary outcome comes from the session title resolved in step 1.
 - [ ] Published via the `Artifact` tool with the fixed favicon `📓`; URL captured (or HTML emitted to chat when step 2 Write failed)
 - [ ] Vault-context line appended via Edit (step 3); `Artifact` redeployed on the same URL
 - [ ] Decision extraction surfaced any unrecorded items
-- [ ] Session tidy reported anomalies or stayed silent
+- [ ] Session tidy ran session-tidy Phase 1 audit rules on the project folder (or stayed silent when clean)
 - [ ] `/rename` command copied to clipboard via `pwsh Set-Clipboard`
 
 ## Folder map