claude-dev-env 4.3.0 → 7.1.0

package/scripts/tests/test_verification_notice.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+HOOKS_DIRECTORY = Path(__file__).resolve().parents[2] / "hooks" / "git-hooks"
+NOTICE_SCRIPT = HOOKS_DIRECTORY / "verification_notice.py"
+ALL_REMOTE_URLS = (
+    "https://github.com/JonEcho/python-automation.git",
+    "git@github.com:JonEcho/python-automation.git",
+    "ssh://git@github.com/JonEcho/python-automation.git",
+)
+
+
+def run_notice(
+    repository_path: Path,
+    event_name: str = "commit",
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [
+            sys.executable,
+            str(NOTICE_SCRIPT),
+            "--event",
+            event_name,
+            "--repo",
+            str(repository_path),
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        env={**os.environ, "PYTHONIOENCODING": "utf-8"},
+    )
+
+
+def create_target_repository(
+    temporary_directory: Path,
+    remote_url: str,
+) -> tuple[Path, str]:
+    repository_path = temporary_directory / "Jon Echo project with spaces Ω"
+    repository_path.mkdir(parents=True)
+    run_git(repository_path, "init", "--quiet")
+    run_git(repository_path, "config", "user.email", "test@example.invalid")
+    run_git(repository_path, "config", "user.name", "Verification Test")
+    (repository_path / "README.md").write_text("check\n", encoding="utf-8")
+    run_git(repository_path, "add", "README.md")
+    run_git(repository_path, "commit", "--quiet", "-m", "initial")
+    run_git(repository_path, "remote", "add", "origin", remote_url)
+    current_head = run_git(repository_path, "rev-parse", "HEAD").stdout.strip()
+    return repository_path, current_head
+
+
+def run_git(
+    repository_path: Path,
+    *arguments: str,
+) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["git", *arguments],
+        cwd=repository_path,
+        check=True,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+    )
+
+
+def write_report(
+    repository_path: Path,
+    report_fields: dict[str, object],
+) -> None:
+    manifest_path = repository_path / "config" / "local-verification.json"
+    manifest_path.parent.mkdir(exist_ok=True)
+    manifest_mapping = {
+        "version": 1,
+        "checks": [
+            {
+                "id": "smoke",
+                "argv": ["python", "-c", "pass"],
+                "cwd": ".",
+                "timeout_seconds": 1.0,
+                "minimum_tests": None,
+            }
+        ],
+        "exclusions": [],
+    }
+    manifest_path.write_text(json.dumps(manifest_mapping), encoding="utf-8")
+    report_path = repository_path / ".git" / "local-verification" / "report.json"
+    report_path.parent.mkdir(exist_ok=True)
+    all_report_fields = {
+        "selection": {"selected_manifest_path": "config/local-verification.json"},
+        "manifest_digest": hashlib.sha256(
+            json.dumps(manifest_mapping, sort_keys=True, separators=(",", ":")).encode()
+        ).hexdigest(),
+        **report_fields,
+    }
+    report_path.write_text(json.dumps(all_report_fields), encoding="utf-8")
+
+
+def write_passing_report(repository_path: Path) -> str:
+    write_report(repository_path, {})
+    run_git(repository_path, "add", "config/local-verification.json")
+    run_git(repository_path, "commit", "--quiet", "-m", "manifest")
+    current_head = run_git(repository_path, "rev-parse", "HEAD").stdout.strip()
+    run_git(repository_path, "update-ref", "refs/remotes/origin/main", current_head)
+    write_report(
+        repository_path,
+        {
+            "head": current_head,
+            "base": current_head,
+            "worktree_clean": True,
+            "inputs_unchanged": True,
+            "publishable": True,
+            "status": "passed",
+            "aggregate": {
+                "status": "passed",
+                "total": 1,
+                "passed": 1,
+                "failed": 0,
+                "incomplete": 0,
+                "exit_code": 0,
+            },
+        },
+    )
+    return current_head
+
+
+def write_worktree_passing_report(
+    repository_path: Path,
+    linked_git_directory: Path,
+) -> str:
+    current_head = run_git(repository_path, "rev-parse", "HEAD").stdout.strip()
+    source_manifest_path = repository_path / "config" / "local-verification.json"
+    source_report_path = repository_path / ".git" / "local-verification" / "report.json"
+    metadata_directory = linked_git_directory / "local-verification"
+    metadata_directory.mkdir(parents=True, exist_ok=True)
+    metadata_manifest_path = metadata_directory / "local-verification.json"
+    metadata_manifest_path.write_bytes(source_manifest_path.read_bytes())
+    all_report_fields = json.loads(source_report_path.read_text(encoding="utf-8"))
+    all_report_fields["selection"]["selected_manifest_path"] = str(
+        metadata_manifest_path
+    )
+    metadata_report_path = metadata_directory / "report.json"
+    metadata_report_path.write_text(json.dumps(all_report_fields), encoding="utf-8")
+    return current_head
+
+
+def test_notice_matches_remote_formats_and_quotes_paths(tmp_path: Path) -> None:
+    for each_index, each_remote_url in enumerate(ALL_REMOTE_URLS):
+        repository_path, current_head = create_target_repository(
+            tmp_path / str(each_index), each_remote_url
+        )
+        completed_notice = run_notice(repository_path, "push")
+        assert completed_notice.returncode == 0
+        assert "LOCAL VERIFICATION ADVISORY" in completed_notice.stdout
+        assert f"Current SHA: {current_head}" in completed_notice.stdout
+        assert "State: pending" in completed_notice.stdout
+        assert "python '" in completed_notice.stdout
+        wrapper_suffix = str(Path(".github") / "ci" / "local_verify.py")
+        assert f"{wrapper_suffix}' --base origin/main" in completed_notice.stdout
+        assert "--executor '" in completed_notice.stdout
+        assert "--output '" in completed_notice.stdout
+        assert repository_path.name in completed_notice.stdout
+        assert "--base origin/main" in completed_notice.stdout
+        assert "does not block commit or push" in completed_notice.stdout
+
+
+def test_notice_reports_pending_when_manifest_exists_without_report(
+    tmp_path: Path,
+) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path,
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    write_report(repository_path, {})
+    (repository_path / ".git" / "local-verification" / "report.json").unlink()
+
+    completed_notice = run_notice(repository_path)
+
+    assert completed_notice.returncode == 0
+    assert "State: pending" in completed_notice.stdout
+    assert "manifest is missing or unreadable" not in completed_notice.stdout
+    assert "No complete current pass is recorded" in completed_notice.stdout
+
+
+def test_notice_ignores_unrelated_remote(tmp_path: Path) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path,
+        "https://github.com/other-owner/other-repository.git",
+    )
+    completed_notice = run_notice(repository_path)
+    assert completed_notice.returncode == 0
+    assert completed_notice.stdout == ""
+
+
+def test_notice_reports_failed_checks_without_pass_label(tmp_path: Path) -> None:
+    repository_path, current_head = create_target_repository(
+        tmp_path,
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    write_report(repository_path, {"head": current_head, "status": "failed"})
+    completed_notice = run_notice(repository_path)
+    assert completed_notice.returncode == 0
+    assert f"Current SHA: {current_head}" in completed_notice.stdout
+    assert "State: failed" in completed_notice.stdout
+    assert "recorded local checks failed" in completed_notice.stdout
+    assert "local-checks:passed" not in completed_notice.stdout
+
+
+def test_notice_reports_pass_only_for_complete_current_revision(tmp_path: Path) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path,
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    current_head = write_passing_report(repository_path)
+    completed_notice = run_notice(repository_path)
+    assert completed_notice.returncode == 0
+    assert f"Verified SHA: {current_head}" in completed_notice.stdout
+    assert "State: passed" in completed_notice.stdout
+    assert (
+        "local-checks:passed is valid only for this exact current SHA"
+        in completed_notice.stdout
+    )
+
+
+def test_notice_handles_malformed_report_and_missing_repository(tmp_path: Path) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path,
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    manifest_path = repository_path / "config" / "local-verification.json"
+    manifest_path.parent.mkdir(exist_ok=True)
+    manifest_mapping = {
+        "version": 1,
+        "checks": [
+            {
+                "id": "smoke",
+                "argv": ["python", "-c", "pass"],
+                "cwd": ".",
+                "timeout_seconds": 1.0,
+                "minimum_tests": None,
+            }
+        ],
+        "exclusions": [],
+    }
+    manifest_path.write_text(json.dumps(manifest_mapping), encoding="utf-8")
+    report_path = repository_path / ".git" / "local-verification" / "report.json"
+    report_path.parent.mkdir(exist_ok=True)
+    report_path.write_bytes(b"not-json\xff")
+    malformed_notice = run_notice(repository_path)
+    missing_notice = run_notice(tmp_path / "missing repository")
+    assert malformed_notice.returncode == 0
+    assert "State: unverified" in malformed_notice.stdout
+    assert missing_notice.returncode == 0
+    assert missing_notice.stdout == ""
+
+
+def test_notice_uses_worktree_specific_report_path(tmp_path: Path) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path / "main",
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    linked_worktree_path = tmp_path / "linked worktree Ω"
+    run_git(repository_path, "worktree", "add", "--detach", str(linked_worktree_path))
+    linked_git_directory = Path(
+        run_git(linked_worktree_path, "rev-parse", "--absolute-git-dir").stdout.strip()
+    )
+
+    completed_notice = run_notice(linked_worktree_path)
+
+    expected_report_path = linked_git_directory / "local-verification" / "report.json"
+    shared_report_path = repository_path / ".git" / "local-verification" / "report.json"
+    assert completed_notice.returncode == 0
+    assert str(expected_report_path) in completed_notice.stdout
+    assert str(shared_report_path) not in completed_notice.stdout
+
+
+def test_notice_accepts_complete_report_in_worktree_metadata(tmp_path: Path) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path / "main",
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    current_head = write_passing_report(repository_path)
+    linked_worktree_path = tmp_path / "linked worktree Ω"
+    run_git(repository_path, "worktree", "add", "--detach", str(linked_worktree_path))
+    linked_git_directory = Path(
+        run_git(linked_worktree_path, "rev-parse", "--absolute-git-dir").stdout.strip()
+    )
+    write_worktree_passing_report(repository_path, linked_git_directory)
+
+    completed_notice = run_notice(linked_worktree_path)
+
+    future_path = linked_worktree_path / "future.txt"
+    future_path.write_text("future\n", encoding="utf-8")
+    run_git(linked_worktree_path, "add", "future.txt")
+    run_git(linked_worktree_path, "commit", "--quiet", "-m", "future")
+    future_head = run_git(linked_worktree_path, "rev-parse", "HEAD").stdout.strip()
+    stale_notice = run_notice(linked_worktree_path)
+    run_git(linked_worktree_path, "reset", "--quiet", "--hard", current_head)
+    run_git(linked_worktree_path, "update-ref", "refs/remotes/origin/main", future_head)
+    moved_base_notice = run_notice(linked_worktree_path)
+
+    assert "State: passed" in completed_notice.stdout
+    assert f"Verified SHA: {current_head}" in completed_notice.stdout
+    assert "State: stale" in stale_notice.stdout
+    assert "State: unverified" in moved_base_notice.stdout
+
+
+def test_notice_invalidates_pass_after_worktree_edit(tmp_path: Path) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path,
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    current_head = write_passing_report(repository_path)
+    passed_notice = run_notice(repository_path)
+    (repository_path / "untracked.txt").write_text("changed\n", encoding="utf-8")
+
+    changed_notice = run_notice(repository_path)
+
+    assert f"Verified SHA: {current_head}" in passed_notice.stdout
+    assert "State: passed" in passed_notice.stdout
+    assert "Verified SHA: none" in changed_notice.stdout
+    assert "State: unverified" in changed_notice.stdout
+
+
+def test_notice_invalidates_pass_after_origin_base_moves(tmp_path: Path) -> None:
+    repository_path, _ = create_target_repository(
+        tmp_path,
+        "https://github.com/JonEcho/python-automation.git",
+    )
+    current_head = write_passing_report(repository_path)
+    passed_notice = run_notice(repository_path)
+    (repository_path / "future.txt").write_text("future\n", encoding="utf-8")
+    run_git(repository_path, "add", "future.txt")
+    run_git(repository_path, "commit", "--quiet", "-m", "future")
+    future_head = run_git(repository_path, "rev-parse", "HEAD").stdout.strip()
+    run_git(repository_path, "reset", "--quiet", "--hard", current_head)
+    run_git(repository_path, "update-ref", "refs/remotes/origin/main", future_head)
+
+    moved_base_notice = run_notice(repository_path)
+
+    assert "State: passed" in passed_notice.stdout
+    assert "Verified SHA: none" in moved_base_notice.stdout
+    assert "State: unverified" in moved_base_notice.stdout

package/.agents/skills/_shared/pr-loop/.claude/CLAUDE.md

@@ -1 +0,0 @@
-@../AGENTS.md

package/.agents/skills/_shared/pr-loop/audit-contract.md

@@ -1,5 +0,0 @@
-# Audit contract
-
-**Canonical home:**
-
-@~/.claude/_shared/pr-loop/audit-contract.md

package/.agents/skills/_shared/pr-loop/audit-reply-template.md

@@ -1,5 +0,0 @@
-# Audit reply template
-
-**Canonical home:**
-
-@~/.claude/_shared/pr-loop/audit-reply-template.md

package/.agents/skills/_shared/pr-loop/code-rules-gate.md

@@ -1,5 +0,0 @@
-# Code rules gate
-
-**Canonical home:**
-
-@~/.claude/_shared/pr-loop/code-rules-gate.md

package/.agents/skills/_shared/pr-loop/fix-protocol.md

@@ -1,5 +0,0 @@
-# Fix protocol
-
-**Canonical home:**
-
-@~/.claude/_shared/pr-loop/fix-protocol.md

package/.agents/skills/_shared/pr-loop/gh-payloads.md

@@ -1,5 +0,0 @@
-# Gh payloads
-
-**Canonical home:**
-
-@~/.claude/_shared/pr-loop/gh-payloads.md

package/.agents/skills/_shared/pr-loop/portable-driver.md

@@ -1,149 +0,0 @@
-# Portable converge driver
-
-**Rule: deterministic control is script-only.** Phase transitions, wait delays,
-clean stamps, ready decisions, task lists, and “what next” never live as prose
-for the agent to invent. The agent runs scripts, reads JSON, and only performs
-judgment steps the JSON names.
-
-## Step 1 — task list (every autoconverge portable run)
-
-```
-python "$HOME/.claude/skills/_shared/pr-loop/scripts/build_converge_task_list.py" \
-  [--bugbot-down 0|1] [--copilot-down 0|1] \
-  [--codex-down 0|1] [--codex-required 0|1]
-```
-
-Register every `tasks[]` entry on the session task list. **Final task id is
-always** `all_runnable_reviews_clean_same_head`. The run is complete only when
-that final task is completed: every runnable code review is CLEAN on one
-shared HEAD. Do not invent tasks in prose.
-
-`open-run` embeds the same list (`tasks`, `runnable_review_ids`,
-`final_task_id`, `done_when`).
-
-## Pacer selection
-
-```
-python "$HOME/.claude/skills/_shared/pr-loop/scripts/select_converge_pacer.py" \
-  --skill autoconverge \
-  --has-workflow <0|1> \
-  --has-schedule-wakeup <0|1>
-```
-
-When `pacer` is not `portable`, use the skill’s native Workflow or
-ScheduleWakeup path. When `pacer=portable`, use the control script below.
-
-## Isolation and worktree
-
-1. When the tool list includes `EnterWorktree`, call it (same contract as the
-   Claude-host skills).
-2. When `EnterWorktree` is absent, isolate with git worktree machinery:
-   - Prefer an existing worktree already on the PR head ref under
-     `.claude/worktrees/` (or another dedicated worktree path).
-   - Otherwise `git fetch origin <headRefName>` and
-     `git worktree add <path> <headRefName>` (or `gh pr checkout <N>` into a
-     dedicated directory), then `cd` into that checkout.
-3. Confirm the working directory is the PR’s own repo on the PR head SHA:
-   `python "$HOME/.claude/skills/_shared/pr-loop/scripts/preflight_worktree.py" --owner <O> --repo <R> --mode strict`.
-   Non-zero exit → report the `ABORT` line and stop.
-4. Cross-repo routing: every local review and edit runs with cwd set to the **PR worktree** (see autoconverge pre-flight and `preflight_worktree.py --mode strict`).
-
-`open-run` runs the same strict preflight before seeding state.
-
-## Control script
-
-```
-python "$HOME/.claude/skills/_shared/pr-loop/scripts/portable_converge_driver.py" <command> ...
-```
-
-Stdout JSON: `status`, `next`, `phase`, `state_file`, optional `commands`,
-`wait_seconds`, `blocker`, and on `open-run` the task-list fields. Exit `0` =
-ok; `1` = contract failure; `2` = usage error.
-
-| Command | Deterministic effect |
-|---|---|
-| `open-run` | Require `portable`; preflight; seed state + task list; when `--codex-down` is off, set `codex_required` from CLI force-on or the weekly usage probe (same rule as `check_convergence`); next=`run_code_review` |
-| `after-code-review` | From returncode / dirty_tree / served_command |
-| `after-bugteam` | From pushed / converged (bug-audit phase on portable pacer) |
-| `after-bugbot` | From classification / inline lag |
-| `after-codex` | From classification clean / dirty / down |
-| `after-copilot-wait` | From review surfaced / wait cap |
-| `after-ready-check` | From check_convergence exit |
-| `show-state` | Echo state; rehydrate `commands` / `wait_seconds` for pending next |
-
-## Continuous tick loop
-
-After transport check, PR scope, isolation, permission grant, and the once-per-run
-Copilot quota pre-check:
-
-1. Seed or restore state via `open-run` or `show-state` (and handoff
-   `state-copy.json` when resuming).
-2. Run the driver command for the current step; read JSON `next` / `commands` /
-   `wait_seconds`.
-3. On non-terminal `next`:
-   - Write state and handoff when the after-* payload says so.
-   - If `next` is `poll_wait`, sleep `wait_seconds` only, then re-poll and call
-     the matching after-*.
-   - If `next` is immediate work, continue in the same turn without sleeping.
-4. On `mark_ready` / `stop_blocked` / named stop: run lifecycle Close, print the
-   entry skill’s exit block, omit further pacing.
-5. External reviewers remain skippable the same way as Claude-host runs when
-   opted out or down. Push and head-change reset push-invalidated markers
-   (`*_clean_at`, `merge_state_status`, `bugbot_down`, `codex_down`).
-
-## Agent loop (judgment only)
-
-1. Run the driver command for the current step.
-2. If JSON `commands` is non-empty, run that argv (scripted helper).
-3. Map JSON `next` to the single judgment action; report back via the matching
-   `after-*` command.
-4. Mark session tasks complete only when the scripted stamps say so; complete
-   the final task only when every runnable review is clean on the same HEAD.
-
-| `next` | Agent does | Report with |
-|---|---|---|
-| `run_code_review` | Run `commands` | `after-code-review` |
-| `apply_fixes_and_push` | Fix protocol; commit; push | re-review then `after-code-review` |
-| `run_bugteam` | Bug-audit lens / worker spawn body | `after-bugteam` |
-| `run_bugbot_gate` | Bugbot helper scripts | `after-bugbot` |
-| `run_codex_review` | Run Codex review step | `after-codex` |
-| `request_copilot_review` | Request Copilot | `after-copilot-wait` |
-| `poll_wait` | Sleep `wait_seconds` only | re-poll then after-* |
-| `check_ready` | Run `commands` (check_convergence) | `after-ready-check` |
-| `mark_ready` | Run `commands` (`gh pr ready`) | teardown |
-| `stop_blocked` | Teardown; print blocker | stop |
-
-## Autoconverge entry on portable pacer
-
-When `/autoconverge` selects `pacer=portable`:
-
-- Complete autoconverge pre-flight (scope, draft ownership, strict worktree,
-  grant, Copilot quota).
-- Drive the continuous tick loop above (scripted phase machine) until ready
-  or a documented blocker.
-- Skip `Workflow({ scriptPath: converge.mjs })` — that path requires the
-  Workflow tool.
-- Teardown uses the lifecycle Close path; the Workflow-only closing HTML
-  journal report is optional and skipped when no workflow run id exists.
-- Resume command on handoff: `/autoconverge <PR URL>`.
-
-When `/autoconverge` selects `pacer=workflow`, follow the skill’s Workflow
-sections unchanged.
-
-## Helpers (scripted)
-
-| Concern | Script |
-|---|---|
-| Task list | `build_converge_task_list.py` |
-| Pacer | `select_converge_pacer.py` |
-| Worktree | `preflight_worktree.py` |
-| Code review | `$HOME/.claude/scripts/invoke_code_review.py` |
-| Workers | `$HOME/.claude/scripts/resolve_worker_spawn.py` |
-| Ready | `$HOME/.claude/_shared/pr-loop/scripts/check_convergence.py` |
-| Handoff | `write_handoff.py` |
-
-## Fail closed
-
-Never abort solely because Workflow or ScheduleWakeup is missing once
-pacer=`portable`. Fail closed on contract failures only: auth, worktree,
-unresolvable gates, and wait caps.

package/.agents/skills/_shared/pr-loop/post-audit-thread-contract.md

@@ -1,5 +0,0 @@
-# Post-audit thread contract
-
-**Canonical home:**
-
-@~/.claude/_shared/pr-loop/post-audit-thread-contract.md

package/.agents/skills/_shared/pr-loop/precatch-rubric.md

@@ -1,5 +0,0 @@
-# Precatch rubric
-
-**Canonical home:**
-
-@~/.claude/_shared/pr-loop/precatch-rubric.md

package/.agents/skills/_shared/pr-loop/preflight-proposal.contract.test.mjs

@@ -1,119 +0,0 @@
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { dirname, resolve } from 'node:path'
-import test from 'node:test'
-import { fileURLToPath } from 'node:url'
-
-const THIS_DIRECTORY = dirname(fileURLToPath(import.meta.url))
-const canonicalContractSource = readFileSync(
-  resolve(THIS_DIRECTORY, '../../../../_shared/pr-loop/preflight-proposal.md'),
-  'utf8',
-)
-const sharedSkillSource = readFileSync(
-  resolve(THIS_DIRECTORY, '../../pr-shared-extraction/SKILL.md'),
-  'utf8',
-)
-const capabilitySkillSource = readFileSync(
-  resolve(THIS_DIRECTORY, '../../pr-name-by-capability/SKILL.md'),
-  'utf8',
-)
-const capabilityTaskSeedsSource = readFileSync(
-  resolve(THIS_DIRECTORY, '../../pr-name-by-capability/reference/task-seeds.md'),
-  'utf8',
-)
-const reviewSkillSource = readFileSync(
-  resolve(THIS_DIRECTORY, '../../e-code-review/SKILL.md'),
-  'utf8',
-)
-const reviewProposalSource = readFileSync(
-  resolve(THIS_DIRECTORY, '../../e-code-review/reference/preflight-proposal.md'),
-  'utf8',
-)
-
-const allSkillContracts = [
-  {
-    name: 'shared extraction audit',
-    skillSource: sharedSkillSource,
-    invocationPattern: /pr-shared-extraction preflight-proposal/,
-    classificationPattern: /priority and target/,
-    expectedDefaultBehavior: 'applies the prioritized fix band by default',
-  },
-  {
-    name: 'name by capability audit',
-    skillSource: capabilitySkillSource,
-    invocationPattern: /pr-name-by-capability preflight-proposal/,
-    classificationPattern: /violation or OK-driver classification/,
-    expectedDefaultBehavior: 'applies the suggested rename direction by default',
-  },
-]
-
-function assertProposalAdapter(skillContract) {
-  const preflightRoutingOffset = skillContract.skillSource.indexOf('`preflight-proposal`')
-  const reportOnlyRoutingOffset = skillContract.skillSource.indexOf('`audit-only`')
-
-  assert.ok(preflightRoutingOffset >= 0, `${skillContract.name} selects proposal mode`)
-  assert.ok(preflightRoutingOffset < reportOnlyRoutingOffset, `${skillContract.name} routes proposal mode first`)
-  assert.match(skillContract.skillSource, skillContract.invocationPattern)
-  assert.match(skillContract.skillSource, skillContract.classificationPattern)
-  assert.match(skillContract.skillSource, new RegExp(skillContract.expectedDefaultBehavior))
-}
-
-function assertTaskRoutingAndNormalMode() {
-  assert.match(sharedSkillSource, /Register this checklist with `update_plan`/)
-  assert.match(capabilitySkillSource, /Register every bullet from `reference\/task-seeds\.md` with `update_plan`/)
-  assert.match(capabilityTaskSeedsSource, /Register each item with `update_plan`/)
-  assert.doesNotMatch(sharedSkillSource, /TodoWrite|TaskCreate/)
-  assert.doesNotMatch(capabilitySkillSource, /TodoWrite|TaskCreate/)
-  assert.doesNotMatch(capabilityTaskSeedsSource, /TodoWrite|TaskCreate/)
-  assert.match(sharedSkillSource, /audit-only` is report-only/)
-  assert.match(capabilitySkillSource, /audit-only` is report-only/)
-}
-
-function assertSharedProposalContract(contractSource) {
-  assert.match(contractSource, /caller-supplied isolated worktree/)
-  assert.match(contractSource, /resolved PR number/)
-  assert.match(contractSource, /immutable base SHA/)
-  assert.match(contractSource, /immutable head SHA/)
-  assert.match(contractSource, /exact `base_sha\.\.\.head_sha` range/)
-  assert.match(contractSource, /require exact equality with the head SHA/)
-  assert.match(contractSource, /immutable proposal identity/)
-  assert.match(contractSource, /deterministic diff hash/)
-  assert.match(contractSource, /changed paths/)
-  assert.match(contractSource, /exact tests and outcomes/)
-  assert.match(contractSource, /selected-candidate-ready proposal evidence/)
-  assert.match(contractSource, /selected or dispositioned proposal collection/)
-  assert.match(contractSource, /Reapplication uses exactly the selected records/)
-}
-
-function assertReviewProposalAdapter() {
-  const preflightRoutingOffset = reviewSkillSource.indexOf('`preflight-proposal`')
-  const refusalRoutingOffset = reviewSkillSource.indexOf('**Refusal — first match wins:**')
-  const allProposalEntryMatches = reviewSkillSource.match(
-    /Route the selected mode through \[reference\/preflight-proposal.md\]\(reference\/preflight-proposal.md\) to establish proposal context/g,
-  ) ?? []
-
-  assert.ok(preflightRoutingOffset >= 0)
-  assert.ok(preflightRoutingOffset < refusalRoutingOffset)
-  assert.equal(allProposalEntryMatches.length, 1)
-  assert.match(reviewSkillSource, /e-code-review preflight-proposal/)
-  assert.match(reviewSkillSource, /`--level <low\|medium\|xhigh>`/)
-  assert.match(reviewSkillSource, /@~\/.claude\/_shared\/pr-loop\/preflight-proposal.md/)
-  assert.match(reviewSkillSource, /Normal mode follows the current level/)
-  assert.match(reviewProposalSource, /Keep Gate 1, Gate 2, the bare code-rules gate, and exact required tests/)
-  assert.match(reviewProposalSource, /review_level: low \| medium \| xhigh/)
-  assert.match(reviewProposalSource, /severity: blocker \| high \| medium \| low \| nit/)
-  assert.match(reviewProposalSource, /verdict: CONFIRMED \| PLAUSIBLE/)
-  assert.match(reviewProposalSource, /outcome: fixed \| no_change_needed \| skipped/)
-}
-
-test('audit modes retain their normal routing behavior', () => {
-  assertTaskRoutingAndNormalMode()
-})
-
-test('one shared contract defines proposal evidence for audit and review skills', () => {
-  for (const eachSkillContract of allSkillContracts) {
-    assertProposalAdapter(eachSkillContract)
-  }
-  assertReviewProposalAdapter()
-  assertSharedProposalContract(canonicalContractSource)
-})

package/.agents/skills/_shared/pr-loop/preflight-proposal.md

@@ -1,5 +0,0 @@
-# Preflight proposal contract
-
-**Canonical home:**
-
-@~/.claude/_shared/pr-loop/preflight-proposal.md

package/.agents/skills/_shared/pr-loop/prompts/.claude/CLAUDE.md

@@ -1 +0,0 @@
-@../AGENTS.md