proofhouse 0.4.2__py3-none-any.whl

proofhouse/__init__.py

@@ -0,0 +1,9 @@
+"""Proofhouse prompt-operations framework."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    # One source of truth: the installed distribution's version (pyproject.toml).
+    __version__ = version("proofhouse")
+except PackageNotFoundError:  # running from a source tree that was never installed
+    __version__ = "0+unknown"

proofhouse/cli.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from .loadouts import compile_loadout, load_legendary_loadouts
+from .runner import build_markdown_report, validate_dataset
+from .scan import ScanError, emit as emit_scan, render as render_scan, scan as scan_project
+from .templates import PromptArchitectInputs, export_prompt_architect
+
+
+def cmd_validate(args: argparse.Namespace) -> int:
+    issues = validate_dataset(args.dataset)
+    if issues:
+        print(f"Dataset validation failed: {args.dataset}")
+        for issue in issues:
+            print(f"line {issue.line}: {issue.message}")
+        return 1
+    print(f"Dataset validation passed: {args.dataset}")
+    return 0
+
+
+def cmd_report(args: argparse.Namespace) -> int:
+    report = build_markdown_report(args.dataset)
+    out = Path(args.out)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(report, encoding="utf-8")
+    print(f"Report written: {out}")
+    return 0
+
+
+def cmd_loadouts(args: argparse.Namespace) -> int:
+    for loadout in load_legendary_loadouts():
+        print(f"{loadout.id}\t{loadout.name}\t{loadout.role}")
+    return 0
+
+
+def cmd_compile_loadout(args: argparse.Namespace) -> int:
+    compiled = compile_loadout(args.id)
+    if args.out:
+        out = Path(args.out)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(compiled, encoding="utf-8")
+        print(f"Loadout compiled: {out}")
+    else:
+        print(compiled, end="")
+    return 0
+
+
+def cmd_scan(args: argparse.Namespace) -> int:
+    try:
+        result = scan_project(args.path)
+    except ScanError as exc:
+        print(f"scan: {exc}", file=sys.stderr)
+        return 2
+    emit_scan(json.dumps(result, indent=2) if args.json else render_scan(result))
+    return 0
+
+
+def cmd_generate(args: argparse.Namespace) -> int:
+    if args.template != "prompt-architect":
+        raise ValueError(f"Unsupported template: {args.template}")
+
+    exported = export_prompt_architect(
+        PromptArchitectInputs(
+            project_name=args.project_name,
+            project_description=args.project_description,
+            platforms=args.platform or [],
+            stack=args.stack or "",
+            scale=args.scale or "",
+            open_decisions=args.open_decision or [],
+        ),
+        args.out_dir,
+        version=args.version,
+    )
+    print(f"Prompt architect templates rendered with version {exported.version}:")
+    print(f"System: {exported.system_path}")
+    print(f"Compact: {exported.compact_path}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="proofhouse", description="Proofhouse eval harness")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    validate = subparsers.add_parser("validate", help="Validate a JSONL eval dataset")
+    validate.add_argument("--dataset", required=True, help="Path to JSONL dataset")
+    validate.set_defaults(func=cmd_validate)
+
+    report = subparsers.add_parser("report", help="Create a markdown report skeleton")
+    report.add_argument("--dataset", required=True, help="Path to JSONL dataset")
+    report.add_argument("--out", required=True, help="Output markdown path")
+    report.set_defaults(func=cmd_report)
+
+    loadouts = subparsers.add_parser("loadouts", help="List legendary Proofhouse loadouts")
+    loadouts.set_defaults(func=cmd_loadouts)
+
+    compile_parser = subparsers.add_parser("compile-loadout", help="Compile a legendary loadout")
+    compile_parser.add_argument("--id", required=True, help="Loadout id to compile")
+    compile_parser.add_argument("--out", help="Optional output markdown path")
+    compile_parser.set_defaults(func=cmd_compile_loadout)
+
+    scan_cmd = subparsers.add_parser("scan", help="Read-only scan of a project folder, so fewer questions are needed")
+    scan_cmd.add_argument("path", nargs="?", default=".", help="Project folder (default: current folder)")
+    scan_cmd.add_argument("--json", action="store_true", help="Machine-readable output")
+    scan_cmd.set_defaults(func=cmd_scan)
+
+    generate = subparsers.add_parser("generate", help="Render versioned prompt templates")
+    generate.add_argument("--template", default="prompt-architect", choices=["prompt-architect"])
+    generate.add_argument("--version", default=None, help="Template version, defaults to manifest default")
+    generate.add_argument("--project-name", required=True, help="Project name to inject")
+    generate.add_argument("--project-description", required=True, help="Project description to inject")
+    generate.add_argument(
+        "--platform",
+        action="append",
+        help="Target platform; repeat for multiple platforms",
+    )
+    generate.add_argument("--stack", help="Preferred or existing stack")
+    generate.add_argument("--scale", choices=["S", "M", "L", "XL"], help="Project scale")
+    generate.add_argument(
+        "--open-decision",
+        action="append",
+        help="Open decision to carry into the prompt; repeat for multiple decisions",
+    )
+    generate.add_argument("--out-dir", required=True, help="Directory for rendered prompt files")
+    generate.set_defaults(func=cmd_generate)
+
+    return parser
+
+
+def main() -> int:
+    parser = build_parser()
+    args = parser.parse_args()
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

proofhouse/compiler/__init__.py

@@ -0,0 +1,12 @@
+"""Proofhouse Compiler Core v0.1 — deterministic, offline IR compiler.
+
+Public library surface lives in `proofhouse.compiler.api`. Default
+compile/validate/closed-loop paths contain no live provider calls, network
+access, or credential handling. Opt-in live OpenAI execution lives in
+`execution.py` (fail-closed, DEFERRED-to-opt-in, not CERTIFIED).
+"""
+from __future__ import annotations
+
+COMPILER_ID = "proofhouse-compiler-core"
+COMPILER_VERSION = "0.1.0"
+IR_CONTRACT_VERSION = "0.1.0"

proofhouse/compiler/adapters/__init__.py

@@ -0,0 +1,56 @@
+"""Adapter registry.
+
+v0.1 registers the deterministic fake adapter, the OpenAI adapter (second
+conformance target, MISSION-003), the Anthropic adapter (third conformance
+target, MISSION-004) and, as of MISSION-005, the Gemini adapter (fourth and
+final conformance target per OAR-001-02's ratified order). All four adapter
+ids are now registered; no live-provider id remains reserved-but-unimplemented.
+"""
+from __future__ import annotations
+
+from ..diagnostics import DiagnosticFactory
+from .anthropic import ADAPTER_ID as ANTHROPIC_ADAPTER_ID
+from .anthropic import AnthropicAdapter
+from .base import Adapter, AdapterNotFoundError
+from .fake import ADAPTER_ID as FAKE_ADAPTER_ID
+from .fake import FakeAdapter
+from .gemini import ADAPTER_ID as GEMINI_ADAPTER_ID
+from .gemini import GeminiAdapter
+from .openai import ADAPTER_ID as OPENAI_ADAPTER_ID
+from .openai import OpenAIAdapter
+
+RESERVED_LIVE_ADAPTER_IDS = frozenset()
+KNOWN_ADAPTER_IDS = frozenset({FAKE_ADAPTER_ID, OPENAI_ADAPTER_ID, ANTHROPIC_ADAPTER_ID, GEMINI_ADAPTER_ID})
+
+
+def list_registered_adapter_ids() -> tuple[str, ...]:
+    """Adapters actually implemented in v0.1 (fake, openai, anthropic, gemini)."""
+    return (FAKE_ADAPTER_ID, OPENAI_ADAPTER_ID, ANTHROPIC_ADAPTER_ID, GEMINI_ADAPTER_ID)
+
+
+def get_adapter(adapter_id: str, diagnostics: DiagnosticFactory, source_document: str = "<input>") -> Adapter:
+    if adapter_id == FAKE_ADAPTER_ID:
+        return FakeAdapter(diagnostics, source_document)
+    if adapter_id == OPENAI_ADAPTER_ID:
+        return OpenAIAdapter(diagnostics, source_document)
+    if adapter_id == ANTHROPIC_ADAPTER_ID:
+        return AnthropicAdapter(diagnostics, source_document)
+    if adapter_id == GEMINI_ADAPTER_ID:
+        return GeminiAdapter(diagnostics, source_document)
+    if adapter_id in RESERVED_LIVE_ADAPTER_IDS:
+        raise AdapterNotFoundError(
+            f"adapter {adapter_id!r} is a reserved live-provider id not implemented in "
+            f"Compiler Core v0.1 (out of scope: live execution); it is never silently "
+            f"substituted with another adapter"
+        )
+    raise AdapterNotFoundError(f"unknown adapter id {adapter_id!r}")
+
+
+__all__ = [
+    "Adapter",
+    "AdapterNotFoundError",
+    "KNOWN_ADAPTER_IDS",
+    "RESERVED_LIVE_ADAPTER_IDS",
+    "get_adapter",
+    "list_registered_adapter_ids",
+]

proofhouse/compiler/adapters/anthropic.py

@@ -0,0 +1,305 @@
+"""Anthropic adapter -- the third conformance target (OAR-001-02).
+
+Produces a deterministic, offline-computable Anthropic-shaped request payload
+from validated IR. Per PROVIDER_ADAPTER_CONTRACT.md, `lower()` never calls
+the Anthropic API, never handles credentials, and never touches the network
+-- live execution is a separate, future interface and permission boundary.
+
+Structurally this class parallels `openai.py` (constructed the same way,
+same fail-fast-on-required-gap `lower()` shape, same
+`canonicalize`/`canonical_sha256` artifact primitives, same deliberately
+duplicated `check_capabilities()` loop -- see MISSION_003_REPORT.md's stated
+reasoning for not sharing that loop across adapters). It diverges from
+`openai.py` in three places Anthropic's actual model requires it to, per
+MISSION-004 scope items 3-4:
+
+1. Client-executed vs. server-executed tools are contractually distinct for
+   Anthropic (unlike OpenAI's single `tools.function_calling@1` surface), so
+   this adapter tracks a separate `tools.server_executed@1` capability and
+   never collapses both kinds into one generic `tools` artifact field --
+   `lower()` always emits distinct `client_tools` and `server_tools` keys.
+2. Anthropic's extended-thinking model requires signature-verified
+   thinking-block preservation across tool-use turns -- structurally
+   different from OpenAI's scalar `reasoning.effort_control@1` -- so this
+   adapter uses its own `reasoning.extended_thinking@1` capability id and
+   always emits an explicit `thinking` object in the artifact (never
+   omitted), even when the frozen IR has no field to source a concrete
+   `budget_tokens` value from.
+3. The strict schema subset is Anthropic-sourced (`anthropic_schema_subset`),
+   not reused from `openai_schema_subset`, matching the intentional
+   per-adapter duplication precedent from MISSION-003.
+
+Capability manifest and the strict-schema-subset limits it references are
+grounded in current Anthropic documentation (Structured Outputs, Strict Tool
+Use, Tool Use overview/server-tools, and Extended Thinking guides, confirmed
+2026-07-22 via web search cross-checked across multiple independent
+sources -- see MISSION_004_REPORT.md for the full corroboration record).
+"""
+from __future__ import annotations
+
+from ..canonical import canonical_sha256, canonicalize
+from ..capability import CapabilityManifest
+from ..contracts import Artifact, CapabilityDecision, Diagnostic
+from ..diagnostics import DiagnosticFactory
+from .anthropic_schema_subset import check_strict_subset
+from .base import AdapterDescriptor, LoweringResult
+
+ADAPTER_ID = "anthropic"
+ADAPTER_VERSION = "0.1.0"
+PROVIDER_ID = "anthropic"
+CONFORMANCE_SUITE_VERSION = "0.1.0"
+
+STRUCTURED_JSON_CAPABILITY = "output.structured_json@1"
+CLIENT_TOOL_CAPABILITY = "tools.function_calling@1"
+SERVER_TOOL_CAPABILITY = "tools.server_executed@1"
+THINKING_CAPABILITY = "reasoning.extended_thinking@1"
+
+# tools.server_executed@1 is deliberately NOT in supported/conditional: see
+# CAPABILITY_LIMITS[SERVER_TOOL_CAPABILITY] for why this is a genuine IR
+# representational gap, not a misreading of Anthropic's actual capability.
+SUPPORTED_CAPABILITIES = frozenset({STRUCTURED_JSON_CAPABILITY, CLIENT_TOOL_CAPABILITY})
+CONDITIONAL_CAPABILITIES = frozenset({THINKING_CAPABILITY})
+
+_STRICT_SCHEMA_LIMITS = {
+    "additional_properties_must_be_false": True,
+    "all_properties_must_be_required": True,
+    "supported_types": ["string", "number", "integer", "boolean", "array", "object", "null"],
+    "documented_but_unenforced_keywords": [
+        "minLength",
+        "maxLength",
+        "pattern",
+        "minItems",
+        "maxItems",
+        "minimum",
+        "maximum",
+        "multipleOf",
+    ],
+    "recursive_schemas_supported": False,
+}
+
+CAPABILITY_LIMITS = {
+    STRUCTURED_JSON_CAPABILITY: {
+        **_STRICT_SCHEMA_LIMITS,
+        "source": "https://platform.claude.com/docs/en/build-with-claude/structured-outputs",
+    },
+    CLIENT_TOOL_CAPABILITY: {
+        **_STRICT_SCHEMA_LIMITS,
+        "applies_when": "strict: true tool definitions (client-executed, caller-defined tools only)",
+        "source": "https://platform.claude.com/docs/en/agents-and-tools/tool-use/strict-tool-use",
+    },
+    SERVER_TOOL_CAPABILITY: {
+        "note": (
+            "Anthropic's API genuinely supports server-executed tools (e.g. web_search, "
+            "web_fetch, code_execution, tool_search) that run on Anthropic's own infrastructure "
+            "with no caller-side handler. Proofhouse's frozen IR v0.1 `tools` array schema "
+            "(proofhouse_ir_v0_1.schema.json) only supports the caller-defined custom-tool shape "
+            "(id/description/input_schema/side_effecting/approval) -- there is no IR field to "
+            "select a specific Anthropic server tool or supply its configuration. This adapter "
+            "reports tools.server_executed@1 as unsupported to reflect that IR-representational "
+            "gap explicitly, rather than silently downgrading a server-tool request to a client "
+            "tool or fabricating a payload for a tool the IR cannot actually describe."
+        ),
+        "source": "https://platform.claude.com/docs/en/agents-and-tools/tool-use/server-tools",
+    },
+    THINKING_CAPABILITY: {
+        "note": "extended thinking is model-specific; not available on all Claude models",
+        "budget_tokens_minimum": 1024,
+        "preservation_required_when_used_with_tools": True,
+        "signature_field_required": True,
+        "redacted_thinking_blocks_must_be_preserved": True,
+        "incompatible_with": ["temperature_override", "top_k_override", "forced_tool_choice"],
+        "source": "https://platform.claude.com/docs/en/build-with-claude/extended-thinking",
+    },
+}
+
+
+class AnthropicAdapter:
+    adapter_id = ADAPTER_ID
+    adapter_version = ADAPTER_VERSION
+
+    def __init__(self, diagnostics: DiagnosticFactory, source_document: str = "<input>"):
+        self._diagnostics = diagnostics
+        self._source_document = source_document
+
+    def capability_manifest(self) -> CapabilityManifest:
+        return CapabilityManifest(
+            adapter_id=ADAPTER_ID,
+            adapter_version=ADAPTER_VERSION,
+            manifest_version="0.1.0",
+            supported=SUPPORTED_CAPABILITIES,
+            conditional=CONDITIONAL_CAPABILITIES,
+            limits=CAPABILITY_LIMITS,
+        )
+
+    def describe(self) -> AdapterDescriptor:
+        manifest = self.capability_manifest()
+        digest = manifest.digest
+        return AdapterDescriptor(
+            adapter_id=ADAPTER_ID,
+            adapter_version=ADAPTER_VERSION,
+            provider_id=PROVIDER_ID,
+            supported_ir_range="0.1.0",
+            capability_manifest_version=manifest.manifest_version,
+            capability_manifest_digest=digest,
+            artifact_kinds=("anthropic_request_payload",),
+            conformance_suite_version=CONFORMANCE_SUITE_VERSION,
+        )
+
+    def check_capabilities(self, validated_ir: dict) -> tuple[CapabilityDecision, ...]:
+        provider_requirements = validated_ir.get("provider_requirements") or {
+            "required_capabilities": [],
+            "optional_capabilities": [],
+        }
+        manifest = self.capability_manifest()
+        decisions: list[CapabilityDecision] = []
+        for capability in provider_requirements.get("required_capabilities", []):
+            decisions.append(
+                CapabilityDecision(capability=capability, requirement="required", resolution=manifest.resolve(capability))
+            )
+        for capability in provider_requirements.get("optional_capabilities", []):
+            decisions.append(
+                CapabilityDecision(capability=capability, requirement="optional", resolution=manifest.resolve(capability))
+            )
+        return tuple(decisions)
+
+    def lower(self, validated_ir: dict, resolution: tuple[CapabilityDecision, ...]) -> LoweringResult:
+        required_gaps = [d for d in resolution if d.requirement == "required" and d.resolution == "unsupported"]
+        if required_gaps:
+            diags = tuple(
+                self._diagnostics.emit(
+                    code="PRG-CAPABILITY-0001",
+                    phase="capability_resolution",
+                    message=f"Required capability {gap.capability!r} unsupported by anthropic adapter.",
+                    document=self._source_document,
+                    json_pointer="/provider_requirements/required_capabilities",
+                )
+                for gap in required_gaps
+            )
+            return LoweringResult(artifacts=(), diagnostics=diags, status="failure")
+
+        requested = {d.capability for d in resolution}
+        wants_structured_json = STRUCTURED_JSON_CAPABILITY in requested
+        wants_client_tools = CLIENT_TOOL_CAPABILITY in requested
+        wants_thinking = THINKING_CAPABILITY in requested
+
+        subset_diagnostics: list[Diagnostic] = []
+
+        # Anthropic v0.1 has one response schema per request.  Composite
+        # lowering is an explicit future contract, never an index-zero choice.
+        output_format = None
+        if wants_structured_json:
+            output_contracts = validated_ir.get("output_contracts") or []
+            if len(output_contracts) > 1:
+                diagnostic = self._diagnostics.emit(
+                    code="PRG-ADAPTER-0001",
+                    phase="adapter_lowering",
+                    message="Anthropic v0.1 lowering rejects multiple output contracts; composite lowering is not authorized.",
+                    document=self._source_document,
+                    json_pointer="/output_contracts",
+                )
+                return LoweringResult(artifacts=(), diagnostics=(diagnostic,), status="failure")
+            if output_contracts:
+                contract = output_contracts[0]
+                schema = contract["schema"]
+                violations = check_strict_subset(schema, base_pointer="/output_contracts/0/schema")
+                for v in violations:
+                    subset_diagnostics.append(
+                        self._diagnostics.emit(
+                            code="PRG-ADAPTER-0001",
+                            phase="adapter_lowering",
+                            message=f"Output schema is not expressible in Anthropic's strict "
+                            f"structured-output subset: {v.reason}",
+                            document=self._source_document,
+                            json_pointer=v.json_pointer,
+                        )
+                    )
+                if not violations:
+                    output_format = {"type": "json_schema", "schema": schema}
+
+        client_tools_payload: list[dict] = []
+        if wants_client_tools:
+            for idx, tool in enumerate(validated_ir.get("tools") or []):
+                schema = tool["input_schema"]
+                violations = check_strict_subset(schema, base_pointer=f"/tools/{idx}/input_schema")
+                for v in violations:
+                    subset_diagnostics.append(
+                        self._diagnostics.emit(
+                            code="PRG-ADAPTER-0001",
+                            phase="adapter_lowering",
+                            message=f"Client tool {tool.get('id')!r} input_schema is not expressible in "
+                            f"Anthropic's strict tool-use subset: {v.reason}",
+                            document=self._source_document,
+                            json_pointer=v.json_pointer,
+                        )
+                    )
+                if not violations:
+                    client_tools_payload.append(
+                        {
+                            "name": tool["id"],
+                            "description": tool["description"],
+                            "input_schema": schema,
+                            "strict": True,
+                        }
+                    )
+
+        if subset_diagnostics:
+            return LoweringResult(artifacts=(), diagnostics=tuple(subset_diagnostics), status="failure")
+
+        # Client-vs-server tool distinction (scope item 4): two distinct keys,
+        # never one flattened generic "tools" field. server_tools is always []
+        # here -- the frozen IR v0.1 has no way to express an Anthropic
+        # server-executed tool (see CAPABILITY_LIMITS[SERVER_TOOL_CAPABILITY]) --
+        # but the key is always explicitly present, and any requested-but-
+        # unsupported server-tool capability is recorded in capability_decisions,
+        # never silently dropped.
+        server_tools_payload: list[dict] = []
+
+        # Thinking-block/reasoning-preservation state (scope item 4): always an
+        # explicit object, never omitted, even when not requested or when the IR
+        # has no field to source a concrete budget_tokens value from.
+        if wants_thinking:
+            thinking_state = {
+                "requested": True,
+                "capability_resolution": "conditional",
+                "budget_tokens": None,
+                "budget_tokens_note": (
+                    "Proofhouse IR v0.1 has no field to source a concrete budget_tokens "
+                    "value from; recorded as an open IR-schema question, not silently dropped."
+                ),
+                "preservation": {
+                    "signature_required": True,
+                    "must_return_thinking_blocks_unmodified_when_used_with_tools": True,
+                    "redacted_thinking_blocks_must_be_preserved": True,
+                },
+            }
+        else:
+            thinking_state = {"requested": False}
+
+        payload = {
+            "adapter_id": ADAPTER_ID,
+            "adapter_version": ADAPTER_VERSION,
+            "ir_sha256": canonical_sha256(validated_ir),
+            "model_selection": "runtime-configured; not frozen by the compiler artifact",
+            "instructions": _build_instructions(validated_ir),
+            "client_tools": client_tools_payload,
+            "server_tools": server_tools_payload,
+            "output_config": {"format": output_format} if output_format is not None else None,
+            "thinking": thinking_state,
+            "capability_decisions": [d.to_dict() for d in resolution],
+        }
+        body = canonicalize(payload)
+        digest = canonical_sha256(payload)
+        artifact = Artifact(
+            name="anthropic_request_payload",
+            media_type="application/vnd.proofhouse.anthropic.request-payload+json",
+            sha256=digest,
+            data=body,
+        )
+        return LoweringResult(artifacts=(artifact,), diagnostics=(), status="success")
+
+
+def _build_instructions(validated_ir: dict) -> str:
+    objective = validated_ir["objective"]
+    behavior = validated_ir["behavior"]
+    lines = [objective["goal"], *behavior["instructions"], *behavior["constraints"]]
+    return "\n".join(lines)

proofhouse/compiler/adapters/anthropic_schema_subset.py

@@ -0,0 +1,102 @@
+"""Anthropic's documented strict JSON Schema subset, shared by JSON Outputs
+(`output_config.format`) and strict tool use (`strict: true` tool definitions).
+
+Deliberately narrow, following the same discipline as
+`openai_schema_subset.py`: this module encodes only the constraints
+confirmed with confidence against current Anthropic documentation as of
+this mission (2026-07-22), via web search cross-checked across multiple
+independent sources (direct fetches of `platform.claude.com` guide pages
+were not reliably retrievable as body text through the available tools,
+the same limitation MISSION-003 hit for `platform.openai.com`). It is not
+a general JSON Schema subset checker.
+
+Confirmed hard constraints (enforced as violations by this module --
+sourced from Anthropic's Structured Outputs and Strict Tool Use guides,
+cross-checked against independent secondary summaries of the same guides):
+  - Every object-typed schema node MUST set additionalProperties: false.
+  - Every property declared in an object's `properties` MUST also appear
+    in that object's `required` array.
+  - Supported base types: string, number, integer, boolean, array, object,
+    null (standalone or in a type-union list).
+
+Confirmed but NOT enforced by this checker (informational only -- see
+ANTHROPIC_CAPABILITY note below and MISSION_004_REPORT.md Technical Debt):
+  - Anthropic's strict subset additionally documents support for `enum`,
+    `const`, `anyOf`/`allOf`, and `$ref`/`$defs`, which OpenAI's confirmed
+    subset (per MISSION-003) did not assert either way. This module does
+    not add checks for these keywords' presence/absence; it only flags the
+    two hard constraints above.
+  - Keywords such as `minLength`, `maxLength`, `pattern`, `minItems`,
+    `maxItems`, `minimum`, `maximum`, and `multipleOf` are confirmed, across
+    multiple independent sources, to be *accepted but silently unenforced*
+    by Anthropic's constrained decoding under strict mode -- this is a
+    materially different behavior than "rejected as a violation", so this
+    checker deliberately does NOT flag their presence as a subset violation
+    (doing so would misrepresent silently-ignored-but-permitted as
+    disallowed). Recorded as a known, source-confirmed gap: no diagnostic
+    currently warns a schema author that these keywords will be ignored.
+  - Recursive schemas (`$ref` cycles) are documented as unsupported, but
+    this walker -- like the OpenAI checker it parallels -- does not detect
+    reference cycles; it assumes a tree-shaped schema.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ..paths import join_json_pointer
+
+_SUPPORTED_TYPES = frozenset({"string", "number", "integer", "boolean", "array", "object", "null"})
+
+
+@dataclass(frozen=True, slots=True)
+class SubsetViolation:
+    json_pointer: str
+    reason: str
+
+
+def check_strict_subset(schema: dict, *, base_pointer: str = "") -> tuple[SubsetViolation, ...]:
+    """Returns every violation of the documented strict-mode subset found in
+    `schema`, walked recursively through object properties and array items.
+    An empty tuple means the schema is expressible in the strict subset."""
+    violations: list[SubsetViolation] = []
+    _walk(schema, base_pointer, violations)
+    return tuple(violations)
+
+
+def _walk(schema: dict, pointer: str, violations: list[SubsetViolation]) -> None:
+    if not isinstance(schema, dict):
+        violations.append(SubsetViolation(pointer, "schema node must be a JSON object"))
+        return
+
+    schema_type = schema.get("type")
+    type_names = schema_type if isinstance(schema_type, list) else [schema_type]
+    unsupported = [t for t in type_names if t not in _SUPPORTED_TYPES]
+    if unsupported:
+        violations.append(
+            SubsetViolation(pointer, f"unsupported type(s) {unsupported} outside {sorted(_SUPPORTED_TYPES)}")
+        )
+
+    if "object" in type_names:
+        if schema.get("additionalProperties") is not False:
+            violations.append(SubsetViolation(pointer, "object schemas must set additionalProperties: false"))
+
+        properties: dict = schema.get("properties", {})
+        required = set(schema.get("required", []))
+        missing_required = sorted(set(properties) - required)
+        if missing_required:
+            violations.append(
+                SubsetViolation(
+                    pointer,
+                    f"all properties must be listed in required (missing: {missing_required}); "
+                    f"express optional fields as a nullable type union instead",
+                )
+            )
+        for prop_name, prop_schema in properties.items():
+            _walk(prop_schema, join_json_pointer(join_json_pointer(pointer, "properties"), prop_name), violations)
+
+    if "array" in type_names:
+        items = schema.get("items")
+        if items is None:
+            violations.append(SubsetViolation(pointer, "array schemas must declare items"))
+        else:
+            _walk(items, join_json_pointer(pointer, "items"), violations)