claude-dev-env 1.94.0 → 1.95.0

package/skills/closeout/reference/pii-redaction-checklist.md

@@ -0,0 +1,36 @@
+# PII redaction checklist
+
+The PII pass runs on every closeout run, over every issue body and over the handoff prompt, before the confirmation gate. Repository visibility changes how aggressive the redaction is — public repos get the strictest pass — never whether the pass runs.
+
+## The pass
+
+Read each drafted body and the handoff prompt line by line. For every match below, swap the real value for the placeholder. When a value is load-bearing for the fix (a hook needs the exact path shape), keep the shape and drop the private part — `~/.claude/hooks/<hook>.py`, not the full home path.
+
+| Category | What to catch | Swap |
+|---|---|---|
+| Email | Any address | `<email>` |
+| Real name | A person's name in a path, log line, or account | `<name>` |
+| Home path | A user home directory | `~/` or `<home>/` |
+| Private host / IP | A LAN host, NAS name, private IP | `<host>` |
+| SSH user / port | A login user or non-standard port | `<user>`, `<port>` |
+| Account id | A store, cloud, app, or master-user id | `<account-id>` |
+| Token / secret | An API key, token, or credential | `<redacted>` |
+| Private repo name | An unpublished owner/repo | `<owner>/<repo>` |
+| Sheet / DB / script id | A Neon, Sheet, or Apps Script id | `<id>` |
+
+## Public versus private aggression
+
+| Target repo | Aggression |
+|---|---|
+| Public (ships to a public host, open source) | Strictest: redact every category above, and any value a stranger could tie to a person or a private system. When in doubt, redact. |
+| Private (internal, team-only) | Redact tokens, secrets, credentials, and emails without exception. Keep internal host and path shapes only when the fix needs them. |
+
+## After the pass
+
+- List every redaction made, so the confirmation gate shows the user what changed.
+- When a redaction removes a value the fix needs, note it as an open question for the user in the gate — do not guess a replacement.
+- A body that still holds a match after the pass does not reach the gate. Re-run the pass until every match is swapped.
+
+## Why the pass is unconditional
+
+An issue is a durable post on a shared server. A private value in an issue body outlives the session and the person who typed it. Running the pass on every body, public or private, keeps a leak from landing where it cannot be pulled back.

package/skills/orchestrator/SKILL.md

@@ -30,7 +30,7 @@ communication flows through it. It spawns and resumes executor subagents
 — `clean-coder` and the like — and those executors do every bit of the
 execution: the code edits, the build runs, the test runs. The orchestrating
 session drives the plan and routes hard decisions to the shared advisor
-(Claude: warm `session-advisor`; Grok: this session self-as-advisor).
+(Claude: warm `session-advisor`; Grok: Claude CLI advisor via the chain runner).
 
 ## Gotchas
 
@@ -43,7 +43,7 @@ session drives the plan and routes hard decisions to the shared advisor
   wasted. Hand every code edit and every build or test run to an executor; keep
   the orchestrating session's own tool use to orchestration and light
   verification reads. Hard decisions go to the shared advisor (Claude:
-  `session-advisor` via SendMessage; Grok: this session inline).
+  `session-advisor` via SendMessage; Grok: Claude CLI advisor via the chain).
 - **Flat ad hoc spawns bypass routing.** Every execution task goes through a
   workflow-backed spawn or workflow resume so the required agent type, model,
   prompt packet, and sidecar metadata stay attached to the work.
@@ -54,15 +54,15 @@ session drives the plan and routes hard decisions to the shared advisor
   spawn returns an `agentId` (format `a...-...`); keep it so `SendMessage` can
   reach that agent later. A named agent is reachable by name.
 - **Only the orchestrating session owns the shared advisor's lifecycle.** An
-  executor that finds the advisor unreachable (Claude warm agent, or this
-  session on Grok) reports that upward; it never spawns a replacement itself.
+  executor that finds the advisor unreachable (Claude warm agent, or Claude
+  CLI bind on Grok) reports that upward; it never spawns a replacement itself.
 
 ## Process
 
 1. **Check whether the refresh loop is already running this
    session.** If it is, do not schedule a second loop. Reuse any live
