psyclaw 0.27.22 → 0.28.0

package/vendor/ars/scripts/test_check_630_codex_subscription_transport.py

@@ -0,0 +1,245 @@
+"""Mutation tests for the #630 integration guard."""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+from pathlib import Path
+
+import pytest
+
+
+REPO = Path(__file__).resolve().parent.parent
+GUARD_PATH = REPO / "scripts" / "check_630_codex_subscription_transport.py"
+
+
+def _load_guard():
+    spec = importlib.util.spec_from_file_location("guard_630", GUARD_PATH)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _mutated_file(tmp_path: Path, source: Path, old: str, new: str) -> Path:
+    original = source.read_text(encoding="utf-8")
+    mutated = original.replace(old, new, 1)
+    assert mutated != original, f"mutation was a no-op: {old!r}"
+    target = tmp_path / source.name
+    target.write_text(mutated, encoding="utf-8")
+    return target
+
+
+def test_guard_passes_real_tree() -> None:
+    assert _load_guard().check_all() == []
+
+
+@pytest.mark.parametrize(
+    "name,old,new,expected",
+    [
+        ("open-root", '"additionalProperties": false', '"additionalProperties": true', "not closed"),
+        ("prompt-field", '"citation_context": {', '"prompt": {', "four-field"),
+        ("wrong-version", "ars-codex-citation-request/1.0", "ars-codex-citation-request/2.0", "version"),
+    ],
+)
+def test_schema_mutations_fail(tmp_path: Path, monkeypatch, name, old, new, expected) -> None:
+    del name
+    guard = _load_guard()
+    mutated = _mutated_file(tmp_path, guard.REQUEST_SCHEMA, old, new)
+    monkeypatch.setattr(guard, "REQUEST_SCHEMA", mutated)
+    assert any(expected in error for error in guard.check_schemas())
+
+
+def test_source_binding_mutation_fails(tmp_path: Path, monkeypatch) -> None:
+    guard = _load_guard()
+    data = json.loads(guard.RECEIPT_SCHEMA.read_text(encoding="utf-8"))
+    data["$defs"]["source_binding"]["required"].remove("search_result_digest")
+    target = tmp_path / "receipt.json"
+    target.write_text(json.dumps(data), encoding="utf-8")
+    monkeypatch.setattr(guard, "RECEIPT_SCHEMA", target)
+    assert any("source binding" in error for error in guard.check_schemas())
+
+
+def test_receipt_cross_field_condition_mutation_fails(tmp_path: Path, monkeypatch) -> None:
+    guard = _load_guard()
+    data = json.loads(guard.RECEIPT_SCHEMA.read_text(encoding="utf-8"))
+    data["allOf"] = []
+    target = tmp_path / "receipt.json"
+    target.write_text(json.dumps(data), encoding="utf-8")
+    monkeypatch.setattr(guard, "RECEIPT_SCHEMA", target)
+    assert any("cross-field conditions" in error for error in guard.check_schemas())
+
+
+@pytest.mark.parametrize(
+    "old,new,expected",
+    [
+        ('"app-server"', '"exec"', "app-server"),
+        ('"standalone_web_search"', '"something_else"', "standalone_web_search"),
+        ('"sandbox": "read-only"', '"sandbox": "danger-full-access"', "read-only"),
+        ('"approvalPolicy": "never"', '"approvalPolicy": "on-request"', "never"),
+        ('"dynamicTools": []', '"dynamicTools": None', "dynamicTools"),
+        ('"Logged in using ChatGPT"', '"Logged in"', "Logged in using ChatGPT"),
+        ('selector != "codex"', 'selector not in {"codex", "anything"}', "selector"),
+        ('"webSearch"', '"agentMessage"', "webSearch"),
+        ('"search_result_digest"', '"result_digest"', "search_result_digest"),
+    ],
+)
+def test_runtime_mutations_fail(tmp_path: Path, monkeypatch, old, new, expected) -> None:
+    guard = _load_guard()
+    mutated = _mutated_file(tmp_path, guard.RUNTIME, old, new)
+    monkeypatch.setattr(guard, "RUNTIME", mutated)
+    assert any(expected in error for error in guard.check_runtime())
+
+
+def test_child_env_secret_mutation_fails(tmp_path: Path, monkeypatch) -> None:
+    guard = _load_guard()
+    mutated = _mutated_file(
+        tmp_path,
+        guard.RUNTIME,
+        '"NO_COLOR": "1",',
+        '"NO_COLOR": "1",\n        "OPENAI_API_KEY": environ.get("OPENAI_API_KEY", ""),',
+    )
+    monkeypatch.setattr(guard, "RUNTIME", mutated)
+    assert any("child environment" in error for error in guard.check_runtime())
+
+
+@pytest.mark.parametrize(
+    "old,new,expected",
+    [
+        (
+            "_close_app_server_stdin(proc)",
+            "_stop_process(proc)",
+            "post-terminal EOF boundary",
+        ),
+        (
+            "drain_deadline = min(\n"
+            "                deadline, terminal_observed_at + APP_SERVER_DRAIN_GRACE_SECONDS\n"
+            "            )",
+            "drain_deadline = terminal_observed_at + APP_SERVER_DRAIN_GRACE_SECONDS",
+            "post-terminal EOF boundary",
+        ),
+        (
+            "if remaining <= 0:\n"
+            '        raise TransportError("APP_SERVER_DRAIN_TIMEOUT")\n'
+            "    return remaining",
+            "if remaining <= 0:\n        return 0.001\n    return remaining",
+            "deadline no longer fails closed",
+        ),
+        (
+            "            _drain_app_server_after_turn(\n"
+            "                proc,\n"
+            "                reader,\n"
+            "                stderr_reader,\n"
+            "                messages,\n"
+            "                raw_lines,\n"
+            "                drain_deadline,\n"
+            "            )",
+            "            try:\n"
+            "                _drain_app_server_after_turn(\n"
+            "                    proc,\n"
+            "                    reader,\n"
+            "                    stderr_reader,\n"
+            "                    messages,\n"
+            "                    raw_lines,\n"
+            "                    drain_deadline,\n"
+            "                )\n"
+            "            except TransportError:\n"
+            "                pass",
+            "drain failure is caught",
+        ),
+    ],
+    ids=[
+        "stdin-close-removed",
+        "fresh-drain-timeout",
+        "drain-timeout-ignored",
+        "drain-error-swallowed",
+    ],
+)
+def test_terminal_drain_mutations_fail(
+    tmp_path: Path, monkeypatch, old: str, new: str, expected: str
+) -> None:
+    guard = _load_guard()
+    mutated = _mutated_file(tmp_path, guard.RUNTIME, old, new)
+    monkeypatch.setattr(guard, "RUNTIME", mutated)
+    assert any(expected in error for error in guard.check_runtime())
+
+
+@pytest.mark.parametrize(
+    "helper,constructor",
+    [
+        ("reader", "_LineReader(proc.stdout, limit=MAX_EVENT_BYTES)"),
+        ("stderr_reader", "_DrainReader(proc.stderr, limit=MAX_STDERR_BYTES)"),
+    ],
+    ids=["stdout-helper-escaped", "stderr-helper-escaped"],
+)
+def test_reader_helper_construction_must_remain_process_owned(
+    tmp_path: Path, monkeypatch, helper: str, constructor: str
+) -> None:
+    guard = _load_guard()
+    original = guard.RUNTIME.read_text(encoding="utf-8")
+    owner_anchor = (
+        "        try:\n"
+        "            if proc.stdout is None or proc.stderr is None:\n"
+    )
+    mutated = original.replace(
+        owner_anchor,
+        f"        {helper} = {constructor}\n" + owner_anchor,
+        1,
+    ).replace(
+        f"            {helper} = {constructor}\n",
+        f"            {helper} = {helper}\n",
+        1,
+    )
+    assert mutated != original
+    target = tmp_path / "runtime.py"
+    target.write_text(mutated, encoding="utf-8")
+    monkeypatch.setattr(guard, "RUNTIME", target)
+    assert any("not process-owned" in error for error in guard.check_runtime())
+
+
+@pytest.mark.parametrize(
+    "attribute,old,new,expected",
+    [
+        ("SPEC", "Source implementation: PR #567 by `dcs-scd`", "Source implementation: internal", "PR #567"),
+        ("PROTOCOL", "**Recommendation policy (2026-08-19):**", "**GPT-5.6 is recommended:**", "recommendation-policy"),
+        ("PROTOCOL", "a lifecycle decision, not a measurement claim", "a measured upgrade over GPT-5.5", "recommendation-policy"),
+        ("PROTOCOL", "`validated` is earned only there", "`validated` is granted on release", "recommendation-policy"),
+        ("PRODUCER", "This adapter is not available to DA, reviewer, calibration", "This adapter is available to every path", "non-citation"),
+        ("CHANGELOG", "@dcs-scd", "@someone-else", "@dcs-scd"),
+    ],
+)
+def test_doc_mutations_fail(tmp_path: Path, monkeypatch, attribute, old, new, expected) -> None:
+    guard = _load_guard()
+    source = getattr(guard, attribute)
+    mutated = _mutated_file(tmp_path, source, old, new)
+    monkeypatch.setattr(guard, attribute, mutated)
+    assert any(expected in error for error in guard.check_docs_and_wiring())
+
+
+def test_smoke_wired_to_ci_fails(tmp_path: Path, monkeypatch) -> None:
+    guard = _load_guard()
+    mutated = tmp_path / "workflow.yml"
+    mutated.write_text(
+        guard.WORKFLOW.read_text(encoding="utf-8")
+        + "\n      - run: scripts/cross_model_smoke_test_codex.sh\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(guard, "WORKFLOW", mutated)
+    assert any("live Codex smoke" in error for error in guard.check_shell_and_ci())
+
+
+def test_bash_4_mutation_fails(tmp_path: Path, monkeypatch) -> None:
+    guard = _load_guard()
+    mutated = _mutated_file(tmp_path, guard.VERIFY_SH, "set -u", "set -u\nmapfile rows")
+    monkeypatch.setattr(guard, "VERIFY_SH", mutated)
+    assert any("non-Bash-3.2" in error for error in guard.check_shell_and_ci())
+
+
+def test_fixture_inventory_mutation_fails(tmp_path: Path, monkeypatch) -> None:
+    guard = _load_guard()
+    fixtures = tmp_path / "fixtures"
+    fixtures.mkdir()
+    for name in sorted(guard.EXPECTED_FIXTURES - {"missing_search.jsonl"}):
+        (fixtures / name).write_text("{}\n", encoding="utf-8")
+    monkeypatch.setattr(guard, "FIXTURES", fixtures)
+    assert any("fixture inventory drift" in error for error in guard.check_shell_and_ci())

package/vendor/ars/scripts/test_check_669_review_pathway_rule_trace.py

@@ -0,0 +1,304 @@
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+import pytest
+
+from scripts import check_669_review_pathway_rule_trace as check
+
+
+ROOT = Path(__file__).resolve().parents[1]
+CHECKED = (
+    check.REQUEST_SCHEMA,
+    check.TRACE_SCHEMA,
+    check.REGISTRY,
+    check.RUNTIME,
+    check.OUTPUT_LINT,
+    check.RUNTIME_TEST,
+    check.LINT_FIXTURE,
+    check.DESIGN,
+    check.PROTOCOL,
+    check.AUTHORITY_PROTOCOL,
+    check.CONTRACT_README,
+    check.NAVIGATION_AID,
+    check.DEEP_SKILL,
+    check.ETHICS_AGENT,
+    check.ARCHITECT,
+    check.ARCHITECT_MIRROR,
+    check.CI_MANIFEST,
+    check.WORKFLOW,
+)
+
+
+@pytest.fixture
+def tree(tmp_path: Path) -> Path:
+    for rel in CHECKED:
+        target = tmp_path / rel
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(ROOT / rel, target)
+    return tmp_path
+
+
+def _errors(tree: Path) -> list[str]:
+    return check.run_checks(tree)
+
+
+def _replace(tree: Path, rel: Path, old: str, new: str) -> None:
+    path = tree / rel
+    text = path.read_text(encoding="utf-8")
+    assert old in text
+    path.write_text(text.replace(old, new, 1), encoding="utf-8")
+
+
+def test_current_tree_passes() -> None:
+    assert check.run_checks(ROOT) == []
+
+
+@pytest.mark.parametrize(
+    ("rel", "snippet"),
+    [
+        (rel, snippet)
+        for rel, snippets in check.REQUIRED_SNIPPETS.items()
+        for snippet in snippets
+    ],
+)
+def test_required_wiring_removal_fails(tree: Path, rel: Path, snippet: str) -> None:
+    _replace(tree, rel, snippet, "removed-669-contract")
+    assert _errors(tree)
+
+
+@pytest.mark.parametrize(
+    ("rel", "snippet"),
+    [
+        (rel, snippet)
+        for rel, scopes in check.SCOPED_SNIPPETS.items()
+        for _start, _end, snippets in scopes
+        for snippet in snippets
+    ],
+)
+def test_shadow_token_cannot_mask_primary_contract_removal(
+    tree: Path, rel: Path, snippet: str
+) -> None:
+    path = tree / rel
+    text = path.read_text(encoding="utf-8")
+    assert snippet in text
+    path.write_text(
+        text.replace(snippet, "removed-primary-contract", 1)
+        + f"\n<!-- shadow only: {snippet} -->\n",
+        encoding="utf-8",
+    )
+    assert any("primary #669 section" in error for error in _errors(tree))
+
+
+def test_schema_result_footer_and_state_drift_fail(tree: Path) -> None:
+    path = tree / check.TRACE_SCHEMA
+    value = json.loads(path.read_text(encoding="utf-8"))
+    value["properties"]["result"]["const"] = "candidate selected"
+    path.write_text(json.dumps(value), encoding="utf-8")
+    assert any("institutional result" in error for error in _errors(tree))
+
+    value = json.loads((ROOT / check.TRACE_SCHEMA).read_text(encoding="utf-8"))
+    value["properties"]["boundary_footer"]["const"] = "Authorization granted."
+    path.write_text(json.dumps(value), encoding="utf-8")
+    assert any("footer" in error for error in _errors(tree))
+
+    value = json.loads((ROOT / check.TRACE_SCHEMA).read_text(encoding="utf-8"))
+    value["properties"]["trace_state"]["enum"].append("approved")
+    path.write_text(json.dumps(value), encoding="utf-8")
+    assert any("trace-state" in error for error in _errors(tree))
+
+
+@pytest.mark.parametrize(
+    "field",
+    [
+        "verdict",
+        "gate",
+        "checkpoint",
+        "approval_status",
+        "probability",
+        "selected_pathway",
+        "submission_readiness",
+        "authorization_status",
+    ],
+)
+def test_trace_schema_cannot_represent_determination_or_workflow_field(
+    tree: Path, field: str
+) -> None:
+    path = tree / check.TRACE_SCHEMA
+    value = json.loads(path.read_text(encoding="utf-8"))
+    value["properties"][field] = {"type": "string"}
+    path.write_text(json.dumps(value), encoding="utf-8")
+    assert any("determination/workflow keys" in error for error in _errors(tree))
+
+
+def test_request_two_axis_grammar_drift_fails(tree: Path) -> None:
+    path = tree / check.REQUEST_SCHEMA
+    value = json.loads(path.read_text(encoding="utf-8"))
+    value["$defs"]["profile_ref"]["properties"]["axis"]["enum"] = [
+        "review_ethics"
+    ]
+    path.write_text(json.dumps(value), encoding="utf-8")
+    assert any("two-axis" in error for error in _errors(tree))
+
+
+@pytest.mark.parametrize("rel", [check.REQUEST_SCHEMA, check.TRACE_SCHEMA])
+def test_display_only_ordering_constant_drift_fails(tree: Path, rel: Path) -> None:
+    path = tree / rel
+    value = json.loads(path.read_text(encoding="utf-8"))
+    value["properties"]["ordering_semantics"]["const"] = "preferred_order"
+    path.write_text(json.dumps(value), encoding="utf-8")
+    assert any("ordering constant" in error for error in _errors(tree))
+
+
+def test_any_object_schema_opening_fails(tree: Path) -> None:
+    path = tree / check.REQUEST_SCHEMA
+    value = json.loads(path.read_text(encoding="utf-8"))
+    value["$defs"]["candidate_pathway"]["additionalProperties"] = True
+    path.write_text(json.dumps(value), encoding="utf-8")
+    assert any("not closed" in error for error in _errors(tree))
+
+
+def test_alternative_row_schema_cap_drift_fails(tree: Path) -> None:
+    path = tree / check.TRACE_SCHEMA
+    value = json.loads(path.read_text(encoding="utf-8"))
+    value["$defs"]["candidate_trace"]["properties"][
+        "alternative_pathway_triggers"
+    ]["maxItems"] = 65536
+    path.write_text(json.dumps(value), encoding="utf-8")
+    assert any("alternative-row schema cap" in error for error in _errors(tree))
+
+
+def test_registry_requirement_scope_removal_fails(tree: Path) -> None:
+    path = tree / check.REGISTRY
+    value = json.loads(path.read_text(encoding="utf-8"))
+    scopes = value["profiles"][0]["requirements"][0]["consumer_scopes"]
+    scopes.remove("pathway_trace")
+    path.write_text(json.dumps(value), encoding="utf-8")
+    assert any("lost pathway_trace" in error for error in _errors(tree))
+
+
+def test_lint_fixture_class_coverage_drift_fails(tree: Path) -> None:
+    path = tree / check.LINT_FIXTURE
+    value = json.loads(path.read_text(encoding="utf-8"))
+    value["failing_surfaces"] = [
+        row
+        for row in value["failing_surfaces"]
+        if row["class"] != "hedged_determination"
+    ]
+    path.write_text(json.dumps(value), encoding="utf-8")
+    assert any("near-miss class coverage" in error for error in _errors(tree))
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        "\nimport socket\n",
+        "\nimport openai\n",
+        "\nimport subprocess\n",
+        "\ndef scan(path):\n    return path.rglob('*')\n",
+        "\ndef scan(path):\n    return os.listdir(path)\n",
+        "\ndef clock():\n    return date.today()\n",
+        "\ndef dynamic(text):\n    return eval(text)\n",
+        "\ndef reflected(path):\n    return getattr(path, 'rglob')('*')\n",
+        "\ndef judge(value):\n    return value\n\ndef use(value):\n    return judge(value)\n",
+    ],
+)
+@pytest.mark.parametrize("rel", [check.RUNTIME, check.OUTPUT_LINT])
+def test_runtime_or_lint_transport_scan_clock_model_drift_fails(
+    tree: Path, rel: Path, payload: str
+) -> None:
+    path = tree / rel
+    path.write_text(path.read_text(encoding="utf-8") + payload, encoding="utf-8")
+    assert _errors(tree)
+
+
+@pytest.mark.parametrize(
+    ("rel", "name"),
+    [
+        (check.RUNTIME, "build_review_pathway_rule_trace"),
+        (check.RUNTIME, "validate_review_pathway_rule_trace"),
+        (check.RUNTIME, "render_review_pathway_rule_trace"),
+        (check.OUTPUT_LINT, "normalize_surface"),
+        (check.OUTPUT_LINT, "lint_trace_surface"),
+    ],
+)
+def test_required_public_function_rename_fails(
+    tree: Path, rel: Path, name: str
+) -> None:
+    _replace(tree, rel, f"def {name}(", f"def removed_{name}(")
+    assert any("missing required function" in error for error in _errors(tree))
+
+
+def test_pathway_or_banned_vocabulary_drift_fails(tree: Path) -> None:
+    _replace(tree, check.OUTPUT_LINT, '("exempt",),', '("removed",),')
+    assert any("pathway-name vocabulary" in error for error in _errors(tree))
+    shutil.copyfile(ROOT / check.OUTPUT_LINT, tree / check.OUTPUT_LINT)
+    _replace(tree, check.OUTPUT_LINT, '("approved",),', '("removed",),')
+    assert any("banned-output vocabulary" in error for error in _errors(tree))
+
+
+@pytest.mark.parametrize(
+    ("rel", "old", "new", "message"),
+    [
+        (check.RUNTIME, "MAX_ALTERNATIVE_ROWS = 4096", "MAX_ALTERNATIVE_ROWS = 9999", "safety limit"),
+        (check.RUNTIME, "MAX_TRACE_BYTES = 8 * 1024 * 1024", "MAX_TRACE_BYTES = 16 * 1024 * 1024", "safety limit"),
+        (check.RUNTIME, "MAX_RENDERED_BYTES = 8 * 1024 * 1024", "MAX_RENDERED_BYTES = 16 * 1024 * 1024", "safety limit"),
+        (check.OUTPUT_LINT, "MAX_RENDERED_BYTES = 8 * 1024 * 1024", "MAX_RENDERED_BYTES = 16 * 1024 * 1024", "byte limit"),
+        (check.OUTPUT_LINT, "MAX_SURFACE_NODES = 200_000", "MAX_SURFACE_NODES = 300_000", "node limit"),
+    ],
+)
+def test_resource_limit_drift_fails(
+    tree: Path, rel: Path, old: str, new: str, message: str
+) -> None:
+    _replace(tree, rel, old, new)
+    assert any(message in error for error in _errors(tree))
+
+
+def test_candidate_json_or_markdown_grammar_drift_fails(tree: Path) -> None:
+    _replace(
+        tree,
+        check.OUTPUT_LINT,
+        'path[2] == "candidate_pathway_name"',
+        'path[2] == "any_text"',
+    )
+    assert _errors(tree)
+    shutil.copyfile(ROOT / check.OUTPUT_LINT, tree / check.OUTPUT_LINT)
+    _replace(
+        tree,
+        check.OUTPUT_LINT,
+        'line.startswith("Candidate pathway examined:")',
+        'line.startswith("Candidate:")',
+    )
+    assert _errors(tree)
+
+
+def test_linter_cannot_grow_an_ambient_path_argument(tree: Path) -> None:
+    path = tree / check.OUTPUT_LINT
+    path.write_text(
+        path.read_text(encoding="utf-8")
+        + '\n\ndef forbidden(parser):\n    parser.add_argument("--root")\n',
+        encoding="utf-8",
+    )
+    # The forbidden function alone is not a scan; make the execution surface
+    # materially ambient so the AST guard proves the policy boundary.
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write("\ndef forbidden_scan(path):\n    return path.rglob('*.md')\n")
+    assert any("ambient scan" in error for error in _errors(tree))
+
+
+def test_architect_mirror_drift_fails(tree: Path) -> None:
+    path = tree / check.ARCHITECT_MIRROR
+    path.write_text(path.read_text(encoding="utf-8") + "\nmirror drift\n", encoding="utf-8")
+    assert any("mirror drift" in error for error in _errors(tree))
+
+
+def test_duplicate_schema_key_fails_strict_json(tree: Path) -> None:
+    path = tree / check.TRACE_SCHEMA
+    text = path.read_text(encoding="utf-8")
+    path.write_text(
+        text.replace('"title":', '"title":"duplicate",\n"title":', 1),
+        encoding="utf-8",
+    )
+    assert any("duplicate key" in error for error in _errors(tree))