psyclaw 0.27.23 → 0.28.1

package/vendor/ars/scripts/test_check_394_submission_policy.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""Tests for check_394_submission_policy.py (#394 slice 4, plan D5).
+
+Mutation discipline: every invariant has a passing case against the real
+tree artifacts and a failing case proving the check fires when the guarded
+property is broken.
+"""
+from __future__ import annotations
+
+import json
+import re
+
+import pytest
+
+from check_394_submission_policy import (
+    FORMATTER,
+    ORCHESTRATOR,
+    REPORT_SCHEMA,
+    TP_SCHEMA,
+    VERIFIER,
+    check_formatter,
+    check_orchestrator,
+    check_report_schema,
+    check_tp_schema,
+    check_verifier_single_homed,
+    find_terminal_policies_access,
+)
+
+
+@pytest.fixture(scope="module")
+def tp_schema():
+    return json.loads(TP_SCHEMA.read_text(encoding="utf-8"))
+
+
+@pytest.fixture(scope="module")
+def report_schema():
+    return json.loads(REPORT_SCHEMA.read_text(encoding="utf-8"))
+
+
+@pytest.fixture(scope="module")
+def orchestrator_text():
+    return ORCHESTRATOR.read_text(encoding="utf-8")
+
+
+@pytest.fixture(scope="module")
+def formatter_text():
+    return FORMATTER.read_text(encoding="utf-8")
+
+
+# --- invariant 1: terminal_policies schema ----------------------------------
+
+def test_tp_schema_real_tree_passes(tp_schema):
+    assert check_tp_schema(tp_schema) == []
+
+
+def test_tp_schema_missing_key_fails(tp_schema):
+    mutated = json.loads(json.dumps(tp_schema))
+    del mutated["properties"]["submission_package"]
+    assert check_tp_schema(mutated)
+
+
+def test_tp_schema_widened_enum_fails(tp_schema):
+    mutated = json.loads(json.dumps(tp_schema))
+    mutated["properties"]["submission_package"]["enum"].append(
+        "strict_articles_only")
+    errs = check_tp_schema(mutated)
+    assert errs and "enum" in errs[0]
+
+
+def test_tp_schema_json_default_fails(tp_schema):
+    # The Invariant-3 lesson: a JSON-Schema `default` is non-operational
+    # comfort — the absent-key default lives in the evaluator.
+    mutated = json.loads(json.dumps(tp_schema))
+    mutated["properties"]["submission_package"]["default"] = "advisory"
+    errs = check_tp_schema(mutated)
+    assert errs and "default" in errs[0]
+
+
+# --- invariant 2: orchestrator gate section ---------------------------------
+
+def test_orchestrator_real_tree_passes(orchestrator_text):
+    assert check_orchestrator(orchestrator_text) == []
+
+
+def test_orchestrator_missing_section_fails():
+    assert check_orchestrator("# something else entirely\n")
+
+
+@pytest.mark.parametrize("literal", [
+    "bounded: 2 fix rounds",
+    "VERIFICATION-INCOMPLETE",
+    "--check-freshness",
+    "SOLE reader of `terminal_policies.submission_package`",
+    "Gate on stdout tokens, NEVER on exit codes",
+    "Recompute each pass",
+])
+def test_orchestrator_lost_literal_fails(orchestrator_text, literal):
+    mutated = orchestrator_text.replace(literal, "REDACTED")
+    errs = check_orchestrator(mutated)
+    assert errs, f"dropping {literal!r} must fire invariant 2"
+
+
+# --- invariant 3: formatter advisories section ------------------------------
+
+def test_formatter_real_tree_passes(formatter_text):
+    assert check_formatter(formatter_text) == []
+
+
+def test_formatter_missing_section_fails():
+    assert check_formatter("# no advisories here\n")
+
+
+@pytest.mark.parametrize("literal", [
+    "mandatory and non-empty iff",
+    "Invariant 13",
+    "`not_applicable` rows",
+])
+def test_formatter_lost_literal_fails(formatter_text, literal):
+    # Scope the mutation to the advisories section so a literal that also
+    # appears elsewhere (Invariant 13 does) is removed where it matters.
+    section_re = re.compile(
+        r"^## Submission Package Advisories.*?(?=^## |\Z)",
+        re.MULTILINE | re.DOTALL)
+    mutated = section_re.sub(
+        lambda m: m.group(0).replace(literal, "REDACTED"), formatter_text)
+    errs = check_formatter(mutated)
+    assert errs, f"dropping {literal!r} must fire invariant 3"
+
+
+# --- invariant 4: AST single-homed guard ------------------------------------
+
+def test_verifier_real_tree_is_single_homed():
+    assert check_verifier_single_homed(
+        VERIFIER.read_text(encoding="utf-8")) == []
+
+
+def test_docstring_mention_does_not_fire():
+    # The whole point of the AST guard (gate-1 P2): the verifier's module
+    # docstring legitimately SAYS "terminal_policies"; only runtime access
+    # may fire.
+    source = '"""The script never reads terminal_policies (§5.3)."""\n'
+    assert find_terminal_policies_access(source) == []
+
+
+def test_comment_and_help_text_do_not_fire():
+    source = (
+        "# never touch terminal_policies here\n"
+        'HELP = "the orchestrator reads terminal_policies, not this script"\n'
+    )
+    assert find_terminal_policies_access(source) == []
+
+
+def test_subscript_access_fires():
+    assert find_terminal_policies_access(
+        'x = passport["terminal_policies"]\n')
+
+
+def test_dotget_access_fires():
+    assert find_terminal_policies_access(
+        'x = passport.get("terminal_policies", {})\n')
+
+
+def test_planted_access_in_real_source_fires():
+    # Mutation pair for the real tree: planting a read into the actual
+    # verifier source must fire.
+    planted = (VERIFIER.read_text(encoding="utf-8")
+               + '\n_tp = {}.get("terminal_policies")\n')
+    assert check_verifier_single_homed(planted)
+
+
+# --- invariant 5: report schema policy_slug ---------------------------------
+
+def test_report_schema_real_tree_passes(report_schema):
+    assert check_report_schema(report_schema) == []
+
+
+def test_report_schema_widened_slug_enum_fails(report_schema):
+    mutated = json.loads(json.dumps(report_schema))
+    mutated["properties"]["header"]["properties"]["policy_slug"][
+        "enum"].append("paranoid")
+    errs = check_report_schema(mutated)
+    assert errs and "enum" in errs[0]
+
+
+def test_report_schema_dropped_null_semantics_fails(report_schema):
+    mutated = json.loads(json.dumps(report_schema))
+    mutated["properties"]["header"]["properties"]["policy_slug"][
+        "description"] = "a slug"
+    errs = check_report_schema(mutated)
+    assert errs
+
+
+def test_report_schema_string_none_is_not_null(report_schema):
+    # Final-round review P3: the enum member must be JSON null, not the
+    # STRING "None" — a str() mapping in the lint would let them collide.
+    mutated = json.loads(json.dumps(report_schema))
+    slug = mutated["properties"]["header"]["properties"]["policy_slug"]
+    slug["enum"] = ["None", "advisory", "strict"]
+    errs = check_report_schema(mutated)
+    assert errs and "enum" in errs[0]

package/vendor/ars/scripts/test_check_439_format_profile.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""Tests for check_439_format_profile.py (#439 Slice A).
+
+Mutation discipline: every invariant has a passing case against the real schema
+and a failing case proving the check fires when the guarded property is broken.
+"""
+from __future__ import annotations
+
+import copy
+import json
+
+import pytest
+from jsonschema import Draft202012Validator
+
+from check_439_format_profile import (
+    FORMATTER,
+    INTAKE,
+    POSITIONING,
+    SCHEMA,
+    check_cut_fields_stay_cut,
+    check_example_fixture,
+    check_fixed_pt_conditional,
+    check_formatter_wiring,
+    check_intake_wiring,
+    check_no_provenance,
+    check_positioning_boundary,
+    check_schema_valid,
+)
+
+
+@pytest.fixture(scope="module")
+def schema():
+    return json.loads(SCHEMA.read_text(encoding="utf-8"))
+
+
+# --- invariant 1: valid standalone schema, locked root ----------------------
+
+def test_schema_real_tree_passes(schema):
+    assert check_schema_valid(schema) == []
+
+
+def test_schema_open_root_fails(schema):
+    mutated = copy.deepcopy(schema)
+    mutated["additionalProperties"] = True
+    assert check_schema_valid(mutated), "open root (additionalProperties:true) must fire"
+
+
+# --- invariant 2: fixed_pt conditional --------------------------------------
+
+def test_fixed_pt_conditional_real_tree_passes(schema):
+    assert check_fixed_pt_conditional(schema) == []
+
+
+def test_fixed_pt_conditional_removed_fails(schema):
+    """Drop the allOf conditional → fixed_pt no longer gated → check must fire."""
+    mutated = copy.deepcopy(schema)
+    mutated["properties"]["line_spacing"].pop("allOf", None)
+    assert check_fixed_pt_conditional(mutated), "removing the fixed_pt conditional must fire"
+
+
+def test_fixed_pt_conditional_mode_not_required_fails(schema):
+    """Drop required:[mode] → {fixed_pt:20} with no mode becomes valid → check must fire (codex P2-1)."""
+    mutated = copy.deepcopy(schema)
+    mutated["properties"]["line_spacing"].pop("required", None)
+    assert check_fixed_pt_conditional(mutated), "dropping required:[mode] must fire"
+
+
+# --- invariant 3: no provenance machinery -----------------------------------
+
+def test_no_provenance_real_tree_passes(schema):
+    assert check_no_provenance(schema) == []
+
+
+def test_provenance_leak_fails(schema):
+    mutated = copy.deepcopy(schema)
+    mutated["properties"]["declared_by"] = {"const": "scholar"}
+    assert check_no_provenance(mutated), "a leaked declared_by must fire"
+
+
+def test_inferred_marker_leak_fails(schema):
+    mutated = copy.deepcopy(schema)
+    mutated["properties"]["body_font_provenance"] = {"type": "string"}
+    assert check_no_provenance(mutated), "a leaked *_provenance field must fire"
+
+
+# --- invariant 4: cut fields stay cut ---------------------------------------
+
+def test_cut_fields_real_tree_passes(schema):
+    assert check_cut_fields_stay_cut(schema) == []
+
+
+def test_profile_name_reappears_fails(schema):
+    mutated = copy.deepcopy(schema)
+    mutated["properties"]["profile_name"] = {"type": "string"}
+    assert check_cut_fields_stay_cut(mutated), "reappearing profile_name must fire"
+
+
+def test_caption_bold_reappears_fails(schema):
+    mutated = copy.deepcopy(schema)
+    mutated["properties"]["caption"]["properties"]["bold"] = {"type": "boolean"}
+    assert check_cut_fields_stay_cut(mutated), "reappearing caption.bold must fire"
+
+
+# --- invariant 5: synthetic example fixture validates -----------------------
+
+def test_example_fixture_real_tree_passes(schema):
+    assert check_example_fixture(schema) == []
+
+
+def test_example_fixture_violation_fails(schema):
+    """A schema that rejects the committed example must make the check fire."""
+    mutated = copy.deepcopy(schema)
+    # forbid table_border_style 'three_line' (the example declares it) → example invalid
+    mutated["properties"]["table_border_style"]["enum"] = ["full_grid", "none"]
+    assert check_example_fixture(mutated), "an example that violates the schema must fire"
+
+
+# --- invariant 6: formatter wiring ------------------------------------------
+
+@pytest.fixture(scope="module")
+def formatter_text():
+    return FORMATTER.read_text(encoding="utf-8")
+
+
+@pytest.fixture(scope="module")
+def intake_text():
+    return INTAKE.read_text(encoding="utf-8")
+
+
+def test_formatter_wiring_real_tree_passes(formatter_text):
+    assert check_formatter_wiring(formatter_text) == []
+
+
+def test_formatter_wiring_missing_section_fails():
+    assert check_formatter_wiring("# no format profile section here"), \
+        "a formatter without the Format Profile section must fire"
+
+
+def test_formatter_wiring_dropped_guard_fails(formatter_text):
+    """Remove the byte-equivalence guard literal → check must fire."""
+    mutated = formatter_text.replace("skip this entire section", "skip it")
+    assert check_formatter_wiring(mutated), "dropping the byte-equivalence guard must fire"
+
+
+def test_formatter_wiring_dropped_venue_precedence_fails(formatter_text):
+    mutated = formatter_text.replace("venue compliance wins", "format profile wins")
+    assert check_formatter_wiring(mutated), "dropping venue precedence must fire"
+
+
+def test_formatter_wiring_dropped_failclosed_fails(formatter_text):
+    mutated = formatter_text.replace("fail closed BEFORE formatting", "handle path issues")
+    assert check_formatter_wiring(mutated), "dropping the fail-closed rule must fire"
+
+
+def test_formatter_wiring_dropped_no_inference_fails(formatter_text):
+    mutated = formatter_text.replace("Never infer a missing layout field", "Guess layout")
+    assert check_formatter_wiring(mutated), "dropping the no-inference rule must fire"
+
+
+def test_formatter_wiring_dropped_best_effort_fails(formatter_text):
+    mutated = formatter_text.replace("best-effort per output target", "always applied")
+    assert check_formatter_wiring(mutated), "dropping the best-effort rule must fire"
+
+
+# --- invariant 7: intake wiring ---------------------------------------------
+
+def test_intake_wiring_real_tree_passes(intake_text):
+    assert check_intake_wiring(intake_text) == []
+
+
+def test_intake_wiring_missing_followup_fails():
+    assert check_intake_wiring("# no followup"), "a missing #439 follow-up must fire"
+
+
+def test_intake_wiring_dropped_byte_equiv_rule_fails(intake_text):
+    mutated = intake_text.replace("no PCR `Format Profile` row at all", "an absent row")
+    assert check_intake_wiring(mutated), "dropping the write-nothing rule must fire"
+
+
+def test_intake_wiring_dropped_pcr_row_fails(intake_text):
+    """Remove the structural PCR table row → check must fire (not just the prose mention)."""
+    mutated = intake_text.replace("| **Format Profile** |", "| Format Profile |")
+    assert check_intake_wiring(mutated), "losing the structural PCR Format Profile row must fire"
+
+
+# --- invariant 8: POSITIONING boundary --------------------------------------
+
+@pytest.fixture(scope="module")
+def positioning_text():
+    return POSITIONING.read_text(encoding="utf-8")
+
+
+def test_positioning_boundary_real_tree_passes(positioning_text):
+    assert check_positioning_boundary(positioning_text) == []
+
+
+def test_positioning_boundary_missing_note_fails():
+    assert check_positioning_boundary("# positioning without the boundary"), \
+        "a POSITIONING without the #439 boundary note must fire"
+
+
+def test_positioning_boundary_dropped_review_criterion_fails(positioning_text):
+    mutated = positioning_text.replace("Review criterion:", "Note:")
+    assert check_positioning_boundary(mutated), "dropping the Review criterion must fire"
+
+
+# --- schema behavior: the contract a real profile must satisfy --------------
+# These assert the SCHEMA itself (not the lint) accepts/rejects the right shapes,
+# so the example profiles in the design doc stay valid and the cut/conditional
+# rules hold at the data layer.
+
+@pytest.fixture(scope="module")
+def validator(schema):
+    return Draft202012Validator(schema)
+
+
+def _valid(validator, inst) -> bool:
+    return not list(validator.iter_errors(inst))
+
+
+@pytest.mark.parametrize(
+    "inst",
+    [
+        {},
+        {"body_font": {"family": "SimSun", "size_pt": 10.5}},
+        {"line_spacing": {"mode": "fixed_pt", "fixed_pt": 20}},
+        {"line_spacing": {"mode": "double"}},
+        {"caption": {"placement": "below", "alignment": "center", "latin_font_family": "Times New Roman"}},
+        {"margins_cm": {"top": 2.5, "bottom": 2.5, "left": 3.0, "right": 2.5}},
+        {"table_border_style": "three_line"},
+    ],
+)
+def test_schema_accepts_valid_profiles(validator, inst):
+    assert _valid(validator, inst), f"should be VALID: {inst}"
+
+
+@pytest.mark.parametrize(
+    "inst",
+    [
+        {"line_spacing": {"mode": "double", "fixed_pt": 20}},   # fixed_pt with wrong mode
+        {"line_spacing": {"mode": "fixed_pt"}},                  # fixed_pt mode missing value
+        {"profile_name": "Guangxi undergrad"},                   # cut field
+        {"caption": {"bold": True}},                             # cut field
+        {"heading_font": {"family": "x"}},                       # cut field
+        {"body_font": {"size_pt": 0}},                           # non-positive size
+        {"table_border_style": "dashed"},                        # not in enum
+        {"caption": {"placement": "middle"}},                    # not in enum
+        {"unknown_top_level": 1},                                # locked root
+    ],
+)
+def test_schema_rejects_invalid_profiles(validator, inst):
+    assert not _valid(validator, inst), f"should be INVALID: {inst}"

package/vendor/ars/scripts/test_check_619_disclosure_closeout.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""Focused mutation coverage for the #619 disclosure closeout."""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+CHECKER = REPO_ROOT / "scripts" / "check_619_disclosure_closeout.py"
+PROTOCOL = "academic-paper/references/disclosure_mode_protocol.md"
+POLICIES = "academic-paper/references/venue_disclosure_policies.md"
+AUDIT = "audits/external-contribution-audit-prompt.md"
+ALL_FILES = (PROTOCOL, POLICIES, AUDIT)
+
+
+def _run(root: Path) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, str(CHECKER), "--root", str(root)],
+        capture_output=True,
+        text=True,
+    )
+
+
+@pytest.fixture()
+def tree(tmp_path: Path) -> Path:
+    for rel in ALL_FILES:
+        dst = tmp_path / rel
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy(REPO_ROOT / rel, dst)
+    return tmp_path
+
+
+def _mutate(root: Path, rel: str, old: str, new: str) -> None:
+    path = root / rel
+    text = path.read_text(encoding="utf-8")
+    assert old in text, f"anchor missing in {rel}: {old!r}"
+    path.write_text(text.replace(old, new, 1), encoding="utf-8")
+
+
+def test_clean_tree_passes(tree: Path) -> None:
+    result = _run(tree)
+    assert result.returncode == 0, result.stderr
+
+
+@pytest.mark.parametrize(
+    ("scenario", "old", "new"),
+    (
+        (
+            "created text",
+            "| Created written content | REQUIRED | REQUIRED | — |",
+            "| Created written content | — | REQUIRED | — |",
+        ),
+        (
+            "edited text",
+            "| Edited written content | — | REQUIRED | — |",
+            "| Edited written content | REQUIRED | REQUIRED | — |",
+        ),
+        (
+            "non-data visual",
+            "| Produced non-data visual content | REQUIRED | REQUIRED | — |",
+            "| Produced non-data visual content | REQUIRED | REQUIRED | REQUIRED |",
+        ),
+        (
+            "data-representing figure",
+            "| Produced figure representing manuscript data | REQUIRED | REQUIRED | REQUIRED |",
+            "| Produced figure representing manuscript data | REQUIRED | REQUIRED | — |",
+        ),
+    ),
+)
+def test_frontiers_action_matrix_is_semantically_pinned(
+    tree: Path, scenario: str, old: str, new: str
+) -> None:
+    _mutate(tree, PROTOCOL, old, new)
+    result = _run(tree)
+    assert result.returncode == 1
+    assert scenario in result.stderr
+
+
+def test_frontiers_phase2_render_gate_cannot_regrow(tree: Path) -> None:
+    _mutate(
+        tree,
+        PROTOCOL,
+        "Use that forms part of the research method: method-level description.",
+        "Use that forms part of the research method: method-level description. "
+        "Figure use: plagiarism-free confirmation before render.",
+    )
+    result = _run(tree)
+    assert result.returncode == 1
+    assert "Phase 2b" in result.stderr
+
+
+def test_unknown_action_state_stays_outstanding_not_halted(tree: Path) -> None:
+    _mutate(
+        tree,
+        PROTOCOL,
+        "UNKNOWN or false action state is OUTSTANDING",
+        "UNKNOWN action state is UNKNOWN/HALTED",
+    )
+    result = _run(tree)
+    assert result.returncode == 1
+    assert "OUTSTANDING" in result.stderr
+
+
+def test_frontiers_quality_actions_are_not_categorical_prohibitions(tree: Path) -> None:
+    _mutate(
+        tree,
+        POLICIES,
+        "Editors/reviewers uploading manuscript content to external generative AI tools.",
+        "Editors/reviewers uploading manuscript content to external generative AI tools. "
+        "Unchecked figures are prohibited.",
+    )
+    result = _run(tree)
+    assert result.returncode == 1
+    assert "Prohibited uses" in result.stderr
+
+
+def test_jama_snapshot_gap_is_explicit(tree: Path) -> None:
+    _mutate(
+        tree,
+        POLICIES,
+        "A Piece of My Mind and Poetry drafting clauses were verified on the live official page on 2026-08-01 and are absent from the cited 2026-07-01 snapshot.",
+        "The cited snapshot includes all current manuscript-class clauses.",
+    )
+    result = _run(tree)
+    assert result.returncode == 1
+    assert "JAMA" in result.stderr
+    assert "snapshot" in result.stderr
+
+
+def test_audit_round_exact_heads_and_counts_are_pinned(tree: Path) -> None:
+    _mutate(tree, AUDIT, "Template A: 8 P1 / 6 P2 / 1 P3", "Template A: 7 P1 / 6 P2 / 1 P3")
+    result = _run(tree)
+    assert result.returncode == 1
+    assert "2026-08-01" in result.stderr
+
+
+def test_old_multi_pr_head_cannot_be_reassigned_to_new_round(tree: Path) -> None:
+    _mutate(
+        tree,
+        AUDIT,
+        "PR #599 blind audit head `7bb578d3`",
+        "PR #599 blind audit head `45653587`",
+    )
+    result = _run(tree)
+    assert result.returncode == 1
+    assert "7bb578d3" in result.stderr
+
+
+def test_missing_required_file_is_invocation_error(tree: Path) -> None:
+    (tree / AUDIT).unlink()
+    result = _run(tree)
+    assert result.returncode == 2
+    assert "required file missing" in result.stderr