-   shared advisor bind (Claude warm `session-advisor`, or Grok self-bind —
-   run step 3 only when none exists yet), then skip straight to step 4.
+   shared advisor bind (Claude warm `session-advisor`, or Grok Claude CLI
+   bind — run step 3 only when none exists yet), then skip straight to step 4.
 
 2. **Register the discipline reminder.** By default, schedule it with
    `ScheduleWakeup` at `delaySeconds: 1200`, prompt `/orchestrator-refresh`,
@@ -85,15 +85,18 @@ session drives the plan and routes hard decisions to the shared advisor
    [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md);
    it is not a "spawn only at the floor" rule. Paste the **Claude host**
    Advisor block from that doc, with the resolved agent name filled in, into
-   every executor's spawn prompt. On a **Grok host**, skip that spawn — use
-   the protocol's self-as-advisor path (this session *is* the advisor; single
-   tier `Grok`, attempt result `self`). Paste the **Grok host** Advisor block
-   from that doc into every executor's spawn prompt — never the Claude
-   SendMessage block. Every row in the routing table is a consumer of the
-   shared advisor, not just this session. The orchestrating session owns the
-   shared advisor's lifecycle end to end (spawn or self-bind, drift handling
-   per the shared doc, shutdown at task end); executors only ever SendMessage
-   the warm agent (Claude) or report to this session (Grok).
+   every executor's spawn prompt. On a **Grok host**, skip the Agent spawn —
+   bind a max-tier Claude advisor through the protocol's CLI Claude-chain path
+   (Fable high, then Opus max; `claude_chain_runner.py` for account usage
+   failover). Paste the **Grok host** Advisor block from that doc into every
+   executor's spawn prompt — never the Claude SendMessage block. Every row in
+   the routing table is a consumer of the shared advisor, not just this
+   session. The orchestrating session owns the shared advisor's lifecycle end
+   to end (Agent spawn or CLI bind, drift handling per the shared doc,
+   shutdown at task end); executors only ever SendMessage the warm agent
+   (Claude) or report to this session so it can consult the CLI advisor
+   (Grok). When the CLI chain cannot bind, fail closed and report to the user
+   — do not answer the four signals as this Grok session.
 
 4. **Orchestrate the task.** Hold the plan and the user conversation. Execute
    workflow-backed spawns or resumes using the routing table below, and keep
@@ -112,10 +115,13 @@ session drives the plan and routes hard decisions to the shared advisor
 
    **Claude host:** consult the shared `session-advisor` via `SendMessage`.
    **Grok host:** executors report to this orchestrating session; this session
-   answers the four signals inline (self-as-advisor — no Agent, no
-   SendMessage-to-`session-advisor`). Every consult gets back one of four
-   signals (ENDORSE, CORRECTION, PLAN, or STOP). See
-   `agents/session-advisor.md` for what each signal means and
+   consults the bound Claude CLI advisor (`claude_chain_runner.py` +
+   `--resume`) and relays the four-signal reply (no Agent-tool
+   `session-advisor`, no SendMessage to one). Every consult gets back one of
+   four signals (ENDORSE, CORRECTION, PLAN, or STOP). When the CLI advisor is
+   unreachable, fail closed and surface that to the user — do not invent a
+   signal as this session. See `agents/session-advisor.md` for what each
+   signal means and
    [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md)
    for the consult format.
 
@@ -173,8 +179,8 @@ Routing rules:
   session (see
   [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md))
   — on Claude, executors consult a warm `session-advisor` via SendMessage; on
-  Grok, this session is the advisor and executors report here. Executors never
-  spawn or respawn the advisor.
+  Grok, executors report here and this session relays the Claude CLI advisor.
+  Executors never spawn or respawn the advisor.
 - Reuse a warm agent over a cold spawn whenever one holds relevant context.
 
 ## File Index

package/skills/orchestrator-refresh/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Fired by the /orchestrator loop reminder about every 20 minutes to
   re-assert the advisor discipline mid-run: orchestrate, route hard decisions
   to the shared advisor (ENDORSE / CORRECTION / PLAN / STOP — SendMessage on
-  Claude, self-as-advisor on Grok), reuse warm agents. Triggers:
+  Claude, Claude CLI chain on Grok), reuse warm agents. Triggers:
   '/orchestrator-refresh'.
 ---
 
