clm-kernel 0.0.0__py3-none-any.whl

clm/layer1/test_runner.py

@@ -0,0 +1,498 @@
+import os
+import shutil
+import subprocess
+
+import yaml
+
+from clm.cross_cutting.clm_logger import get_logger
+from clm.layer0.utils import get_bash_command
+
+_logger = get_logger("clm.layer1.test_runner")
+
+
+def test_type_system(clm_root: str) -> int:
+    """
+    Executes compliance assertions against the CLM type registry and yaml schemas.
+
+    Args:
+        clm_root (str): The workspace root directory.
+
+    Returns:
+        int: 0 if all tests pass, 1 otherwise.
+    """
+    print("======================================================")
+    print("  Test Suite: CLM Type System (Python Native)")
+    print("======================================================\n")
+
+    passed = 0
+    failed = 0
+
+    def _assert(desc, cond):
+        nonlocal passed, failed
+        if cond:
+            print(f"  ✅ {desc}")
+            passed += 1
+            return True
+        else:
+            print(f"  ❌ {desc}")
+            failed += 1
+            return False
+
+    all_types = [
+        "types/meta/a_mcard.yaml",
+        "types/meta/b_mcard.yaml",
+        "types/meta/c_mcard.yaml",
+        "types/primitives/string.yaml",
+        "types/primitives/integer.yaml",
+        "types/primitives/float.yaml",
+        "types/primitives/boolean.yaml",
+        "types/primitives/blob.yaml",
+        "types/primitives/list.yaml",
+        "types/primitives/map.yaml",
+        "types/runtime/agent.yaml",
+        "types/runtime/clmEval.yaml",
+        "types/runtime/evaluate.yaml"
+    ]
+
+    print("-- 1. Grammar Standard Compliance --")
+    for t in all_types:
+        full_path = os.path.join(clm_root, t)
+        name = os.path.splitext(os.path.basename(t))[0]
+        try:
+            with open(full_path, encoding="utf-8") as f:
+                data = yaml.safe_load(f)
+            clm_block = data.get("clm")
+            _assert(f"{name}: has clm: root wrapper", clm_block is not None)
+            if clm_block:
+                _assert(f"{name}: uses balanced_exp (not balanced_expc)", "balanced_exp" in clm_block and "balanced_expc" not in clm_block)
+                abstract = clm_block.get("abstract_spec", {})
+                sc = abstract.get("success_criteria")
+                _assert(f"{name}: success_criteria is a list", isinstance(sc, list))
+        except Exception as e:
+            _assert(f"{name}: failed to read or parse - {e}", False)
+
+    print("\n-- 2. Schema Sections --")
+    for t in all_types:
+        full_path = os.path.join(clm_root, t)
+        name = os.path.splitext(os.path.basename(t))[0]
+        try:
+            with open(full_path, encoding="utf-8") as f:
+                data = yaml.safe_load(f)
+            clm_block = data.get("clm")
+            schema = clm_block.get("concrete_impl", {}).get("schema") if clm_block else None
+            _assert(f"{name}: has schema section", schema is not None)
+        except Exception as e:
+            _assert(f"{name}: failed schema check - {e}", False)
+
+    print("\n-- 3. Type Registry --")
+
+    def resolve_type_path(clm_root, tname):
+        for tier in ("meta", "primitives", "runtime", "content", "transport", "codegen"):
+            candidate = os.path.join(clm_root, "types", tier, f"{tname}.yaml")
+            if os.path.exists(candidate):
+                return candidate
+        return None
+
+    a_mcard_path = resolve_type_path(clm_root, "a_mcard")
+    _assert("resolve_type_path 'a_mcard' succeeds", a_mcard_path is not None)
+    integer_path = resolve_type_path(clm_root, "integer")
+    _assert("resolve_type_path 'integer' succeeds", integer_path is not None)
+    agent_path = resolve_type_path(clm_root, "agent")
+    _assert("resolve_type_path 'agent' succeeds", agent_path is not None)
+
+    types_count = 0
+    for _root, _, files in os.walk(os.path.join(clm_root, "types")):
+        for file in files:
+            if file.endswith(".yaml"):
+                types_count += 1
+    _assert(f"Registry loaded 13+ types (got {types_count})", types_count >= 13)
+
+    print("\n-- 4. Universe Levels --")
+    def get_universe_level(clm_root, tname):
+        path = resolve_type_path(clm_root, tname)
+        if not path:
+            return None
+        with open(path, encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+        return str(data.get("clm", {}).get("concrete_impl", {}).get("universe_level", "0"))
+
+    _assert("string is Level 0", get_universe_level(clm_root, "string") == "0")
+    _assert("integer is Level 0", get_universe_level(clm_root, "integer") == "0")
+    _assert("a_mcard is Level 1", get_universe_level(clm_root, "a_mcard") == "1")
+    _assert("b_mcard is Level 1", get_universe_level(clm_root, "b_mcard") == "1")
+    _assert("agent is Level 2", get_universe_level(clm_root, "agent") == "2")
+    _assert("clmEval is Level 2", get_universe_level(clm_root, "clmeval") == "2")
+
+    print("\n==================================================")
+    print(f"  Results: {passed} passed, {failed} failed")
+    return 0 if failed == 0 else 1
+
+
+def run_algebra_op(clm_root: str, op: str, *args: str) -> tuple[int, str, str]:
+    """
+    Runs a legacy shell modular algebra command and returns exit code and output.
+    """
+    import platform as _plat
+
+    from clm.layer0.utils import detect_host_os
+    host_os = detect_host_os()
+    arch = "amd64" if _plat.machine() in ("x86_64", "AMD64") else "arm64"
+    bash_cmd = f"""
+    export CLM_ROOT="{clm_root}"
+    export PATH="$CLM_ROOT/.venv/Scripts:$CLM_ROOT/.venv/bin:$CLM_ROOT/kernel/bin/{host_os}-{arch}:$CLM_ROOT/kernel/scripts:$PATH"
+    clm_root() {{ echo "$CLM_ROOT"; }}
+    export -f clm_root
+    source "$CLM_ROOT/computable_knowledge/Concrete/layer5_system/bootstrap/evaluator/shell_utils.sh" 2>/dev/null || true
+    source "$CLM_ROOT/computable_knowledge/Concrete/layer5_system/bootstrap/layer0_core/mcard_storage.sh" 2>/dev/null || true
+    source "$CLM_ROOT/computable_knowledge/Concrete/layer5_system/bootstrap/governance/register_handle.sh" 2>/dev/null || true
+    source "$CLM_ROOT/computable_knowledge/Concrete/layer5_system/bootstrap/layer0_core/clm_bootstrap.sh" 2>/dev/null || true
+    source "$CLM_ROOT/computable_knowledge/Concrete/layer5_system/bootstrap/governance/validate_grammar.sh" 2>/dev/null || true
+    source "$CLM_ROOT/computable_knowledge/Concrete/layer5_system/bootstrap/layer0_core/clm_algebra.sh" 2>/dev/null || true
+    source "$CLM_ROOT/computable_knowledge/Concrete/layer5_system/playbooks/diff_handle.sh" 2>/dev/null || true
+    {op} "$@"
+    """
+    proc = subprocess.Popen([get_bash_command(), "-c", bash_cmd, "--"] + list(args), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, encoding="utf-8")
+    stdout_data, _ = proc.communicate()
+    return proc.returncode, stdout_data, ""
+
+
+def test_baldwin_operators(clm_root: str) -> int:
+    """
+    Validates Baldwin modularity operators (split, port, augment) in the local database.
+    """
+    print("======================================================")
+    print("  Test Suite: Baldwin Modularity Operators (Python Native)")
+    print("======================================================\n")
+
+    passed = 0
+    failed = 0
+
+    def _assert(desc, cond):
+        nonlocal passed, failed
+        if cond:
+            print(f"  ✅ {desc}")
+            passed += 1
+            return True
+        else:
+            print(f"  ❌ {desc}")
+            failed += 1
+            return False
+
+    test_dir = os.path.join(clm_root, "data", "content_memory")
+    log_dir = os.path.join(clm_root, "data", "execution_logs")
+    scratch_dir = os.path.join(log_dir, ".baldwin_scratch")
+
+    os.makedirs(scratch_dir, exist_ok=True)
+    fixture_clm = os.path.join(scratch_dir, "fixture.yaml")
+
+    fixture_yaml = """clm:
+  abstract_spec:
+    context: "Baldwin test fixture"
+    goal: "A CLM fixture for testing"
+    success_criteria:
+      - "The CLM is structurally valid"
+  concrete_impl:
+    runtime: system
+    operation: test_baldwin_fixture
+    inputs:
+      - "test_input"
+    outputs:
+      - "record/test_output"
+    process:
+      type: shell
+      script: |
+        echo "hello from test_baldwin_fixture"
+  balanced_exp:
+    expectation: "The fixture CLM executes correctly"
+    pending_cases:
+      - given:
+          input: "test"
+        when:
+          operation: test_baldwin_fixture
+        then:
+          exit_code: 0
+  _meta:
+    clm_root_hash: sha256:0000000000000000000000000000000000000000000000000000000000000000
+    a_hash: sha256:0000000000000000000000000000000000000000000000000000000000000000
+    c_hash: sha256:0000000000000000000000000000000000000000000000000000000000000000
+    b_hash: sha256:0000000000000000000000000000000000000000000000000000000000000000
+    clm_name: test_fixture
+    computed_at: "2026-05-31T00:00:00Z"
+"""
+    with open(fixture_clm, "w", encoding="utf-8") as fh:
+        fh.write(fixture_yaml)
+
+    import sys
+    target = "clm.layer2.storage"
+    mod = sys.modules.get(target)
+    if mod is None:
+        __import__(target)
+        mod = sys.modules.get(target)
+    CLMDB = mod.CLMDB
+    register_handle = mod.register_handle
+
+    db = CLMDB(clm_root)
+    db.execute("content_memory", "DELETE FROM handle_history WHERE handle LIKE 'test:baldwin%';")
+    db.execute("content_memory", "DELETE FROM handle_registry WHERE handle LIKE 'test:baldwin%';")
+
+    # 1. SPLIT
+    print("-- 1. SPLIT (Decomposition) -------------------------")
+    rc, stdout, stderr = run_algebra_op(clm_root, "split", fixture_clm)
+    _assert("split returns 0", rc == 0)
+    _assert("split produces A-MCard", "A-MCard" in stdout)
+    _assert("split produces C-MCard", "C-MCard" in stdout)
+    _assert("split produces B-MCard", "B-MCard" in stdout)
+    _assert("split shows a_hash", "a_hash" in stdout)
+    _assert("split shows c_hash", "c_hash" in stdout)
+
+    a_files = [f for f in os.listdir(test_dir) if f.startswith("a_") and f.endswith(".yaml")]
+    c_files = [f for f in os.listdir(test_dir) if f.startswith("c_") and f.endswith(".yaml")]
+    b_files = [f for f in os.listdir(test_dir) if f.startswith("b_") and f.endswith(".yaml")]
+
+    _assert("A-MCard facet file created", len(a_files) > 0)
+    _assert("C-MCard facet file created", len(c_files) > 0)
+    _assert("B-MCard facet file created", len(b_files) > 0)
+
+    if a_files:
+        latest_a = sorted(a_files)[-1]
+        with open(os.path.join(test_dir, latest_a), encoding="utf-8") as f:
+            a_data = yaml.safe_load(f)
+        _assert("A-MCard facet is abstract_spec", "abstract_spec" in a_data.get("mcard", {}).get("facet", ""))
+
+    # 2. SUBSTITUTE
+    print("\n-- 2. SUBSTITUTE (Swap Implementation) --------------")
+    new_impl = os.path.join(scratch_dir, "new_impl.yaml")
+    new_impl_yaml = """runtime: system
+operation: test_substituted_fixture
+inputs:
+  - "new_input"
+outputs:
+  - "record/new_output"
+process:
+  type: shell
+  script: |
+    echo "substituted implementation"
+"""
+    with open(new_impl, "w", encoding="utf-8") as fh:
+        fh.write(new_impl_yaml)
+
+    rc, stdout, stderr = run_algebra_op(clm_root, "substitute", fixture_clm, new_impl)
+    _assert("substitute returns 0", rc == 0)
+
+    sub_file = None
+    for line in stdout.splitlines():
+        if "Substituted CLM:" in line:
+            sub_file = line.split("CLM:", 1)[1].strip()
+            break
+
+    if sub_file and os.path.exists(sub_file):
+        with open(sub_file, encoding="utf-8") as f:
+            sub_data = yaml.safe_load(f)
+        goal = sub_data.get("clm", {}).get("abstract_spec", {}).get("goal", "")
+        _assert("substitute preserves abstract_spec", "A CLM fixture for testing" in goal)
+        _assert("substitute retires tested_cases key", "tested_cases" not in sub_data.get("clm", {}).get("balanced_exp", {}))
+
+        # Verify grammar validation in-process via python
+        # Validate grammar by running compose-conditions or evaluate
+        from clm.layer0.algebra import load_normalized_manifest
+        try:
+            load_normalized_manifest(clm_root, sub_file)
+            _assert("substituted CLM passes grammar", True)
+        except Exception:
+            _assert("substituted CLM passes grammar", False)
+    else:
+        _assert("substitute produced output file", False)
+
+    # 3. AUGMENT
+    print("\n-- 3. AUGMENT (Add Layers + Handle History) ---------")
+    register_handle(clm_root, "test:baldwin_augment", fixture_clm)
+
+    res = db.execute("content_memory", "SELECT count(*) FROM handle_history WHERE handle = 'test:baldwin_augment';")
+    pre_history_count = int(res) if res else 0
+
+    aug_spec = os.path.join(scratch_dir, "aug_spec.yaml")
+    aug_spec_yaml = """pending_cases:
+  - given:
+      input: "augmented_test"
+    when:
+      operation: test_augmented
+    then:
+      exit_code: 0
+"""
+    with open(aug_spec, "w", encoding="utf-8") as fh:
+        fh.write(aug_spec_yaml)
+
+    rc, stdout, stderr = run_algebra_op(clm_root, "augment", fixture_clm, aug_spec)
+    _assert("augment returns 0", rc == 0)
+    _assert("augment reports pending cases added", "pending case" in stdout)
+
+    aug_file = None
+    for line in stdout.splitlines():
+        if "Augmented CLM:" in line:
+            aug_file = line.split("CLM:", 1)[1].strip()
+            break
+
+    if aug_file and os.path.exists(aug_file):
+        register_handle(clm_root, "test:baldwin_augment", aug_file)
+    else:
+        _assert("aug_file exists", False)
+
+    res = db.execute("content_memory", "SELECT count(*) FROM handle_history WHERE handle = 'test:baldwin_augment';")
+    post_history_count = int(res) if res else 0
+    _assert("handle_history entry created after augmentation", post_history_count > pre_history_count)
+
+    rc, stdout, stderr = run_algebra_op(clm_root, "diff_handle", "test:baldwin_augment")
+    _assert("diff_handle returns 0", rc == 0)
+    _assert("diff_handle shows handle name", "test:baldwin_augment" in stdout)
+
+    aug_sc = os.path.join(scratch_dir, "aug_sc.yaml")
+    with open(aug_sc, "w", encoding="utf-8") as fh:
+        fh.write('success_criteria: ["New criterion via augment"]\n')
+    rc, stdout, stderr = run_algebra_op(clm_root, "augment", fixture_clm, aug_sc)
+    _assert("augment adds success_criteria", "success criteria" in stdout)
+
+    # 4. EXCLUDE
+    print("\n-- 4. EXCLUDE (Prune + Audit + Handle History) ------")
+    rc, stdout, stderr = run_algebra_op(clm_root, "exclude", fixture_clm, ".clm.concrete_impl.inputs")
+    _assert("exclude non-essential field returns 0", rc == 0)
+    _assert("exclude reports archived content", "Archived" in stdout)
+
+    excl_file = None
+    audit_file = None
+    for line in stdout.splitlines():
+        if "Excluded CLM:" in line:
+            excl_file = line.split("CLM:", 1)[1].strip()
+        elif "Archived excluded content:" in line:
+            audit_file = line.split("content:", 1)[1].strip()
+
+    _assert("Exclude audit MCard created", audit_file is not None and os.path.exists(audit_file))
+    if audit_file and os.path.exists(audit_file):
+        with open(audit_file, encoding="utf-8") as f:
+            aud = yaml.safe_load(f)
+        _assert("Audit MCard records excluded path", aud.get("mcard", {}).get("excluded_path") == ".clm.concrete_impl.inputs")
+
+    if excl_file and os.path.exists(excl_file):
+        try:
+            load_normalized_manifest(clm_root, excl_file)
+            _assert("excluded CLM passes grammar validation", True)
+        except Exception:
+            _assert("excluded CLM passes grammar validation", False)
+
+    register_handle(clm_root, "test:baldwin_exclude", fixture_clm)
+    res = db.execute("content_memory", "SELECT count(*) FROM handle_history WHERE handle = 'test:baldwin_exclude';")
+    pre_excl_history = int(res) if res else 0
+
+    if excl_file and os.path.exists(excl_file):
+        register_handle(clm_root, "test:baldwin_exclude", excl_file)
+
+    res = db.execute("content_memory", "SELECT count(*) FROM handle_history WHERE handle = 'test:baldwin_exclude';")
+    post_excl_history = int(res) if res else 0
+    _assert("exclude creates handle_history entry for version tracking", post_excl_history > pre_excl_history)
+
+    prev_hash = db.execute("content_memory", "SELECT previous_hash FROM handle_history WHERE handle = 'test:baldwin_exclude' ORDER BY id DESC LIMIT 1;")
+    prev_hash = prev_hash.strip() if prev_hash else None
+    if prev_hash:
+        prev_content = db.execute("content_memory", f"SELECT content FROM card WHERE hash = '{prev_hash}';")
+        _assert("Previous version retrievable via handle_history", prev_content and "test_input" in prev_content)
+    else:
+        _assert("Previous version retrievable", False)
+
+    rc, stdout, stderr = run_algebra_op(clm_root, "exclude", fixture_clm, ".clm.abstract_spec")
+    _assert("exclude required field is rejected", rc != 0)
+
+    # 5. INVERT
+    print("\n-- 5. INVERT (Extract Rules) ------------------------")
+    rc, stdout, stderr = run_algebra_op(clm_root, "invert", fixture_clm, ".clm.concrete_impl.process.type", "promote")
+    _assert("invert promote returns 0", rc == 0)
+    _assert("invert reports promote to success_criteria", "success_criteria" in stdout)
+
+    inv_promote_file = None
+    for line in stdout.splitlines():
+        if "Inverted CLM:" in line:
+            inv_promote_file = line.split("CLM:", 1)[1].strip()
+            break
+
+    if inv_promote_file and os.path.exists(inv_promote_file):
+        with open(inv_promote_file, encoding="utf-8") as f:
+            inv_data = yaml.safe_load(f)
+        sc_len = len(inv_data.get("clm", {}).get("abstract_spec", {}).get("success_criteria", []))
+        _assert("Promoted CLM has additional success criteria", sc_len > 1)
+    else:
+        _assert("Invert promote file created", False)
+
+    rc, stdout, stderr = run_algebra_op(clm_root, "invert", fixture_clm, ".clm.concrete_impl.operation", "standalone")
+    _assert("invert standalone returns 0", rc == 0)
+
+    inv_standalone_file = None
+    for line in stdout.splitlines():
+        if "Inverted CLM:" in line:
+            inv_standalone_file = line.split("CLM:", 1)[1].strip()
+            break
+        elif "File:" in line:
+            inv_standalone_file = line.split("File:", 1)[1].strip()
+            break
+
+    if inv_standalone_file and os.path.exists(inv_standalone_file):
+        try:
+            load_normalized_manifest(clm_root, inv_standalone_file)
+            _assert("inverted standalone CLM passes grammar", True)
+        except Exception:
+            _assert("inverted standalone CLM passes grammar", False)
+    else:
+        _assert("Invert standalone file created", False)
+
+    rc, stdout, stderr = run_algebra_op(clm_root, "invert", fixture_clm, ".clm.nonexistent.path", "promote")
+    _assert("invert non-existent path returns 1", rc != 0)
+
+    # 6. PORT
+    print("\n-- 6. PORT (Migrate Environment) --------------------")
+    rc, stdout, stderr = run_algebra_op(clm_root, "port", fixture_clm, "python", "CPython 3.12 / Ubuntu 24.04 aarch64")
+    _assert("port returns 0", rc == 0)
+
+    port_file = None
+    port_audit = None
+    for line in stdout.splitlines():
+        if "Ported CLM:" in line:
+            port_file = line.split("CLM:", 1)[1].strip()
+        elif "Migration audit:" in line:
+            port_audit = line.split("audit:", 1)[1].strip()
+
+    if port_file and os.path.exists(port_file):
+        with open(port_file, encoding="utf-8") as f:
+            port_data = yaml.safe_load(f)
+        _assert("ported CLM has new runtime", port_data.get("clm", {}).get("concrete_impl", {}).get("runtime") == "python")
+        _assert("port retires tested_cases key", "tested_cases" not in port_data.get("clm", {}).get("balanced_exp", {}))
+    else:
+        _assert("port file created", False)
+
+    _assert("Port migration audit MCard created", port_audit is not None and os.path.exists(port_audit))
+    if port_audit and os.path.exists(port_audit):
+        with open(port_audit, encoding="utf-8") as f:
+            aud = yaml.safe_load(f)
+        _assert("Audit MCard records operation=port", aud.get("mcard", {}).get("operation") == "port")
+        _assert("Audit records new runtime", aud.get("mcard", {}).get("content", {}).get("new_runtime") == "python")
+
+    _assert("port reports evidence invalidated", "evidence invalidated" in stdout)
+
+    # 7. Handle History Verification
+    print("\n-- 7. Handle History (mcard_schema.sql Verification) -")
+    res = db.execute("content_memory", "SELECT count(*) FROM handle_history WHERE handle LIKE 'test:baldwin%';")
+    total_history = int(res) if res else 0
+    _assert("handle_history has ≥2 entries for test handles", total_history >= 2)
+
+    res = db.execute("content_memory", "SELECT count(*) FROM handle_registry WHERE handle LIKE 'test:baldwin%';")
+    total_handles = int(res) if res else 0
+    _assert("handle_registry has ≥2 test handles", total_handles >= 2)
+
+    res = db.execute("content_memory", "SELECT count(*) FROM handle_history hh INNER JOIN card c ON hh.previous_hash = c.hash WHERE hh.handle LIKE 'test:baldwin%';")
+    chain_valid = int(res) if res else 0
+    _assert("handle_history → card join resolves", chain_valid >= 1)
+
+    # Cleanup
+    shutil.rmtree(scratch_dir, ignore_errors=True)
+    db.execute("content_memory", "DELETE FROM handle_history WHERE handle LIKE 'test:baldwin%';")
+    db.execute("content_memory", "DELETE FROM handle_registry WHERE handle LIKE 'test:baldwin%';")
+
+    print("\n======================================================")
+    print(f"  Results: {passed} passed, {failed} failed")
+    return 0 if failed == 0 else 1

clm/layer1/type_inspector.py

@@ -0,0 +1,166 @@
+"""
+Meta-Circular Type Inspector.
+
+This module provides the built-in PCards (PCard_Pre, PCard_Post) required by the
+Meta-Circular Evaluator to statically inspect Input and Output Types against
+the generalized numbers defined in the architecture.
+
+It utilizes a strictly data-driven registry of primitive types and ContentTypeInterpreter MIME types.
+"""
+
+import json
+from typing import Any
+
+from clm.layer0.model.card import MCard
+from clm.layer0.model.interpreter import ContentTypeInterpreter
+from clm.layer0.model.pcard import PCard
+
+PRIMITIVES = {
+    "string": str,
+    "int": int,
+    "double": float,
+    "float": float,
+    "date": str,  # Parsing ISO strings or datetime objects
+    "object": dict,
+    "array": list,
+    "boolean": bool,
+}
+
+
+class TypeInspectorRegistry:
+    """Data-driven registry bridging primitives and content types."""
+
+    @classmethod
+    def get_supported_types(cls) -> set[str]:
+        interpreter = ContentTypeInterpreter()
+        mimes = set(interpreter._MIME_TO_EXTENSION.keys())
+        primitives = set(PRIMITIVES.keys())
+        return mimes.union(primitives)
+
+    @classmethod
+    def validate(cls, payload: Any, expected_type: str) -> bool:
+        if expected_type in PRIMITIVES:
+            # Special handling for primitive parsing if necessary
+            # For simplicity, we just check isinstance
+            return isinstance(payload, PRIMITIVES[expected_type])
+
+        # If it's a MIME type (content type fallback)
+        try:
+            # We strictly cast payload to str/bytes for detection if it's not
+            detect_payload = payload
+            if getattr(payload, "get_content", None):
+                detect_payload = payload.get_content(as_text=True)
+            elif not isinstance(payload, str | bytes):
+                detect_payload = json.dumps(payload)
+
+            interpreter = ContentTypeInterpreter()
+            detected_mime, _ = interpreter.detect_content_type(detect_payload)
+
+            # Application/json might actually just be valid for our custom MIME types natively
+            if detected_mime == expected_type:
+                return True
+
+            # Weak fallback: if expected is application/mcard or vcard, bypass strict detection
+            # if we confirm it's an MCard instance
+            if expected_type.startswith("application/mcard") and isinstance(
+                payload, MCard
+            ):
+                return True
+            if expected_type.startswith("application/vcard") and hasattr(
+                payload, "is_verification_vcard"
+            ):
+                return True
+
+            return detected_mime == expected_type
+        except Exception:
+            return False
+
+
+def _pcard_validate(payload: Any, expected_type: str, phase: str) -> bool:
+    inspector = TypeInspectorRegistry()
+    if expected_type not in inspector.get_supported_types():
+        # Soft fallback for custom application types
+        if not expected_type.startswith("application/"):
+            raise ValueError(
+                f"Type '{expected_type}' is not a recognized static generalized number format."
+            )
+
+    if not inspector.validate(payload, expected_type):
+        raise TypeError(
+            f"Payload failed validation for type '{expected_type}' during {phase} phase."
+        )
+    return True
+
+
+class TypeInspectorPCardPre:
+    """PCard implementation for validating inputs BEFORE execution."""
+
+    def execute(self, payload: Any, schema: list[dict[str, Any]]) -> PCard:
+        """
+        Takes the input payload and the expected schema geometry list.
+        Returns a v_pre PCard if successful.
+        """
+        from datetime import datetime, timezone
+
+        for field in schema:
+            field_name = field.get("name")
+            expected_type = field.get("type")
+
+            if isinstance(payload, dict):
+                field_val = payload.get(field_name)
+            else:
+                field_val = payload
+
+            _pcard_validate(field_val, expected_type, "Precondition")
+
+        m = MCard(json.dumps(payload) if isinstance(payload, dict) else str(payload))
+
+        content = {
+            "clm": {
+                "version": "1.0",
+                "type": "precondition-witness",
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "target_hash": m.hash,
+            }
+        }
+        return PCard(json.dumps(content))
+
+
+class TypeInspectorPCardPost:
+    """PCard implementation for validating outputs AFTER execution."""
+
+    def execute(
+        self, output: Any, schema: list[dict[str, Any]], pcard_hash: str
+    ) -> PCard:
+        """
+        Takes the execution output and expected output schema geometry.
+        Returns a v_post PCard if successful.
+        """
+        from datetime import datetime, timezone
+
+        for field in schema:
+            expected_type = field.get("type")
+
+            # Simple assumption: output is a single blob or dict matching schema keys
+            if isinstance(output, dict) and field.get("name") in output:
+                val = output.get(field.get("name"))
+            else:
+                val = output
+
+            _pcard_validate(val, expected_type, "Postcondition")
+
+        content = {
+            "clm": {
+                "version": "1.0",
+                "type": "postcondition-witness",
+                "pcard_hash": pcard_hash,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "output_repr": str(output)[:512],
+            }
+        }
+        return PCard(json.dumps(content))
+
+
+# Singleton instances representing the autonomous PCards
+PCard_Pre = TypeInspectorPCardPre()
+PCard_Post = TypeInspectorPCardPost()