psyclaw 0.27.22 → 0.28.0

package/vendor/ars/scripts/check_v3_9_0_triangulation.py

@@ -0,0 +1,366 @@
+#!/usr/bin/env python3
+"""Cross-version contamination-suffix lint: finalizer suffix table contract +
+formatter allowlist + refusal-list guard.
+
+NOTE ON NAMING: this file is named for v3.9.0 (where the triangulation matrix
+landed) but is the CANONICAL contamination-suffix oracle across versions. It now
+also guards the v3.10/v3.11 Delta-1 arXiv four-index tokens (EXPECTED_DELTA1_ROWS).
+The v3.9.0 name is historical; renaming would churn spec-consistency.yml + the CI
+manifest + the test companion for no benefit.
+
+Per spec v3.9.0 §3.8 rules 1-7, extended by #182 Delta 1:
+  Rule 1 — matrix-row oracle: the 3 v3.9.0 markers present in the finalizer
+           suffix-table rows; the 4 Delta-1 arXiv markers (incl. PREPRINT
+           compositions) each pinned to their exact (k, k_max) table cell
+  Rule 2 — preprint composition order: PREPRINT before triangulation token
+  Rule 3 — v3.7.3 legacy compat: k=1 k_max=1 S2 row → CONTAMINATED-UNMATCHED (not COVERAGE-NOISE)
+  Rule 4 — no *-BLOCK tokens in finalizer subsection (v3.10 policy-layer scope only)
+  Rule 5 — formatter pass-through allowlist set-equality, 13 tokens (R-L3-2-E lint)
+  Rule 6 — refusal-list-unchanged guard
+  Rule 7 — CI integration (done in spec-consistency.yml)
+
+Usage:
+    python scripts/check_v3_9_0_triangulation.py
+    python scripts/check_v3_9_0_triangulation.py --formatter-path PATH --orchestrator-path PATH
+        (for test fixtures only)
+
+Exit codes:
+    0 — all checks pass
+    1 — one or more checks failed
+    2 — invocation error (e.g., file missing)
+"""
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_FORMATTER = REPO_ROOT / "academic-paper/agents/formatter_agent.md"
+DEFAULT_ORCHESTRATOR = REPO_ROOT / "academic-pipeline/agents/pipeline_orchestrator_agent.md"
+
+V3_9_0_SECTION_HEADER = "## Cite-Time Provenance Finalizer — v3.9.0 extension"
+
+# Three new v3.9.0 markers that must appear in the finalizer suffix table.
+EXPECTED_NEW_V3_9_0_SUFFIXES = {
+    "CONTAMINATED-COVERAGE-NOISE",
+    "CONTAMINATED-PARTIAL-UNMATCH",
+    "CONTAMINATED-TRIANGULATION-UNMATCHED",
+}
+
+# The four v3.10/v3.11 Delta-1 markers are NOT declared as a bare set here — they
+# are the keys of EXPECTED_DELTA1_ROWS below, which pins each to its exact (k, k_max)
+# matrix cell. A separate presence-only set would be a parallel structure that could
+# drift out of sync (and presence is strictly weaker than the cell assertion anyway),
+# so the cell map is the single source of truth for the Delta-1 token set.
+
+# Canonical 13-suffix allowlist (set-equality oracle, rule 5). This is the full
+# contamination-suffix set across versions: 3 v3.7.3 legacy + 6 v3.9.0 + 4 Delta-1.
+EXPECTED_ALLOWLIST_TOKENS = {
+    # v3.7.3 legacy (3)
+    "CONTAMINATED-PREPRINT",
+    "CONTAMINATED-UNMATCHED",
+    "CONTAMINATED-PREPRINT+UNMATCHED",
+    # v3.9.0 new (6)
+    "CONTAMINATED-COVERAGE-NOISE",
+    "CONTAMINATED-PARTIAL-UNMATCH",
+    "CONTAMINATED-TRIANGULATION-UNMATCHED",
+    "CONTAMINATED-PREPRINT+COVERAGE-NOISE",
+    "CONTAMINATED-PREPRINT+PARTIAL-UNMATCH",
+    "CONTAMINATED-PREPRINT+TRIANGULATION-UNMATCHED",
+    # v3.10/v3.11 Delta-1 arXiv four-index (4)
+    "CONTAMINATED-ARXIV-UNMATCHED",
+    "CONTAMINATED-QUADRANGULATION-UNMATCHED",
+    "CONTAMINATED-PREPRINT+ARXIV-UNMATCHED",
+    "CONTAMINATED-PREPRINT+QUADRANGULATION-UNMATCHED",
+}
+
+
+# ---------------------------------------------------------------------------
+# Orchestrator helpers (rules 1-4)
+# ---------------------------------------------------------------------------
+
+def extract_v3_9_0_finalizer_subsection(orchestrator_text: str) -> str:
+    """Return the v3.9.0 finalizer extension subsection (## header until next ## or EOF)."""
+    lines = orchestrator_text.splitlines()
+    in_section = False
+    collected: list[str] = []
+    for line in lines:
+        if line.startswith(V3_9_0_SECTION_HEADER):
+            in_section = True
+            collected.append(line)
+            continue
+        if in_section:
+            if line.startswith("## "):
+                break
+            collected.append(line)
+    return "\n".join(collected)
+
+
+# Matrix-row contract for the 4 Delta-1 tokens: each must appear in a suffix-table
+# row carrying its exact (k, k_max) cell. The bullet prose + example markers below
+# the table also mention these tokens, so a subsection-wide token scan would pass
+# even if the operational row were deleted/mistokened. Rule 1 therefore asserts the
+# matrix row, not mere subsection presence — the matrix table IS the contract.
+# Column order in the suffix table: | base | preprint | k | k_max | present | suffix |
+# so "| <k> | <k_max> |" locates the (k, k_max) cell exactly (same idiom as rule 3).
+EXPECTED_DELTA1_ROWS = {
+    "CONTAMINATED-ARXIV-UNMATCHED": "| 1 | 1 |",
+    "CONTAMINATED-PREPRINT+ARXIV-UNMATCHED": "| 1 | 1 |",
+    "CONTAMINATED-QUADRANGULATION-UNMATCHED": "| 4 | 4 |",
+    "CONTAMINATED-PREPRINT+QUADRANGULATION-UNMATCHED": "| 4 | 4 |",
+}
+
+
+def check_marker_syntax(subsection_text: str) -> list[str]:
+    """Rule 1 (matrix-row oracle): each v3.9.0 + Delta-1 marker must appear as a
+    backtick-quoted suffix in a TABLE ROW, and each Delta-1 marker must sit in the
+    row carrying its exact (k, k_max) cell.
+
+    Scanning only `|`-delimited rows (not the explanatory bullets/examples below the
+    table) is what makes this a contract oracle rather than a presence check: the
+    matrix table IS the prompt contract, and deleting an operational row must fail
+    even though the same token still appears in the surrounding prose.
+    """
+    table_rows = [ln for ln in subsection_text.splitlines() if "|" in ln]
+    table_text = "\n".join(table_rows)
+    row_tokens = set(re.findall(r"`(CONTAMINATED-[A-Z+\-]+)`", table_text))
+    failures = []
+    # v3.9.0 tokens span k_max RANGES across multiple rows (e.g. COVERAGE-NOISE is
+    # k=1 k_max=1 AND k=1 k_max=2-4), so they get a presence-in-table-rows check, not
+    # a single-cell assertion (same family-by-family treatment as rule 3's s2 rows).
+    missing = EXPECTED_NEW_V3_9_0_SUFFIXES - row_tokens
+    if missing:
+        failures.append(
+            f"rule 1 (marker syntax): missing v3.9.0 markers in finalizer "
+            f"suffix-table rows: {sorted(missing)}"
+        )
+    # Delta-1 tokens are POINT cells, so the cell assertion is their sole check — it
+    # is strictly stronger than presence (a token on the wrong tier, or absent
+    # entirely, fails here), and EXPECTED_DELTA1_ROWS is their single source of truth.
+    for token, cell in EXPECTED_DELTA1_ROWS.items():
+        on_correct_row = any(
+            f"`{token}`" in ln and cell in ln for ln in table_rows
+        )
+        if not on_correct_row:
+            failures.append(
+                f"rule 1 (matrix row): `{token}` is not on a suffix-table row "
+                f"carrying its required {cell} (k, k_max) cell"
+            )
+    return failures
+
+
+def check_preprint_composition_order(subsection_text: str) -> list[str]:
+    """Rule 2: any CONTAMINATED-PREPRINT+X composition has PREPRINT before X (not X+PREPRINT)."""
+    tokens = re.findall(r"`(CONTAMINATED-[A-Z+\-]+)`", subsection_text)
+    failures = []
+    for tok in tokens:
+        # Strip CONTAMINATED- prefix, then check composition ordering.
+        body = tok[len("CONTAMINATED-"):]
+        if "PREPRINT" in body and "+" in body:
+            parts = body.split("+")
+            if parts[0] != "PREPRINT":
+                failures.append(
+                    f"rule 2 (preprint composition order): {tok} has non-leading PREPRINT"
+                )
+    return failures
+
+
+def check_legacy_compat(subsection_text: str) -> list[str]:
+    """Rule 3: k=1 k_max=1 + present_field=semantic_scholar_unmatched preserves
+    v3.7.3 legacy CONTAMINATED-UNMATCHED suffix (NOT CONTAMINATED-COVERAGE-NOISE).
+
+    Both the preprint=false and preprint=true legacy rows must be guarded:
+    - preprint=false: suffix = CONTAMINATED-UNMATCHED, NOT CONTAMINATED-COVERAGE-NOISE
+    - preprint=true: suffix = CONTAMINATED-PREPRINT+UNMATCHED, NOT
+      CONTAMINATED-PREPRINT+COVERAGE-NOISE
+
+    Additionally, both rows must be PRESENT. Deleting either row silently passes
+    without this guard (absence-is-a-pass is a systematic false-negative per
+    v3.9.0 spec §3.6 coverage-noise invariant).
+    """
+    failures = []
+    seen_bare_legacy = False
+    seen_preprint_legacy = False
+    for line in subsection_text.splitlines():
+        if "semantic_scholar_unmatched" not in line or "| 1 | 1 |" not in line:
+            continue
+        # Detect preprint variant: the table row has "| true |" in the preprint column.
+        # Rows with "false / absent" or no explicit "true" are the bare (non-preprint) row.
+        is_preprint = "| true |" in line
+        if is_preprint:
+            seen_preprint_legacy = True
+            # Preprint legacy row must carry CONTAMINATED-PREPRINT+UNMATCHED.
+            if "`CONTAMINATED-PREPRINT+UNMATCHED`" not in line:
+                failures.append(
+                    f"rule 3 (legacy compat — preprint variant): k=1 k_max=1 "
+                    f"semantic_scholar_unmatched preprint=true row does NOT preserve "
+                    f"`CONTAMINATED-PREPRINT+UNMATCHED` legacy suffix"
+                )
+            if "`CONTAMINATED-PREPRINT+COVERAGE-NOISE`" in line:
+                failures.append(
+                    f"rule 3 (legacy compat — preprint drift): preprint legacy row contains "
+                    f"`CONTAMINATED-PREPRINT+COVERAGE-NOISE` (should be "
+                    f"`CONTAMINATED-PREPRINT+UNMATCHED`)"
+                )
+        else:
+            seen_bare_legacy = True
+            # Bare (preprint=false / absent) legacy row must carry CONTAMINATED-UNMATCHED.
+            if "`CONTAMINATED-UNMATCHED`" not in line:
+                failures.append(
+                    f"rule 3 (legacy compat — bare variant): k=1 k_max=1 "
+                    f"semantic_scholar_unmatched preprint=false row does NOT preserve "
+                    f"`CONTAMINATED-UNMATCHED` legacy suffix"
+                )
+            if "`CONTAMINATED-COVERAGE-NOISE`" in line:
+                failures.append(
+                    f"rule 3 (legacy compat — bare drift): bare legacy row contains "
+                    f"`CONTAMINATED-COVERAGE-NOISE` (should be `CONTAMINATED-UNMATCHED`)"
+                )
+    if not seen_bare_legacy:
+        failures.append(
+            "rule 3 (legacy compat): bare k=1 k_max=1 semantic_scholar_unmatched legacy row is "
+            "MISSING from the v3.9.0 finalizer subsection "
+            "(CONTAMINATED-UNMATCHED legacy coverage required)"
+        )
+    if not seen_preprint_legacy:
+        failures.append(
+            "rule 3 (legacy compat): preprint k=1 k_max=1 semantic_scholar_unmatched legacy row is "
+            "MISSING from the v3.9.0 finalizer subsection "
+            "(CONTAMINATED-PREPRINT+UNMATCHED legacy coverage required)"
+        )
+    return failures
+
+
+def check_no_high_block(subsection_text: str) -> list[str]:
+    """Rule 4: no backtick-quoted *-BLOCK tokens in v3.9.0 subsection (those are v3.10 scope)."""
+    block_tokens = re.findall(r"`([A-Z]+(?:-[A-Z]+)*-BLOCK)`", subsection_text)
+    if block_tokens:
+        return [
+            f"rule 4 (no HIGH-BLOCK): backtick-quoted *-BLOCK token in v3.9.0 subsection: "
+            f"{block_tokens}"
+        ]
+    return []
+
+
+# ---------------------------------------------------------------------------
+# Formatter helpers (rules 5-6)
+# ---------------------------------------------------------------------------
+
+def extract_allowlist_tokens(formatter_text: str) -> set[str]:
+    """Parse the pass-through allowlist sentence (anchored at 'DO NOT trigger refusal').
+
+    Strategy: locate the sentence containing 'DO NOT trigger refusal' (the canonical
+    anchor phrase from v3.7.3 + v3.9.0 specs). Walk backward to find the opening '(' of
+    the enclosing parenthetical, then forward to ')'. Extract backtick-quoted
+    CONTAMINATED-* tokens from that parenthetical only.
+
+    This avoids substring collisions because tokens are parsed from backtick-delimited
+    code spans, not from arbitrary text. CONTAMINATED-PREPRINT and
+    CONTAMINATED-PREPRINT+UNMATCHED are extracted as distinct tokens.
+    """
+    anchor = "DO NOT trigger refusal"
+    idx = formatter_text.find(anchor)
+    if idx < 0:
+        return set()
+    paren_start = formatter_text.rfind("(", 0, idx)
+    paren_end = formatter_text.find(")", paren_start) if paren_start >= 0 else -1
+    if paren_start < 0 or paren_end < 0:
+        return set()
+    parenthetical = formatter_text[paren_start:paren_end]
+    pattern = re.compile(r"`(CONTAMINATED-[A-Z+\-]+)`")
+    return set(pattern.findall(parenthetical))
+
+
+def extract_refusal_rule_tokens(formatter_text: str) -> set[str]:
+    """Parse the formatter refusal rules block (numbered list before the allowlist).
+
+    Find numbered list lines (^N. ...) that appear BEFORE the allowlist anchor.
+    Extract any backtick-quoted CONTAMINATED-* token in those rule bodies — there
+    must be none, per R-L3-2-E.
+    """
+    anchor_idx = formatter_text.find("DO NOT trigger refusal")
+    if anchor_idx < 0:
+        return set()
+    pre = formatter_text[:anchor_idx]
+    rule_pattern = re.compile(r"^\d+\.\s.*$", re.MULTILINE)
+    rule_lines = rule_pattern.findall(pre)
+    if not rule_lines:
+        return set()
+    # Scan the last 15 numbered list lines (safely covers rules 1-10).
+    contam_pattern = re.compile(r"`(CONTAMINATED-[A-Z+\-]+)`")
+    found = set()
+    for line in rule_lines[-15:]:
+        found |= set(contam_pattern.findall(line))
+    return found
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="v3.9.0 triangulation spec lint")
+    parser.add_argument(
+        "--formatter-path",
+        default=str(DEFAULT_FORMATTER),
+        help="Path to formatter_agent.md (for test fixtures)",
+    )
+    parser.add_argument(
+        "--orchestrator-path",
+        default=str(DEFAULT_ORCHESTRATOR),
+        help="Path to pipeline_orchestrator_agent.md (for test fixtures)",
+    )
+    args = parser.parse_args()
+
+    formatter_path = Path(args.formatter_path)
+    orchestrator_path = Path(args.orchestrator_path)
+
+    if not formatter_path.exists():
+        print(f"ERROR: formatter not found: {formatter_path}", file=sys.stderr)
+        return 2
+    if not orchestrator_path.exists():
+        print(f"ERROR: orchestrator not found: {orchestrator_path}", file=sys.stderr)
+        return 2
+
+    formatter_text = formatter_path.read_text(encoding="utf-8")
+    orchestrator_text = orchestrator_path.read_text(encoding="utf-8")
+    subsection = extract_v3_9_0_finalizer_subsection(orchestrator_text)
+
+    failures: list[str] = []
+
+    # Rules 1-4: finalizer/orchestrator side
+    failures += check_marker_syntax(subsection)
+    failures += check_preprint_composition_order(subsection)
+    failures += check_legacy_compat(subsection)
+    failures += check_no_high_block(subsection)
+
+    # Rules 5-6: formatter side
+    allowlist = extract_allowlist_tokens(formatter_text)
+    missing = EXPECTED_ALLOWLIST_TOKENS - allowlist
+    extra = allowlist - EXPECTED_ALLOWLIST_TOKENS
+    if missing:
+        failures.append(f"rule 5 (allowlist missing tokens): {sorted(missing)}")
+    if extra:
+        failures.append(f"rule 5 (allowlist extra tokens): {sorted(extra)}")
+
+    in_refusal = extract_refusal_rule_tokens(formatter_text)
+    if in_refusal:
+        failures.append(
+            f"rule 6 (R-L3-2-E violation — CONTAMINATED-* in refusal rules): {sorted(in_refusal)}"
+        )
+
+    if failures:
+        print("v3.9.0 triangulation lint FAILED:", file=sys.stderr)
+        for f in failures:
+            print(f"  - {f}", file=sys.stderr)
+        return 1
+
+    print("v3.9.0 triangulation lint OK")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/vendor/ars/scripts/check_v3_9_2_phase_boundary.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""Static lint for ARS v3.9.2 phase boundary coverage (#133 hot-fix).
+
+Spec: docs/design/2026-05-18-ars-v3.9.2-phase-boundary-spec.md Phase 5
+Classification: docs/design/2026-05-18-ars-v3.9.2-agent-phase-classification.md
+
+Enforces three invariants:
+
+1. **Bucket A coverage** — all 23 single-phase agents MUST carry a
+   `## Phase Boundary (v3.9.2)` or `## Phase Boundary (v3.9.4)` H2 block.
+
+2. **Bucket B/C/D exclusion** — all 16 multi-phase / phase-orthogonal /
+   cross-phase-meta agents MUST NOT carry the block. Adding a fence to
+   these agents would either falsely block legitimate cross-phase work
+   (Bucket B/C) or defeat orchestration (Bucket D).
+
+3. **Block content shape** — each Bucket A block must contain the four
+   load-bearing keywords/phrases that make the boundary detectable in
+   prompt processing:
+     - `Phase Boundary (v3.9.2)` or `Phase Boundary (v3.9.4)` (the H2 marker)
+     - `MUST NOT` (the prohibition section)
+     - `MAY READ` (the explicit upstream-read permission)
+     - `Enforcement (v3.9.2)` or `Enforcement (v3.9.4)` (the trailing enforcement-paragraph marker)
+
+   These are scoped to the Phase Boundary block itself (via H2 → next H2
+   boundary), so the same keyword appearing elsewhere in the agent file
+   does not count toward passing.
+
+4. **Canonical enforcement sentence (#491 defrift lock)** — every Bucket A
+   block's enforcement paragraph must carry the canonical sentence verbatim
+   (version-matched to the block's v3.9.2/v3.9.4 marker; per-file tails
+   AFTER the sentence stay free — formatter's v3.7.1 hard-gate note, the
+   reviewers' Sprint Contract notes are legitimately file-specific). The
+   previous copy ("hook deferred to v3.10 #134") went factually stale
+   repo-wide with no lint noticing (audits/harness-retirement-2026-07-04.md
+   B4-F01). Scope: the constant governs the Bucket A blocks only — the
+   `agents/` mirrors follow mechanically via check_agents_mirror_sync.py,
+   and the SKILL.md copies carry a different, shorter wording (separate
+   surface). Update procedure: see the error message in check_bucket_a.
+
+Falsifiability discipline (per feedback_lint_passes_but_prompt_silent.md):
+keywords are scoped to the v3.9.2 block; bare keyword presence anywhere
+in the agent file does NOT count. The block must include all four phrases
+inside its own H2 span.
+
+Exit codes: 0 on pass, 1 on any failure.
+"""
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+
+# Bucket A — 23 single-phase agents that MUST have Phase Boundary block.
+# Source: docs/design/2026-05-18-ars-v3.9.2-agent-phase-classification.md
+BUCKET_A_AGENTS = [
+    # deep-research/agents/ (10)
+    "deep-research/agents/research_question_agent.md",
+    "deep-research/agents/research_architect_agent.md",
+    "deep-research/agents/bibliography_agent.md",
+    "deep-research/agents/source_verification_agent.md",
+    "deep-research/agents/synthesis_agent.md",
+    "deep-research/agents/timeline_extraction_agent.md",  # v3.9.4 Phase 2 sibling
+    "deep-research/agents/editor_in_chief_agent.md",
+    "deep-research/agents/ethics_review_agent.md",
+    "deep-research/agents/risk_of_bias_agent.md",
+    "deep-research/agents/meta_analysis_agent.md",
+    # academic-paper/agents/ (7)
+    "academic-paper/agents/literature_strategist_agent.md",
+    "academic-paper/agents/structure_architect_agent.md",
+    "academic-paper/agents/draft_writer_agent.md",
+    "academic-paper/agents/citation_compliance_agent.md",
+    "academic-paper/agents/abstract_bilingual_agent.md",
+    "academic-paper/agents/peer_reviewer_agent.md",
+    "academic-paper/agents/formatter_agent.md",
+    # academic-paper-reviewer/agents/ (6)
+    "academic-paper-reviewer/agents/eic_agent.md",
+    "academic-paper-reviewer/agents/methodology_reviewer_agent.md",
+    "academic-paper-reviewer/agents/domain_reviewer_agent.md",
+    "academic-paper-reviewer/agents/perspective_reviewer_agent.md",
+    "academic-paper-reviewer/agents/devils_advocate_reviewer_agent.md",
+    "academic-paper-reviewer/agents/editorial_synthesizer_agent.md",
+]
+
+# Buckets B/C/D — 16 agents that MUST NOT have the block.
+# B (4): multi-phase; C (8): phase-orthogonal; D (4): cross-phase-meta.
+BUCKET_BCD_AGENTS = [
+    # Bucket B — multi-phase (4)
+    "deep-research/agents/devils_advocate_agent.md",          # P1, 3, 5 + Socratic L2, 4
+    "deep-research/agents/report_compiler_agent.md",          # P4, 6
+    "academic-paper/agents/argument_builder_agent.md",        # P3 + Plan Step 3
+    "academic-paper/agents/visualization_agent.md",           # P4 + P7
+    # Bucket C — phase-orthogonal (8)
+    "deep-research/agents/socratic_mentor_agent.md",          # Socratic Layer 1-5
+    "academic-paper/agents/socratic_mentor_agent.md",         # Plan Step 0-3
+    "deep-research/agents/monitoring_agent.md",               # post-pipeline
+    "academic-paper/agents/revision_coach_agent.md",          # Revision-Coach standalone
+    "academic-pipeline/agents/integrity_verification_agent.md",  # Stage 2.5 / 4.5 gates
+    "academic-pipeline/agents/collaboration_depth_agent.md",  # FULL/SLIM advisory
+    "academic-pipeline/agents/claim_ref_alignment_audit_agent.md",  # opt-in audit
+    "shared/agents/compliance_agent.md",                      # cross-skill stage gates
+    # Bucket D — cross-phase / meta (4)
+    "academic-paper/agents/intake_agent.md",                  # Phase 0 cross-phase config
+    "academic-pipeline/agents/pipeline_orchestrator_agent.md",  # orchestrator
+    "academic-pipeline/agents/state_tracker_agent.md",        # meta state
+    "academic-paper-reviewer/agents/field_analyst_agent.md",  # Phase 0 configures panel
+]
+
+# v3.9.4: widened to accept either v3.9.2 or v3.9.4 phase boundary markers.
+# timeline_extraction_agent.md (added in v3.9.4) uses v3.9.4 in both markers.
+PHASE_BOUNDARY_RE = re.compile(r"## Phase Boundary \(v3\.9\.(2|4)\)")
+ENFORCEMENT_RE = re.compile(r"Enforcement \(v3\.9\.(?:2|4)\)")
+
+# #491 defrift lock — the canonical enforcement sentence, keyed by the block's
+# version marker ("2" = v3.9.2, "4" = v3.9.4). Any Bucket A copy that drifts
+# fails the lint; update procedure lives in check_bucket_a's error message.
+# Deliberately lint-local rather than a shared/references/firm_rules.md
+# canonical block: this is factual enforcement-STATUS prose, not a behavioral
+# firm rule, and co-locating it with its only consumer avoids cross-lint
+# coupling (cross-referenced in firm_rules.md "Related mechanisms").
+CANONICAL_ENFORCEMENT = {
+    "2": (
+        "**Enforcement (v3.9.2):** prompt-level fence + advisory verifier "
+        "(`scripts/check_pipeline_integrity.py`). Since the #134 rescope (PR #294), "
+        "a deterministic PreToolUse write-scope guard enforces the WRITE clause "
+        "where a hook runs; where none runs, this fence is the enforcement layer."
+    ),
+    "4": (
+        "**Enforcement (v3.9.4):** prompt-level fence + advisory verifier "
+        "(`scripts/check_pipeline_integrity.py` v3.9.4 extension). Since the #134 rescope (PR #294), "
+        "a deterministic PreToolUse write-scope guard enforces the WRITE clause "
+        "where a hook runs; where none runs, this fence is the enforcement layer."
+    ),
+}
+
+# H2 marker that ends the Phase Boundary block scope.
+# Used to scope keyword checks: keywords appearing elsewhere in the file
+# (e.g., in v3.6.7 PATTERN PROTECTION further down) do NOT count.
+H2_RE = re.compile(r"^## ", re.MULTILINE)
+
+# Required keywords/phrases inside each Bucket A block.
+# Note: Phase Boundary and Enforcement markers are version-widened (v3.9.2|v3.9.4);
+# MUST NOT and MAY READ are version-neutral.
+REQUIRED_PHRASES = [
+    "MUST NOT",
+    "MAY READ",
+]
+
+
+def extract_block(text: str) -> str | None:
+    """Extract the Phase Boundary (v3.9.2|v3.9.4) block from H2 start to next H2."""
+    m = PHASE_BOUNDARY_RE.search(text)
+    if m is None:
+        return None
+    start = m.start()
+    # Find next H2 after the block marker
+    after_block_start = m.end()
+    next_h2 = H2_RE.search(text, after_block_start)
+    end = next_h2.start() if next_h2 else len(text)
+    return text[start:end]
+
+
+def check_bucket_a(path: Path) -> list[str]:
+    """Bucket A: must have block AND all required phrases inside block."""
+    errors: list[str] = []
+    if not path.is_file():
+        errors.append(f"{path.relative_to(REPO_ROOT)}: file not found")
+        return errors
+
+    text = path.read_text(encoding="utf-8")
+    block = extract_block(text)
+    if block is None:
+        errors.append(
+            f"{path.relative_to(REPO_ROOT)}: missing '## Phase Boundary (v3.9.2|v3.9.4)' "
+            f"block (Bucket A agents MUST carry this block per "
+            f"docs/design/2026-05-18-ars-v3.9.2-agent-phase-classification.md)"
+        )
+        return errors
+
+    for phrase in REQUIRED_PHRASES:
+        if phrase not in block:
+            errors.append(
+                f"{path.relative_to(REPO_ROOT)}: Phase Boundary block missing "
+                f"required phrase: {phrase!r} (falsifiability discipline: phrase "
+                f"must appear inside the H2 block, not elsewhere in the file)"
+            )
+    # Enforcement marker check (version-widened: v3.9.2 or v3.9.4)
+    if not ENFORCEMENT_RE.search(block):
+        errors.append(
+            f"{path.relative_to(REPO_ROOT)}: Phase Boundary block missing "
+            f"required phrase: 'Enforcement (v3.9.2|v3.9.4)' (falsifiability "
+            f"discipline: phrase must appear inside the H2 block)"
+        )
+    # Canonical enforcement sentence check (#491 defrift lock).
+    # Version-matched to the block's own marker; per-file tail after the
+    # sentence is free, so containment of the full sentence is the assertion.
+    version = PHASE_BOUNDARY_RE.search(block).group(1)
+    canonical = CANONICAL_ENFORCEMENT[version]
+    if canonical not in block:
+        errors.append(
+            f"{path.relative_to(REPO_ROOT)}: enforcement paragraph has drifted "
+            f"from the canonical sentence (#491 defrift lock, v3.9.{version} "
+            f"variant). It must contain CANONICAL_ENFORCEMENT from "
+            f"{Path(__file__).name} verbatim (per-file tail after the sentence "
+            f"stays free). If the enforcement reality legitimately changed, "
+            f"update the constant and sweep all {len(BUCKET_A_AGENTS)} Bucket A "
+            f"files in the same PR; the `agents/` mirrors follow via "
+            f"check_agents_mirror_sync.py."
+        )
+    return errors
+
+
+def check_bucket_bcd(path: Path) -> list[str]:
+    """Bucket B/C/D: must NOT have the block (adding fence breaks multi-phase
+    or cross-phase legitimate behavior)."""
+    errors: list[str] = []
+    if not path.is_file():
+        errors.append(f"{path.relative_to(REPO_ROOT)}: file not found")
+        return errors
+
+    text = path.read_text(encoding="utf-8")
+    if PHASE_BOUNDARY_RE.search(text):
+        errors.append(
+            f"{path.relative_to(REPO_ROOT)}: unexpected '## Phase Boundary "
+            f"(v3.9.2|v3.9.4)' block on Bucket B/C/D agent. These agents are "
+            f"multi-phase (B), phase-orthogonal (C), or cross-phase meta (D) by "
+            f"design — adding a single-phase fence would either falsely block "
+            f"legitimate cross-phase work or defeat orchestration. See "
+            f"docs/design/2026-05-18-ars-v3.9.2-agent-phase-classification.md."
+        )
+    return errors
+
+
+def main() -> int:
+    errors: list[str] = []
+
+    for rel_path in BUCKET_A_AGENTS:
+        errors.extend(check_bucket_a(REPO_ROOT / rel_path))
+
+    for rel_path in BUCKET_BCD_AGENTS:
+        errors.extend(check_bucket_bcd(REPO_ROOT / rel_path))
+
+    # Coverage sanity
+    if len(BUCKET_A_AGENTS) != 23:
+        errors.append(
+            f"BUCKET_A_AGENTS has {len(BUCKET_A_AGENTS)} entries but "
+            f"classification doc requires 23 (v3.9.4 added timeline_extraction_agent)"
+        )
+    if len(BUCKET_BCD_AGENTS) != 16:
+        errors.append(
+            f"BUCKET_BCD_AGENTS has {len(BUCKET_BCD_AGENTS)} entries but "
+            f"classification doc requires 16"
+        )
+
+    if errors:
+        print("v3.9.2 Phase Boundary lint FAILED:", file=sys.stderr)
+        for err in errors:
+            print(f"  - {err}", file=sys.stderr)
+        return 1
+
+    print(f"v3.9.2/v3.9.4 Phase Boundary lint PASSED: "
+          f"{len(BUCKET_A_AGENTS)} Bucket A agents have block, "
+          f"{len(BUCKET_BCD_AGENTS)} Bucket B/C/D agents excluded.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())