@@ -12,8 +12,8 @@ description: >-
 
 Detect the host profile first (see Host profiles in
 [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md)).
-Re-assert the discipline for that host only — do not invent a Claude
-`session-advisor` spawn on a Grok host.
+Re-assert the discipline for that host only — do not invent an Agent-tool
+Claude `session-advisor` spawn on a Grok host.
 
 1. **You are the orchestrator.** Orchestrate and hold the user conversation;
    spawn executor subagents to do all the work — every code edit and build or
@@ -23,13 +23,17 @@ Re-assert the discipline for that host only — do not invent a Claude
      `SendMessage` and receive one of four signals — ENDORSE, CORRECTION, PLAN,
      or STOP. The orchestrating session routes its own hard decisions the same
      way and keeps its tool use to orchestration and light verification reads.
-   - **Grok host:** this session *is* the advisor (self-as-advisor). Do **not**
-     spawn `session-advisor` and do **not** tell executors to SendMessage a
-     separate advisor agent. Executors report blockers to this session; answer
-     with ENDORSE / CORRECTION / PLAN / STOP inline.
+   - **Grok host:** the advisor is a max-tier Claude CLI bind owned by this
+     session (`claude_chain_runner.py`, Fable high then Opus max). Do **not**
+     spawn `session-advisor` via Agent and do **not** tell executors to
+     SendMessage a separate advisor agent. Executors report blockers to this
+     session; consult the Claude CLI advisor and relay ENDORSE / CORRECTION /
+     PLAN / STOP. When the CLI bind is unreachable, fail closed and report to
+     the user — do not answer the four signals as this Grok session.
 3. **Resume before you spawn.** `SendMessage` an existing *executor* agent by
    name or `agentId` to reuse its warm context; prefer that over a cold spawn.
-   (On Grok this is executor reuse only — not an advisor spawn.)
+   (On Grok this is executor reuse only — advisor re-bind stays on the CLI
+   chain path in the shared protocol.)
 4. **Fresh spawn only for a genuine task switch.** No tool compacts or clears a
    subagent's context, so a clean context comes from a fresh spawn — never tell
    an agent to compact.

package/skills/pr-converge/CLAUDE.md

@@ -28,4 +28,4 @@ Drives a draft PR to convergence by driving the internal passes to clean first
 - All findings and PR reports state verified facts only — no hedging language.
 - The GitHub MCP (`pull_request_read`, `pull_request_review_write`) is the primary path for PR inspection; `gh api` is the fallback.
 - Three step-scoped agents (`fix_executor`, `thread_sweep`, `copilot_watch`) persist across ticks via the `persistent_agents` map in loop state; each tick resumes them with `SendMessage` and spawns a fresh named agent when a stored id is dead.
-- The tick delegates shared mechanics to five sibling sub-skills: `reviewer-gates` (opt-out, Copilot quota, Bugbot trigger), `pr-scope-resolve` (target resolution), `pr-fix-protocol` (fix sequence + unresolved-thread sweep), `post-audit-findings` (audit posting), and `pr-loop-lifecycle` (run open/close).
+- The tick delegates shared mechanics to three sibling sub-skills: `reviewer-gates` (opt-out, Copilot quota, Bugbot trigger), `pr-fix-protocol` (fix sequence + unresolved-thread sweep), and `pr-loop-lifecycle` (run open/close). Target resolution happens inline in `reference/per-tick.md` Steps 1 and 1.5. Audit posting follows the `_shared/pr-loop/post-audit-thread-contract.md` contract, run through `_shared/pr-loop/scripts/post_audit_thread.py`.

