procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/skills/tests/test_agent_skill_engineer.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+import pytest
+import yaml
+
+ROOT = Path(__file__).resolve().parents[2]
+SKILL_ROOT = ROOT / "skills" / "agent-skill-engineer"
+
+
+def _load(name: str, path: Path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    assert spec and spec.loader
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+SCAFFOLD = _load(
+    "agent_skill_scaffold",
+    SKILL_ROOT / "scripts" / "scaffold_skill.py",
+)
+AUDIT = _load(
+    "agent_skill_audit",
+    SKILL_ROOT / "scripts" / "audit_skill.py",
+)
+
+
+def _frontmatter(path: Path) -> dict:
+    lines = path.read_text(encoding="utf-8").splitlines()
+    end = lines[1:].index("---") + 1
+    value = yaml.safe_load("\n".join(lines[1:end]))
+    assert isinstance(value, dict)
+    return value
+
+
+def _governed_skill_mds() -> list[Path]:
+    """Skill manuals that opt into the governance/eval discipline (the
+    `source_policy` marker). The strict audit and the fixed-rubric contract apply
+    to the governed portfolio; a fuller tree (AAT) also hosts imported/portable
+    skills that never signed up for them. In procesio-cli, whose skills/ IS the
+    portfolio, this is every skill."""
+    out: list[Path] = []
+    for skill_md in sorted((ROOT / "skills").glob("*/SKILL.md")):
+        if skill_md.parent.name.startswith("_") or skill_md.parent.name == "tests":
+            continue
+        try:
+            frontmatter = _frontmatter(skill_md)
+        except Exception:  # noqa: BLE001 - a broken skill is validate-skills' job
+            continue
+        if frontmatter.get("source_policy"):
+            out.append(skill_md)
+    return out
+
+
+def test_meta_skill_passes_its_deterministic_audit():
+    report = AUDIT.audit_skill(SKILL_ROOT)
+
+    assert report["passed"] is True
+    assert report["errors"] == 0
+    assert report["warnings"] == 0
+    assert report["quality_score"] == 100
+
+
+@pytest.mark.parametrize("skill_md", _governed_skill_mds(),
+                         ids=lambda path: path.parent.name)
+def test_every_published_skill_passes_strict_audit(skill_md):
+    report = AUDIT.audit_skill(skill_md.parent)
+    assert report["errors"] == 0, report["findings"]
+    assert report["warnings"] == 0, report["findings"]
+
+
+@pytest.mark.parametrize("category", ["references", "scripts", "assets"])
+def test_audit_resolves_category_paths_from_skill_root(tmp_path, category):
+    root = tmp_path / "demo"
+    source = root / "references" / "context.md"
+    target = root / category / "example.txt"
+    source.parent.mkdir(parents=True)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text("example", encoding="utf-8")
+    source.write_text(f"Read `{category}/example.txt`.\n", encoding="utf-8")
+
+    assert AUDIT._candidate_reference(f"{category}/example.txt", source, root) == target.resolve()
+    findings = AUDIT._scan_links(root, [source])
+    assert not [item for item in findings if item.code == "missing-reference"]
+    assert not [item for item in findings if item.path == f"{category}/example.txt"]
+
+
+@pytest.mark.parametrize("raw,code", [
+    ("scripts/missing.sql", "missing-reference"),
+    ("../outside.md", "unsafe-reference"),
+    ("scripts/../../outside.md", "unsafe-reference"),
+])
+def test_audit_resource_resolution_still_rejects_invalid_paths(tmp_path, raw, code):
+    root = tmp_path / "demo"
+    source = root / "references" / "context.md"
+    source.parent.mkdir(parents=True)
+    source.write_text(f"[resource]({raw})\n", encoding="utf-8")
+    assert code in {item.code for item in AUDIT._scan_links(root, [source])}
+
+
+def test_audit_resource_resolution_rejects_symlink_escape(tmp_path):
+    root = tmp_path / "demo"
+    source = root / "references" / "context.md"
+    source.parent.mkdir(parents=True)
+    (root / "scripts").mkdir()
+    outside = tmp_path / "outside.sql"
+    outside.write_text("SELECT 1;", encoding="utf-8")
+    try:
+        (root / "scripts" / "export.sql").symlink_to(outside)
+    except OSError:
+        pytest.skip("symlink creation unavailable on this platform")
+    source.write_text("Read `scripts/export.sql`.\n", encoding="utf-8")
+    assert "unsafe-reference" in {item.code for item in AUDIT._scan_links(root, [source])}
+
+
+def test_scaffold_is_path_confined_governed_and_no_overwrite(tmp_path):
+    parser = SCAFFOLD._parser()
+    args = parser.parse_args(
+        [
+            "incident-triage",
+            "--root",
+            str(tmp_path),
+            "--description",
+            "Triage recurring incidents. Use when an incident report needs a bounded diagnostic workflow.",
+            "--profile",
+            "governed",
+            "--owner",
+            "platform team",
+            "--baseline-version",
+            "abc123",
+            "--trigger",
+            "triage a recurring production incident",
+        ]
+    )
+
+    result = SCAFFOLD.scaffold(args)
+    target = tmp_path / "incident-triage"
+
+    assert result["created"] is True
+    assert (target / "SKILL.md").is_file()
+    assert (target / "evals" / "evals.json").is_file()
+    frontmatter = _frontmatter(target / "SKILL.md")
+    assert frontmatter["name"] == "incident-triage"
+    assert frontmatter["owner"] == "platform team"
+    assert frontmatter["eval_suite"] == "evals/evals.json"
+    suite = json.loads((target / "evals" / "evals.json").read_text(encoding="utf-8"))
+    assert {case["kind"] for case in suite["cases"]} == {
+        "positive",
+        "negative",
+        "overlap",
+        "pressure",
+    }
+    assert suite["rubric_contract"] == "fixed-jury-rubric-v2"
+
+    with pytest.raises(FileExistsError, match="refusing to overwrite"):
+        SCAFFOLD.scaffold(args)
+
+    with pytest.raises(ValueError, match="lowercase"):
+        bad = argparse.Namespace(**{**vars(args), "name": "../escape"})
+        SCAFFOLD.scaffold(bad)
+
+
+def test_audit_rejects_dynamic_jury_and_unsafe_reference(tmp_path):
+    root = tmp_path / "broken-skill"
+    (root / "evals").mkdir(parents=True)
+    (root / "SKILL.md").write_text(
+        "---\n"
+        "name: broken-skill\n"
+        "description: Use when auditing a broken example.\n"
+        "version: 1.0.0\n"
+        "owner: test\n"
+        "last_verified: 2026-09-04\n"
+        "baseline_version: abc\n"
+        "eval_suite: evals/evals.json\n"
+        "source_policy: stable\n"
+        "routing:\n  triggers: [audit a broken example]\n"
+        "---\n\n"
+        "# Broken\n\n"
+        "## Boundary\nBounded.\n\n"
+        "## Workflow\nRead [outside](../outside.md).\n\n"
+        "## Verification\nInspect the report.\n",
+        encoding="utf-8",
+    )
+    (root / "evals" / "evals.json").write_text(
+        json.dumps(
+            {
+                "skill_name": "broken-skill",
+                "evals": [
+                    {
+                        "id": "one",
+                        "kind": "positive",
+                        "prompt": "Do it",
+                        "expected_output": "Be good and safe.",
+                    }
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    report = AUDIT.audit_skill(root)
+    codes = {item["code"] for item in report["findings"]}
+
+    assert report["passed"] is False
+    assert "unsafe-reference" in codes
+    assert "dynamic-jury-rubric" in codes
+
+
+def test_every_published_skill_uses_fixed_atomic_eval_rubrics():
+    criterion_id = AUDIT.CRITERION_RE
+    case_kinds = AUDIT.CASE_KINDS
+
+    for skill_md in _governed_skill_mds():
+        frontmatter = _frontmatter(skill_md)
+        suite_path = skill_md.parent / frontmatter["eval_suite"]
+        suite = json.loads(suite_path.read_text(encoding="utf-8"))
+        cases = suite["cases"]
+
+        assert suite["schema_version"] >= 2, skill_md.parent.name
+        assert suite["skill_name"] == frontmatter["name"]
+        assert suite["rubric_contract"] == "fixed-jury-rubric-v2"
+        assert {case["kind"] for case in cases} == case_kinds
+
+        for case in cases:
+            expected = case["expected_output"]
+            criteria = expected["criteria"]
+            ids = [entry["id"] for entry in criteria]
+            assert expected["rubric_version"] >= 1
+            assert 2 <= len(criteria) <= 8
+            assert len(ids) == len(set(ids))
+            assert all(criterion_id.fullmatch(item) for item in ids)
+            assert all(entry["description"].startswith("Pass only when") for entry in criteria)
+            assert all(isinstance(entry["required"], bool) for entry in criteria)

procesio_cli/skills/tests/test_auth_failure_stop.py

@@ -0,0 +1,25 @@
+"""The operational skill must not encourage endpoint exploration after auth fails."""
+from __future__ import annotations
+
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+SKILL = ROOT / "skills" / "procesio-cli"
+
+
+def test_credentials_playbook_stops_after_failed_check_auth():
+    text = (SKILL / "references" / "credentials-admin.md").read_text(encoding="utf-8")
+    lowered = text.lower()
+    assert "authentication hard stop" in lowered
+    assert "authenticated: false" in lowered
+    assert "stop all remote procesio calls" in lowered
+    assert "show-credential" in lowered
+    assert "key handle" in lowered and "api key value" in lowered
+    assert "configured but not confirmed" in lowered
+
+
+def test_main_skill_treats_failed_readiness_as_a_stop_condition():
+    text = (SKILL / "SKILL.md").read_text(encoding="utf-8").lower()
+    assert "authenticated: false" in text
+    assert "mode" in text
+    assert "stop" in text

procesio_cli/skills/tests/test_capacity_estimator.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import importlib.util
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+SCRIPT = Path(__file__).resolve().parents[2] / "skills/procesio-platform-advisor/scripts/estimate_capacity.py"
+
+
+def module():
+    spec = importlib.util.spec_from_file_location("capacity_estimator", SCRIPT)
+    value = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(value)
+    return value
+
+
+def payload():
+    return {"executions": 10000, "available_seconds": 3600,
+            "mean_active_compute_seconds": 2, "mean_occupied_seconds": 20,
+            "busy_interval_arrival_rate": 5, "safety_factor": 1.25}
+
+
+def test_documented_example_requires_capacity_source_before_ee_conversion():
+    data = payload()
+    estimate = module().estimate(data)
+    assert estimate["compute_work_seconds"] == 20000
+    assert estimate["occupied_slot_seconds"] == 200000
+    assert estimate["average_occupied_slots"] == pytest.approx(55.55555556)
+    assert estimate["planned_slots"] == 125
+    assert estimate["slot_based_ee_lower_bound"] is None
+    data.update(verified_slots_per_ee=10, capacity_source="hypothetical example, not a product limit")
+    assert module().estimate(data)["slot_based_ee_lower_bound"] == 13
+
+
+@pytest.mark.parametrize("key,value", [
+    ("executions", True), ("executions", 1.5), ("available_seconds", 0),
+    ("mean_occupied_seconds", None), ("safety_factor", 0.5),
+    ("mean_active_compute_seconds", float("nan")),
+    ("busy_interval_arrival_rate", float("inf")), ("executions", -1),
+])
+def test_invalid_units_and_nonfinite_inputs_fail(key, value):
+    data = payload()
+    data[key] = value
+    with pytest.raises(ValueError):
+        module().estimate(data)
+
+
+def test_unattributed_capacity_and_unknown_fields_fail():
+    with pytest.raises(ValueError):
+        module().estimate(dict(payload(), verified_slots_per_ee=10))
+    with pytest.raises(ValueError):
+        module().estimate(dict(payload(), slots_per_ee=10))
+
+
+def test_zero_workload_and_occupied_wait_are_distinct():
+    assert module().estimate(dict(payload(), executions=0, busy_interval_arrival_rate=0))["planned_slots"] == 0
+    estimate = module().estimate(dict(payload(), mean_active_compute_seconds=0))
+    assert estimate["compute_work_seconds"] == 0
+    assert estimate["planned_slots"] == 125
+
+
+def test_overflow_is_a_validation_error():
+    with pytest.raises(ValueError):
+        module().estimate(dict(payload(), executions=10 ** 308, mean_occupied_seconds=10 ** 308))
+
+
+# Explicit short ids: without them pytest derives the id from the param value, so
+# the 65537-space case puts a 64 KB string into the PYTEST_CURRENT_TEST env var and
+# Windows rejects it (env vars cap at 32767 chars). The content still reaches the CLI
+# via a file, so the test behavior is unchanged.
+@pytest.mark.parametrize("content,code", [("not json", 1), ("[]", 1), (" " * 65537, 1), (None, 0)],
+                         ids=["not-json", "empty-array", "overlong-input", "valid"])
+def test_real_cli_has_one_json_result_and_no_traceback(tmp_path, content, code):
+    source = tmp_path / "input.json"
+    source.write_text(json.dumps(payload()) if content is None else content)
+    result = subprocess.run([sys.executable, str(SCRIPT), "--input", str(source)],
+                            capture_output=True, text=True)
+    assert result.returncode == code
+    response = json.loads(result.stdout)
+    assert ("error" in response) == bool(code)
+    assert not result.stderr

procesio_cli/skills/tests/test_field_boundary_learning.py

@@ -0,0 +1,100 @@
+"""Structural retention checks + frozen development cases, NOT behavioral uplift proof."""
+import hashlib
+import json
+from pathlib import Path
+import re
+
+ROOT = Path(__file__).resolve().parents[2]
+REFS = ROOT / 'skills/procesio-cli/references'
+CORPUS = ROOT / 'skills/evals/field-boundary-development-v1.json'
+
+
+def text(name):
+    return ' '.join((REFS / name).read_text(encoding='utf-8').split())
+
+
+def test_development_cases_remain_frozen_and_separate():
+    assert hashlib.sha256(CORPUS.read_bytes()).hexdigest() == (
+        'bb0e22e34bdf262a72973958eed528aa470dc37c758c6197126fbbdd5ad72596'
+    )
+    suite = json.loads(CORPUS.read_text(encoding="utf-8"))
+    assert suite['evidence_role'] == 'development_only_not_holdout'
+    assert suite['rubric_contract'] == 'fixed-jury-rubric-v2'
+    cases = suite['cases']
+    ids = {c['id'] for c in cases}
+    assert len(cases) == len(ids) == 10
+    historical = json.loads((ROOT / 'skills/evals/behavioral.json').read_text(encoding="utf-8"))
+    assert not ids & {c['id'] for c in historical['cases']}
+    assert {'positive', 'pressure', 'negative', 'missing-context'} <= {c['kind'] for c in cases}
+    assert not re.search(r'[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}', CORPUS.read_text(encoding="utf-8"))
+    for case in cases:
+        assert (ROOT / 'skills' / case['expected_skill'] / 'SKILL.md').is_file()
+        rubric = case['expected_output']
+        assert rubric['rubric_version'] == 1
+        criteria = rubric['criteria']
+        assert 2 <= len(criteria) <= 8
+        assert len({c['id'] for c in criteria}) == len(criteria)
+        for c in criteria:
+            assert re.fullmatch(r'[a-z][a-z0-9]*(?:_[a-z0-9]+)+', c['id'])
+            assert c['required'] is True
+            assert c['description'].startswith('Pass only when')
+
+
+def test_credentials_preserve_existing_access_and_typed_identity():
+    body = text('credentials-admin.md')
+    for term in ['two authentication planes', 'workspace GUID', 'connection GUID',
+                 '`gid`', 'not evidence of absence', 'does not prove read-only',
+                 'generated', 'not invent', 'owner', 'emails or user IDs']:
+        assert term in body
+
+
+def test_native_proof_is_independent_and_transition_sensitive():
+    body = text('data-verification.md')
+    for term in ['original request', 'same intermediate', 'explicit null',
+                 'concrete → null', 'null → concrete', 'false', 'zero',
+                 'already null', 'typed object', 'not a universal', 'protected']:
+        assert term in body
+
+
+def test_debugging_does_not_repeat_shared_state_corruption():
+    body = text('process-debugging.md')
+    assert 'original item → intermediate variable → native mapping → persisted row' in body
+    assert 'last loop iteration' in body
+    assert 'same intermediate' in body
+
+
+def test_graph_and_confidentiality_precede_execution():
+    body = text('process-lifecycle.md')
+    assert 'before freezing' in body
+    assert 'input-port' in body
+    assert 'Join' in body
+    assert 'first persistence boundary' in body
+    assert 'synthetic canary' in body
+    assert 'inactive creation' in body
+    assert 'downstream hashing' in body
+
+
+def test_resume_and_inventory_rules_are_not_delete_and_retry():
+    body = text('operation-contract.md')
+    for term in ['returned page', 'unique stable IDs', 'not not-found',
+                 'Approval recording', 'checkpoint eligibility', 'actual execution',
+                 'one bounded next step', 'selected-phase', 'aggregate']:
+        assert term in body
+
+
+def test_meta_gate_compares_independent_evidence_and_separate_layers():
+    body = ' '.join((ROOT / 'skills/agent-skill-engineer/references/field-gate-standard.md').read_text(encoding="utf-8").split())
+    for term in ['same erroneous intermediate', 'first persistence boundary',
+                 'offline assertions', 'causal skill improvement',
+                 'typed-null', 'checkpoint eligibility']:
+        assert term in body
+
+
+def test_confidentiality_gate_is_reachable_for_exports_before_execute():
+    common = text('operation-contract.md')
+    assert 'Before a read, export or diagnostic fetch' in common
+    assert 'references/process-lifecycle.md' in common
+    transport = text('transport-environments.md')
+    assert transport.index('pre-acquisition confidentiality gate') < transport.index('## Execute')
+    assert 'inline secrets' in transport
+    assert 'references/process-lifecycle.md' in transport

procesio_cli/skills/tests/test_field_closeout_learning.py

@@ -0,0 +1,123 @@
+"""Development-corpus and instruction retention checks, not behavior/runtime proof."""
+import hashlib
+import json
+from pathlib import Path
+import re
+
+ROOT = Path(__file__).resolve().parents[2]
+SKILLS = ROOT / 'skills'
+CORPUS = SKILLS / 'evals/field-closeout-development-v1.json'
+
+
+def test_review_addendum_is_separate_and_fixed():
+    path = SKILLS / 'evals/field-closeout-correction-development-v1.json'
+    assert hashlib.sha256(path.read_bytes()).hexdigest() == (
+        'b155396ca27300bd535e8da33bf32eb4ab4a4d73d6c30a30682c8b7130ff4dc8'
+    )
+    suite = json.loads(path.read_text(encoding='utf-8'))
+    assert suite['evidence_role'] == 'development_only_not_holdout'
+    assert suite['rubric_contract'] == 'fixed-jury-rubric-v2'
+    assert len(suite['cases']) == 1
+    case = suite['cases'][0]
+    for name in ('behavioral.json', 'field-boundary-development-v1.json',
+                 'field-closeout-development-v1.json'):
+        other = json.loads((SKILLS / 'evals' / name).read_text(encoding='utf-8'))
+        assert case['id'] not in {item['id'] for item in other['cases']}
+    assert case['expected_skill'] == 'procesio-cli'
+    rubric = case['expected_output']
+    assert rubric['rubric_version'] == 1
+    assert len(rubric['criteria']) == 4
+    assert len({c['id'] for c in rubric['criteria']}) == 4
+    for criterion in rubric['criteria']:
+        assert criterion['required'] is True
+        assert criterion['description'].startswith('Pass only when')
+
+
+def body(relative):
+    return ' '.join((SKILLS / relative).read_text(encoding='utf-8').split())
+
+
+def test_closeout_development_contract_is_frozen_and_separate():
+    assert hashlib.sha256(CORPUS.read_bytes()).hexdigest() == (
+        '566e18324c29eade65bf4a81044da1ae23306721d98a501ea29d585b7c49ac92'
+    )
+    suite = json.loads(CORPUS.read_text(encoding='utf-8'))
+    assert suite['evidence_role'] == 'development_only_not_holdout'
+    assert suite['rubric_contract'] == 'fixed-jury-rubric-v2'
+    cases = suite['cases']
+    ids = {case['id'] for case in cases}
+    assert len(ids) == len(cases) == 7
+    assert {'positive', 'pressure', 'negative', 'missing-context'} <= {
+        case['kind'] for case in cases
+    }
+    for name in ('behavioral.json', 'field-boundary-development-v1.json'):
+        other = json.loads((SKILLS / 'evals' / name).read_text(encoding='utf-8'))
+        assert not ids & {case['id'] for case in other['cases']}
+    assert not re.search(
+        r'[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}|Sentinel|scratchpad/',
+        CORPUS.read_text(encoding='utf-8'),
+    )
+    for case in cases:
+        assert (SKILLS / case['expected_skill'] / 'SKILL.md').is_file()
+        rubric = case['expected_output']
+        assert rubric['rubric_version'] == 1
+        criteria = rubric['criteria']
+        assert 2 <= len(criteria) <= 8
+        assert len({criterion['id'] for criterion in criteria}) == len(criteria)
+        for criterion in criteria:
+            assert re.fullmatch(r'[a-z][a-z0-9]*(?:_[a-z0-9]+)+', criterion['id'])
+            assert criterion['required'] is True
+            assert criterion['description'].startswith('Pass only when')
+
+
+def test_safety_obligation_is_not_success_dependent():
+    field = body('agent-skill-engineer/references/field-gate-standard.md')
+    for term in ('safety containment', 'evidence-destroying cleanup',
+                 'independently of business-output decoding', 'existing approval',
+                 'does not pass the business gate'):
+        assert term in field
+    for path in ('agent-skill-engineer/SKILL.md',
+                 'agent-skill-engineer/references/evaluation-standard.md'):
+        text = body(path)
+        assert 'clean up only after' not in text
+        assert 'approved safety containment' in text
+    lifecycle = body('procesio-cli/references/process-lifecycle.md')
+    assert 'does not depend on successful output decoding' in lifecycle
+    assert 'separate approval' in lifecycle
+    assert 'evidence-destroying cleanup' in lifecycle
+    for name in ('form-e2e.md', 'schedules-webhooks.md'):
+        adjacent = body('procesio-cli/references/' + name)
+        assert 'separate approval' in adjacent
+        assert 'must not wait for successful output decoding' in adjacent
+        assert 'references/process-lifecycle.md' in adjacent
+
+
+def test_comparison_rule_preserves_semantics_and_original_evidence():
+    text = body('procesio-cli/references/operation-contract.md')
+    for term in ('identity, authored semantics and representation',
+                 'versioned source contract', 'untouched original',
+                 'exact field paths', 'error bindings', 'Boolean/integer',
+                 'new attributable result'):
+        assert term in text
+
+
+def test_observation_repair_does_not_require_reexecution():
+    text = body('agent-skill-engineer/references/field-gate-standard.md')
+    for term in ('existing attributable evidence', 'does not by itself establish',
+                 'valid observation of a missing required effect',
+                 'missing observation boundary', 'null is not zero'):
+        assert term in text
+
+
+def test_diagnostic_stop_delivers_without_promoting_acceptance():
+    text = body('procesio-cli/references/operation-contract.md')
+    for term in ('smallest observation', 'stop condition', 'responsible owner',
+                 'clearly scoped artifact', 'not retroactive acceptance'):
+        assert term in text
+
+
+def test_generalization_requires_transfer_and_boundary_control():
+    text = body('agent-skill-engineer/references/field-gate-standard.md')
+    for term in ('different domain', 'counterexample', 'must not apply',
+                 'development cases', 'not transfer-performance evidence'):
+        assert term in text

procesio_cli/skills/tests/test_field_gate_standard.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from pathlib import Path
+import re
+
+import yaml
+
+ROOT = Path(__file__).resolve().parents[2]
+META = ROOT / "skills" / "agent-skill-engineer"
+SKILL = META / "SKILL.md"
+STANDARD = META / "references" / "field-gate-standard.md"
+
+
+def _frontmatter(path: Path) -> dict:
+    lines = path.read_text(encoding="utf-8").splitlines()
+    end = lines[1:].index("---") + 1
+    value = yaml.safe_load("\n".join(lines[1:end]))
+    assert isinstance(value, dict)
+    return value
+
+
+def test_meta_skill_routes_field_trials_to_fixed_gate_standard():
+    skill = SKILL.read_text(encoding="utf-8")
+    frontmatter = _frontmatter(SKILL)
+
+    # The field contract landed in 2.0.1; later repairs must retain it, not
+    # keep an obsolete exact version merely to satisfy this regression test.
+    version = tuple(int(part) for part in frontmatter["version"].split("."))
+    assert len(version) == 3 and version >= (2, 0, 1)
+    assert frontmatter["baseline_version"] == "a47135373c4c0598391e808939397cd139234afd"
+    assert "`references/field-gate-standard.md`" in skill
+    assert "Host code—not the acting agent—decides pass" in skill
+    assert "full parent/child execution budget" in skill
+    assert "Never weaken a completed gate" in skill
+
+
+def test_field_gate_standard_is_general_and_host_enforced():
+    text = STANDARD.read_text(encoding="utf-8")
+    normalized = " ".join(text.split())
+
+    for phrase in (
+        "ordered required check IDs",
+        "fingerprint of the complete skill package",
+        "including `SKILL.md`, references, scripts, and assets",
+        "The host computes the aggregate verdict",
+        "complete causal execution tree",
+        "A required outcome that fails is not converted into a gap",
+        "A phase verdict covers only that phase's frozen obligations",
+        "does not force every later phase to report `passed_with_gap`",
+        "compute and preserve both verdict scopes separately",
+        "Credential exposure is monotonic for the exposed credential",
+        "does not make a completed `no_secret_exposure` check true",
+        "prove the old value is rejected",
+        "invalidate stale exports or reports",
+        "preserve the original report",
+        "separately approved versioned remediation contract",
+        "Avoid case-specific overfitting",
+        "Project-specific ID, title, payload, or workaround",
+    ):
+        assert phrase in normalized
+
+    # General doctrine must not embed installation IDs or private evidence paths.
+    assert not re.search(r"[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}", text)
+    assert "scratchpad/" not in text
+
+
+def test_review_and_evaluation_standards_fail_closed_on_field_gate_drift():
+    review = (META / "references" / "review-standard.md").read_text(encoding="utf-8")
+    evaluation = (META / "references" / "evaluation-standard.md").read_text(encoding="utf-8")
+
+    assert "acting agent invent required checks" in review
+    assert "complete causal execution counts" in review
+    assert "failed required field outcome" in review
+    assert "deterministic host code should validate exact IDs and order" in evaluation
+    assert "does not retroactively permit a gap" in evaluation
+    assert "full parent/child execution budget" in evaluation