package/skills/pr-fix-protocol/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: pr-fix-protocol
+description: >-
+  Applies reviewer findings to a PR as verified fixes and drives unresolved
+  review threads to zero. Invoked by PR-loop orchestrators (pr-converge,
+  autoconverge, bugteam, qbug, copilot-review) when a reviewer reports
+  findings; not for ad-hoc 'fix this bug' requests outside a PR loop.
+---
+
+# PR Fix Protocol
+
+**Core principle:** a finding is addressed only when the fix is pushed, the thread carries a reply, and the thread is resolved — as one unit of work. Anything short of all three leaves a convergence gate stalled.
+
+## How callers invoke this
+
+- **Skill-capable contexts** (a lead session that holds the `Skill` tool): `Skill({skill: "pr-fix-protocol", args: "--skill <caller> --pr <URL> --worktree <path> [findings payload or 'sweep']"})`.
+- **Fallback** (a subagent or teammate without the `Skill` tool): the caller's spawn prompt says to read `~/.claude/skills/pr-fix-protocol/SKILL.md` and apply it with the parameters below.
+
+The caller passes: its identity, the PR scope, the PR worktree path, this round's findings (or `sweep` for a thread sweep with no fresh findings), and its post-push obligations — which clean-SHA state fields to reset and which reviewers to re-trigger.
+
+## Executor choice
+
+- **Single-PR loops** (no shared `state.json`): the lead spawns `Agent(subagent_type: "clean-coder")` to write the fix. Stop when `Agent` is unavailable. A spawned clean-coder starts in its own working directory, so its prompt names the PR worktree path and directs it to edit, stage, and commit there.
+- **Multi-PR orchestration** (shared `state.json`): a per-PR clean-coder teammate owns edits, replies, and state writes; the orchestrator holds back from inline edits. The teammate obligations — reply before writing state, which state fields to set, idle handoff — live in the calling skill's multi-PR reference.
+
+Run every git command in the PR worktree. `git add`, `git commit`, and `git push` act on the repo of the current working directory, so a cross-repo PR's fix lands in the PR's repo only when the working directory is its worktree.
+
+## The fix sequence
+
+Follow the shared 13-step sequence in [`_shared/pr-loop/fix-protocol.md`](../../_shared/pr-loop/fix-protocol.md) exactly: read each file:line, capture the pre-fix SHA and contents, write a failing test first where the finding has behavior, apply the fix narrowly, `py_compile`, run the post-fix self-audit, stage by explicit path, make one commit, fast-forward push, then reply and resolve atomically per thread. Its Constraints section — narrow scope, keep the commit hooks, preserve helpers — binds every executor.
+
+**Reply transport:** the GitHub MCP `add_reply_to_pull_request_comment` is primary. For a script-only context or a multi-PR teammate, the fallback is `python "$HOME/.claude/skills/pr-converge/scripts/post_fix_reply.py" --owner <O> --repo <R> --pr-number <N> --in-reply-to <COMMENT_ID> --body "Fixed in <SHA> — <what changed>"`. Both carry the body shape from [`_shared/pr-loop/audit-reply-template.md`](../../_shared/pr-loop/audit-reply-template.md). For a body-only finding with no inline thread, post a top-level review reply that cites the new HEAD SHA.
+
+**Thread resolution:** call `pull_request_review_write(method="resolve_thread", threadId=<PRRT node id>)` right after each reply. Harvest the thread node ids (`PRRT_…`) from `get_review_comments` at fetch time.
+
+## The unresolved-thread sweep (hard gate)
+
+A caller advances a phase, records a clean SHA, or marks a PR ready only when the PR carries zero unresolved review threads.
+
+```
+pull_request_read(method="get_review_comments") → filter threads where is_resolved == false
+```
+
+- The filter is purely `is_resolved == false`. Author, anchor commit, and `is_outdated` play no part in the count.
+- `is_outdated` is informational, not a skip flag. GitHub marks a thread outdated when its anchor line changes, yet the concern can still apply to current HEAD — the fix may have moved rather than landed. Verify each outdated thread against current HEAD like any other.
+- Per unresolved thread: verify the concern against current HEAD. The concern holds → fix (this protocol) → reply → resolve. The concern does not hold on current HEAD → reply with a note that explains why → resolve.
+- Code changed during the sweep → push and hand control back to the caller's re-entry phase. Only resolutions and no code → re-run the sweep and keep the caller's state.
+
+## Post-push obligations
+
+Every push through this protocol:
+
+1. Re-resolve `current_head` — `git rev-parse HEAD` locally, and the PR `get` call for API-visible state.
+2. Reset the caller-named clean-SHA fields to null (`bugbot_clean_at`, `code_review_clean_at`, `copilot_clean_at` — whichever the caller tracks). A new HEAD invalidates every prior clean.
+3. Re-trigger reviewers per the caller's parameter — for Cursor Bugbot the `reviewer-gates` Bugbot flow, for Copilot the caller's request step. Audit-family callers (`bugteam`, `qbug`) skip re-triggering, since their next loop iteration is the reviewer.
+
+## Gotchas
+
+- **Reply, then resolve, atomic per thread.** Batching every reply ahead of any resolve, or yielding to the orchestrator between the two, leaves threads half-addressed when a run dies mid-loop.
+- **An unchanged HEAD after step 11 means no commit landed.** Exit `stuck — could not address findings` rather than report the findings as fixed.
+- **A resolved thread with no reply reads as dismissed.** Reviewers and the humans reading the PR need the one-paragraph explanation the template carries.
+
+## Folder map
+
+- `SKILL.md` — this file. The step sequence, reply template, and payload shapes live in `_shared/pr-loop/` (`fix-protocol.md`, `audit-reply-template.md`, `gh-payloads.md`); the reply fallback script lives in `pr-converge/scripts/`.

package/skills/skill-builder/references/skill-modularity.md

@@ -84,7 +84,7 @@ In Process or a dedicated **Sub-skills** section:
 
 | Skill | When | Produces |
 |---|---|---|
-| `/pr-scope-resolve` | Step 1 — resolve the PR target | owner, repo, PR number, head ref |
+| `/reviewer-gates` | Step 1 — gate external reviewers | opt-out, Copilot quota, Bugbot trigger decisions |
 | `/skill-writer` | Step 4 — author SKILL.md | skill package files |
 
 If a listed skill is not installed, respond: `[exact refusal or degrade line]`.

package/skills/team-advisor/SKILL.md

@@ -29,21 +29,25 @@ the CLI fallback — using `team-advisor-agent` as the name and this session as
 the only consumer (skip the "who you are and your assignment" opener in each
 consult; a single-consumer session doesn't need it).
 
-**Grok host:** use the self-as-advisor path in the shared protocol: this
-session answers ENDORSE / CORRECTION / PLAN / STOP itself. Do not spawn a
-Claude `session-advisor` subagent and do not walk the Claude multi-tier
-ladder.
+**Grok host:** bind a max-tier Claude advisor through the shared CLI Claude-chain
+in the protocol (Fable high, then Opus max; `claude_chain_runner.py` walks
+`~/.claude/claude-chain.json` for account usage failover). Consult via
+`--resume <session_id>` on that bind. This session is the sole consumer of that
+CLI advisor; skip the multi-consumer opener. When the chain cannot bind or
+reply, fail closed and report to the user — do **not** answer ENDORSE /
+CORRECTION / PLAN / STOP as this Grok session.
 
 ## Constraints
 
-- One `team-advisor-agent` per session, owned by this session for its whole
-  lifecycle (spawn, drift-respawn, shutdown) — see
+- One advisor bind per session (`team-advisor-agent` on Claude; one CLI
+  `session_id` on Grok), owned by this session for its whole lifecycle
+  (spawn or CLI bind, drift re-bind, shutdown) — see
   [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md).
-- Never spawn the warm agent, or its CLI fallback, at a tier below this
-  session's own tier.
-- The warm agent (or its CLI equivalent) only answers. It never edits a
-  file, never runs a build or test, and never posts anything on the
-  session's behalf.
+- Never bind the advisor, or its CLI path, at a tier below the protocol floor
+  for this host (Claude: this session's own tier; Grok: Opus floor with Fable
+  first).
+- The advisor only answers. It never edits a file, never runs a build or
+  test, and never posts anything on the session's behalf.
 
 ## File Index
 

package/system-prompts/software-engineer.xml

@@ -140,7 +140,8 @@
   Apply an outside-in BDD reasoning protocol before writing any code. Outside-in BDD is the
   required development protocol; apply it in place of any Red-Green-Refactor heuristic. The
   full anti-pattern catalog, Example Mapping algorithm, and solo-developer guidance live in
-  the bdd-protocol skill; this section carries the core four-phase sequence.
+  the long-form BDD references (`~/.claude/docs/BDD_DISCOVERY_PROTOCOL.md`,
+  `~/.claude/docs/BDD_SCENARIO_QUALITY.md`); this section carries the core four-phase sequence.
 
   Deliberate Discovery. Before writing any specification or code, reason explicitly about
   what the code should do, what constraints apply, and what concrete examples demonstrate the
@@ -159,8 +160,9 @@
   it pass. Assess each green state for structural improvement; refactor when a specific
   naming, cohesion, or duplication problem is identified.
 
-  Reference the bdd-protocol skill for Smart and Molak §7.6 patterns, the Example Mapping
-  algorithm, and guidance on applying this protocol in a solo-developer context.
+  Reference `~/.claude/docs/BDD_SCENARIO_QUALITY.md` and `~/.claude/docs/BDD_DISCOVERY_PROTOCOL.md`
+  for Smart and Molak §7.6 patterns, the Example Mapping algorithm, and guidance on applying this
+  protocol in a solo-developer context.
 </behavior_protocol>
 
 <scope_discipline>
@@ -231,11 +233,10 @@
 </agent_workflow>
 
 <code_review_response>
-  When responding to GitHub PR review feedback, follow this mandatory protocol using the
-  pr-review-responder skill.
+  When responding to GitHub PR review feedback, follow this mandatory protocol.
 
   Fetch all reviewer comments before making any fixes. Obtain the full comment set from the
-  PR using `gh pr view --comments` or the pr-review-responder skill.
+  PR using `gh pr view --comments`.
 
   Create a TodoWrite checklist with one item per comment.
 

package/hooks/validators/test_verify_paths.py

@@ -1,32 +0,0 @@
-"""Tests for validator path verification script."""
-
-import pytest
-
-from .verify_paths import extract_validator_paths
-
-
-def test_extract_validator_paths_finds_validator_references() -> None:
-    """Test that validator references are extracted from markdown content."""
-    content = """
-    **Validator:** `validators/import_checks.py`
-    Some text here.
-    **Validator:** `validators/style_checks.py`
-    """
-
-    result = extract_validator_paths(content)
-
-    assert "import_checks.py" in result
-    assert "style_checks.py" in result
-
-
-def test_extract_validator_paths_deduplicates() -> None:
-    """Test that duplicate validator references are deduplicated."""
-    content = """
-    **Validator:** `validators/import_checks.py`
-    **Validator:** `validators/import_checks.py`
-    **Validator:** `validators/import_checks.py`
-    """
-
-    result = extract_validator_paths(content)
-
-    assert result.count("import_checks.py") == 1

package/hooks/validators/verify_paths.py

@@ -1,57 +0,0 @@
-"""Verify all validator paths referenced in SKILL.md exist."""
-
-import re
-import sys
-from pathlib import Path
-
-
-SKILL_MD_PATH = Path(__file__).parent.parent.parent / "skills" / "pr-review-responder" / "SKILL.md"
-VALIDATORS_DIR = Path(__file__).parent
-
-
-def extract_validator_paths(content: str) -> list[str]:
-    """Extract validator file paths from SKILL.md content."""
-    pattern = r"validators[/\\](\w+\.py)"
-    matches = re.findall(pattern, content)
-    return list(set(matches))
-
-
-def verify_validators() -> int:
-    """Verify all referenced validators exist.
-
-    Returns:
-        Exit code: 0 if all exist, 1 if any missing
-    """
-    if not SKILL_MD_PATH.exists():
-        print(f"ERROR: SKILL.md not found at {SKILL_MD_PATH}")
-        return 1
-
-    content = SKILL_MD_PATH.read_text(encoding="utf-8")
-    referenced_validators = extract_validator_paths(content)
-
-    print(f"Found {len(referenced_validators)} validator references in SKILL.md")
-    print()
-
-    missing = []
-    for validator_file in sorted(referenced_validators):
-        validator_path = VALIDATORS_DIR / validator_file
-        if validator_path.exists():
-            print(f"  [OK] {validator_file}")
-        else:
-            print(f"  [MISSING] {validator_file}")
-            missing.append(validator_file)
-
-    print()
-
-    if missing:
-        print(f"ERROR: {len(missing)} validator(s) missing:")
-        for validator_file in missing:
-            print(f"  - {validator_file}")
-        return 1
-
-    print("All referenced validators exist.")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(verify_validators())