cortex-runtime 0.2.0__py3-none-any.whl

cortex/tools/verification/oracle.py

@@ -0,0 +1,164 @@
+"""
+Structured Verification Oracle for 3-Way Trace Equivalence
+"""
+
+from typing import Any
+
+from cortex.tools.verification.schema import CanonicalState
+
+
+class VerificationOracle:
+    def __init__(self, version: str = "v2.1.0", strict_trap_matching: bool = True):
+        self.version = version
+        self.strict_trap_matching = strict_trap_matching
+
+    def evaluate_equivalence(
+        self,
+        coq_trace: list[CanonicalState],
+        rust_trace: list[CanonicalState],
+        rtl_trace: list[CanonicalState] | None = None
+    ) -> dict[str, Any]:
+        """
+        Evaluates step-by-step equivalence across CanonicalState objects.
+        Returns structured diagnostic object.
+        """
+        # 1. Length check
+        if len(coq_trace) != len(rust_trace):
+            return {
+                "status": "FAIL",
+                "error_type": "LengthMismatch",
+                "message": f"Coq emitted {len(coq_trace)} steps, Rust emitted {len(rust_trace)} steps",
+                "observed_divergence": {"coq_len": len(coq_trace), "rust_len": len(rust_trace)}
+            }
+
+        if rtl_trace and len(rust_trace) != len(rtl_trace):
+            return {
+                "status": "FAIL",
+                "error_type": "LengthMismatch",
+                "message": f"Rust emitted {len(rust_trace)} steps, RTL emitted {len(rtl_trace)} steps",
+                "observed_divergence": {"rust_len": len(rust_trace), "rtl_len": len(rtl_trace)}
+            }
+
+        # 2. Frame-by-frame field evaluation
+        num_steps = len(coq_trace)
+        for idx in range(num_steps):
+            c_step = coq_trace[idx]
+            e_step = rust_trace[idx]
+            step_num = idx + 1
+
+            # HEC match
+            if c_step.reg_hec != e_step.reg_hec:
+                return {
+                    "status": "FAIL",
+                    "error_type": "StateDivergence",
+                    "failing_step": step_num,
+                    "mismatched_field": "reg_hec",
+                    "canonical_expected": {"coq": c_step.reg_hec},
+                    "observed_divergence": {"rust": e_step.reg_hec}
+                }
+
+            # Trap status match
+            if c_step.trap.triggered != e_step.trap.triggered:
+                return {
+                    "status": "FAIL",
+                    "error_type": "TrapStatusMismatch",
+                    "failing_step": step_num,
+                    "mismatched_field": "trap.triggered",
+                    "canonical_expected": {"coq": c_step.trap.triggered},
+                    "observed_divergence": {"rust": e_step.trap.triggered}
+                }
+
+            # STCR file match
+            for r in range(32):
+                c_stcr = c_step.stcr[r]
+                e_stcr = e_step.stcr[r]
+
+                if c_stcr.valid != e_stcr.valid:
+                    return {
+                        "status": "FAIL",
+                        "error_type": "StateDivergence",
+                        "failing_step": step_num,
+                        "mismatched_field": f"stcr[{r}].valid",
+                        "canonical_expected": {"coq": c_stcr.valid},
+                        "observed_divergence": {"rust": e_stcr.valid}
+                    }
+                if c_stcr.valid:
+                    if c_stcr.permissions != e_stcr.permissions:
+                        return {
+                            "status": "FAIL",
+                            "error_type": "StateDivergence",
+                            "failing_step": step_num,
+                            "mismatched_field": f"stcr[{r}].permissions",
+                            "canonical_expected": {"coq": c_stcr.permissions},
+                            "observed_divergence": {"rust": e_stcr.permissions}
+                        }
+                    if c_stcr.epoch != e_stcr.epoch:
+                        return {
+                            "status": "FAIL",
+                            "error_type": "StateDivergence",
+                            "failing_step": step_num,
+                            "mismatched_field": f"stcr[{r}].epoch",
+                            "canonical_expected": {"coq": c_stcr.epoch},
+                            "observed_divergence": {"rust": e_stcr.epoch}
+                        }
+
+            # RTL 3-way check if RTL trace present
+            if rtl_trace:
+                r_step = rtl_trace[idx]
+                if e_step.reg_hec != r_step.reg_hec:
+                    return {
+                        "status": "FAIL",
+                        "error_type": "StateDivergence",
+                        "failing_step": step_num,
+                        "mismatched_field": "reg_hec",
+                        "canonical_expected": {"rust": e_step.reg_hec},
+                        "observed_divergence": {"rtl": r_step.reg_hec}
+                    }
+                if e_step.trap.triggered != r_step.trap.triggered:
+                    return {
+                        "status": "FAIL",
+                        "error_type": "TrapStatusMismatch",
+                        "failing_step": step_num,
+                        "mismatched_field": "trap.triggered",
+                        "canonical_expected": {"rust": e_step.trap.triggered},
+                        "observed_divergence": {"rtl": r_step.trap.triggered}
+                    }
+
+                for r in range(32):
+                    e_stcr = e_step.stcr[r]
+                    r_stcr = r_step.stcr[r]
+                    if e_stcr.valid != r_stcr.valid:
+                        return {
+                            "status": "FAIL",
+                            "error_type": "StateDivergence",
+                            "failing_step": step_num,
+                            "mismatched_field": f"stcr[{r}].valid",
+                            "canonical_expected": {"rust": e_stcr.valid},
+                            "observed_divergence": {"rtl": r_stcr.valid}
+                        }
+                    if e_stcr.valid:
+                        if e_stcr.permissions != r_stcr.permissions:
+                            return {
+                                "status": "FAIL",
+                                "error_type": "StateDivergence",
+                                "failing_step": step_num,
+                                "mismatched_field": f"stcr[{r}].permissions",
+                                "canonical_expected": {"rust": e_stcr.permissions},
+                                "observed_divergence": {"rtl": r_stcr.permissions}
+                            }
+                        if e_stcr.epoch != r_stcr.epoch:
+                            return {
+                                "status": "FAIL",
+                                "error_type": "StateDivergence",
+                                "failing_step": step_num,
+                                "mismatched_field": f"stcr[{r}].epoch",
+                                "canonical_expected": {"rust": e_stcr.epoch},
+                                "observed_divergence": {"rtl": r_stcr.epoch}
+                            }
+
+        return {
+            "status": "PASS",
+            "evaluated_steps": num_steps,
+            "targets_checked": 3 if rtl_trace else 2,
+            "message": "1:1 State Equivalence Confirmed Across Evaluated Targets"
+        }

cortex/tools/verification/schema/__init__.py

@@ -0,0 +1,44 @@
+"""
+Typed Verification Schemas Package
+"""
+
+from dataclasses import asdict, dataclass
+
+
+@dataclass
+class CanonicalSTCR:
+    index: int
+    valid: bool
+    permissions: int
+    base_address: int
+    epoch: int
+
+    def to_dict(self) -> dict[str, object]:
+        return asdict(self)
+
+@dataclass
+class CanonicalTrap:
+    triggered: bool
+    cause_code: int
+    cause_name: str
+    trap_val: int
+
+    def to_dict(self) -> dict[str, object]:
+        return asdict(self)
+
+@dataclass
+class CanonicalState:
+    step: int
+    pc: int
+    instruction: str
+    privilege_mode: str
+    reg_hec: int
+    registers: dict[str, str]
+    stcr: list[CanonicalSTCR]
+    trap: CanonicalTrap
+
+    def to_dict(self) -> dict[str, object]:
+        d = asdict(self)
+        d["stcr"] = [s.to_dict() for s in self.stcr]
+        d["trap"] = self.trap.to_dict()
+        return d

cortex/tools/verification/schema/event.py

@@ -0,0 +1,44 @@
+"""
+Frozen CommitEventV1 Schema for Architectural Retirement Events
+"""
+
+from dataclasses import asdict, dataclass
+
+
+@dataclass(frozen=True)
+class PureArchitecturalStateV1:
+    pc: str
+    instruction: str
+    privilege_mode: str
+    registers: dict[str, str]
+    stcr: list[dict[str, object]]
+    trap: dict[str, object]
+    memory_commit: dict[str, object] | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        return asdict(self)
+
+@dataclass(frozen=True)
+class ObservationMetadataV1:
+    step: int
+    cycle: int
+    timestamp_ns: int
+    target_name: str
+    commit_id: str
+    adapter_version: str
+
+    def to_dict(self) -> dict[str, object]:
+        return asdict(self)
+
+@dataclass(frozen=True)
+class CommitEventV1:
+    schema_version: int = 1
+    architectural: PureArchitecturalStateV1 | None = None
+    observation: ObservationMetadataV1 | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "schema_version": self.schema_version,
+            "architectural": self.architectural.to_dict() if self.architectural else {},
+            "observation": self.observation.to_dict() if self.observation else {}
+        }

cortex/tools/verification/shrink.py

@@ -0,0 +1,26 @@
+"""
+Semantic Delta-Debugging Shrinker for Minimizing Failing Scenarios
+"""
+
+from typing import Any
+
+
+class SemanticShrinker:
+    def __init__(self, max_shrunk_steps: int = 50):
+        self.max_shrunk_steps = max_shrunk_steps
+
+    def shrink_scenario(self, scenario: dict[str, Any], failing_step: int) -> dict[str, Any]:
+        """
+        Reduces program instructions down to failing step minimum reproducer.
+        """
+        program = scenario.get("program", [])
+        # Truncate instruction stream up to failing step
+        shrunk_program = program[:failing_step]
+
+        return {
+            "seed": scenario.get("seed", "0x00000000"),
+            "original_steps": len(program),
+            "shrunk_steps": len(shrunk_program),
+            "initial_state": scenario.get("initial_state", {}),
+            "program": shrunk_program
+        }

cortex/tools/verify.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""
+Cortex Contract-Driven Formal Verification CLI Entry Point
+"""
+
+import argparse
+import sys
+
+from cortex.tools.verification.contract import VerificationContract
+from cortex.tools.verification.engine import VerificationEngine
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Cortex Contract-Driven Formal Verification Tool")
+    parser.add_argument("--contract", required=True, help="Path to verification contract YAML")
+    parser.add_argument("--seed", default=None, help="Hex seed for random generation (e.g. 0x4A91C3F8)")
+    parser.add_argument("--iterations", type=int, default=None, help="Override total fuzzing iterations")
+    parser.add_argument("--inject-failure", default=None, help="Phase 3A.5 mutation fault vector to inject")
+
+    args = parser.parse_args()
+
+    contract = VerificationContract.load(args.contract)
+
+    # Determine seed
+    seed_str = args.seed or contract.fuzzing_parameters.get("default_seed", "0x4A91C3F8")
+    seed_val = int(seed_str, 16) if seed_str.startswith("0x") else int(seed_str)
+
+    iterations = args.iterations or contract.fuzzing_parameters.get("total_iterations", 100)
+
+    print("================================================================================")
+    print("                       Cortex Verification Platform Engine                      ")
+    print("================================================================================")
+    print(f" Contract ID:       {contract.contract_id}")
+    print(f" Seed:              0x{seed_val:08X}")
+    print(f" Target Iterations: {iterations}")
+    print(f" Oracle Version:    {contract.oracle.get('version', 'v2.1.0')}")
+    if args.inject_failure:
+        print(f" Injecting Fault:   {args.inject_failure}")
+    print("--------------------------------------------------------------------------------")
+
+    engine = VerificationEngine(contract, seed_val)
+    result = engine.run_verification(iterations=iterations, inject_failure=args.inject_failure)
+
+    if result.get("status") == "FAIL":
+        print("\n[!] VERIFICATION MISMATCH DETECTED!")
+        print(f"    Iteration:            {result.get('iteration')}")
+        print(f"    Seed:                 {result.get('seed')}")
+        print(f"    Error Type:           {result['diagnostic'].get('error_type')}")
+        print(f"    Failing Step:         {result['diagnostic'].get('failing_step')}")
+        print(f"    Mismatched Field:     {result['diagnostic'].get('mismatched_field')}")
+        print(f"    Counterexample Hash:  {result.get('counterexample_hash')}")
+        print("================================================================================")
+        sys.exit(1)
+    else:
+        print("\n[✓] SUCCESS: Contract-Driven Verification Passed Across All Targets!")
+        print(f"    Steps Evaluated:       {result.get('total_steps_evaluated')}")
+        print(f"    Opcode Coverage:       {result['metrics']['opcode_coverage']['coverage_percentage']}%")
+        print(f"    Trap Path Coverage:    {result['metrics']['trap_coverage']['coverage_percentage']}%")
+        print(f"    Unique States:         {result['metrics']['state_space_explored']['unique_states_explored']}")
+        print("================================================================================")
+        sys.exit(0)
+
+if __name__ == "__main__":
+    main()

cortex_runtime-0.2.0.dist-info/METADATA

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: cortex-runtime
+Version: 0.2.0
+Summary: Spatiotemporal authority and semantic verification framework for autonomous workflows
+Project-URL: Homepage, https://github.com/Iradukunda-Fils/Cortex
+Project-URL: Documentation, https://github.com/Iradukunda-Fils/Cortex#readme
+Project-URL: Repository, https://github.com/Iradukunda-Fils/Cortex.git
+Project-URL: Issues, https://github.com/Iradukunda-Fils/Cortex/issues
+Author: Iradukunda Fils
+License: Apache-2.0
+License-File: LICENSE
+Keywords: agents,architecture,capability-security,sandbox,spatiotemporal,verification,workflow
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.10
+Requires-Dist: pydantic<3.0.0,>=2.0.0
+Requires-Dist: pyyaml<7.0.0,>=6.0.0
+Requires-Dist: typing-extensions>=4.5.0
+Provides-Extra: dev
+Requires-Dist: build>=1.0.0; extra == 'dev'
+Requires-Dist: pyright>=1.1.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Requires-Dist: twine>=4.0.0; extra == 'dev'
+Requires-Dist: types-pyyaml>=6.0.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.0.0; extra == 'docs'
+Requires-Dist: mkdocs>=1.5.0; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# Cortex Platform: Spatiotemporal Authority & Semantic Verification Framework
+
+[![PyPI Version](https://img.shields.io/pypi/v/cortex-runtime.svg)](https://pypi.org/project/cortex-runtime/)
+[![Python Version](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://python.org)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
+[![Type Checked: Pyright](https://img.shields.io/badge/type--checking-pyright-brightgreen.svg)](https://github.com/microsoft/pyright)
+
+> **Cortex** is a spatiotemporal authority and semantic verification framework designed to enforce execution integrity, capability-negotiated sandboxing, and post-facto deterministic verification across autonomous software runtimes and AI agent architectures.
+
+---
+
+## 📖 Narrative Arc: Why Cortex Exists
+
+### 1. The Problem at Scale
+Traditional security systems rely on static user identities (POSIX permissions, IAM roles, cgroups). However, **autonomous AI agents and non-deterministic software break traditional security models**:
+* **Ambient Authority Leakage**: Agents executing inside shell environments inherit full ambient process permissions, allowing unintended file access or dynamic execution.
+* **Subshell Script Bypasses**: Malicious or miscalibrated agents can invoke shell scripts (`.sh`), subprocesses, or eval blocks to bypass high-level application checks.
+* **Non-Deterministic State Drift**: Without causal trace verification, auditing *why* an autonomous agent performed an action after a failure or security breach is impossible.
+
+### 2. The Cortex Value Proposition
+Cortex replaces ambient authority with a **3-Layer Security Boundary**:
+1. **Static Capability Negotiation**: Manifests declare required permissions before plugins access the kernel bus (`CapabilityNegotiator`).
+2. **Runtime Sandbox Proxy**: Guarded resource drivers evaluate capability tokens before firing raw I/O system calls (`PluginContext`).
+3. **Deterministic Replay Audit**: Post-execution trace verification validates $P1$–$P4$ invariants and causal lineage graphs (`cortex workflow replay`).
+
+### 3. Dual-Layer Framing: Non-Technical Analogy vs. Technical Mechanics
+
+```mermaid
+graph TD
+    subgraph Layer 1: Passport Control
+        M[Plugin Manifest] --> N[CapabilityNegotiator]
+        N -->|Match Policy| G[ACTIVE Plugin]
+        N -->|Policy Mismatch| R[REJECTED Plugin]
+    end
+
+    subgraph Layer 2: Boarding Scanner
+        G --> C[PluginContext]
+        C --> D[Guarded Drivers: File / Net / Exec]
+        D -->|has_capability?| E[Execute Action]
+        D -->|Missing Token| V[CAPABILITY_VIOLATION Event]
+    end
+
+    subgraph Layer 3: Flight Blackbox
+        E --> S[Immutable Event Store]
+        V --> S
+        S --> RE[Deterministic Replay Engine]
+        RE --> INV[P1-P4 Invariant Checks]
+    end
+```
+
+| Security Layer | Non-Technical Analogy | Technical Mechanics |
+| :--- | :--- | :--- |
+| **Layer 1: Static Negotiation** | **Passport & Visa Check**<br/>Validates passport and visa credentials before granting entry into the country. | `CapabilityNegotiator.negotiate()` evaluates `PluginManifest.required_capabilities` against `platform_capabilities`. |
+| **Layer 2: Runtime Sandbox Proxy** | **Boarding Gate Scanner**<br/>Ensures passengers present a valid boarding pass for that specific door before entering the aircraft. | `PluginContext.has_capability()` validates tokens before Guarded Resource Drivers fire I/O system calls. |
+| **Layer 3: Verification & Trace Replay** | **Flight Blackbox Recorder**<br/>Records all flight telemetry in a tamper-evident blackbox for post-flight accident investigation. | `DeterministicReplayEngine` re-simulates event streams (`.cortex/events/*.json`), validating $P1$–$P4$ invariants. |
+
+---
+
+## 🚀 Quickstart & Developer Experience
+
+### 1. Installation
+
+Install via PyPI or fast package manager `uv`:
+
+```bash
+# Standard pip
+pip install cortex-runtime
+
+# Fast installation with Astral uv
+uv pip install cortex-runtime
+
+# Or run directly with uv tool
+uvx cortex-runtime --help
+```
+
+### 2. Scaffold a New Project
+
+```bash
+cortex init my_app --type app
+cd my_app
+```
+
+### 3. Execute, Inspect, and Replay Workflows
+
+```bash
+# Execute workflow
+cortex workflow run workflow.json
+
+# Inspect causal execution graph
+cortex workflow inspect .cortex/events/<workflow_id>.json
+
+# Perform 100% deterministic replay audit
+cortex workflow replay .cortex/events/<workflow_id>.json
+```
+
+---
+
+## 📚 Developer Portal & Quick Links
+
+- 🚀 **[Developer Quickstart Guide](docs/quickstart.md)**: Install `cortex-runtime`, build workflows, and run plugins.
+- 💻 **[CLI Reference Documentation](docs/cli.md)**: Standard CLI command usage (`init`, `workflow run`, `inspect`, `replay`).
+- 🏛️ **[Architecture & Security Model](docs/architecture.md)**: 3-layer security boundary, dual-layer framing, and threat neutralization.
+- 🔐 **[Capability Manifest Specification](docs/manifest_spec.md)**: `PluginManifest` schema and negotiation rules.
+- 🔬 **[Research Documentation](Research/)**: Formal whitepapers, mathematical invariants ($P1$–$P4$), and CS literature taxonomy.
+- 📐 **[Coq Proof Substrate](coq/)**: Interactive formal verification proof scripts.
+- ⚡ **[Rust Emulator Engine](cortex-emulator/)**: Hardware state machine emulator.
+
+---
+
+## 🔬 Adversarial Systems Research: Working Hypothesis ($H_{\text{prop}}$)
+
+This repository houses a rigorous, peer-reviewed adversarial falsification program for autonomous systems. The primary function of this research is to validate the **Working Hypothesis ($H_{\text{prop}}$)**:
+
+> **Does an existing semantic preservation relation characterize when the externally observable effects of an execution remain within the authority constraints delegated to that execution under the stated threat model?**
+>
+> *We posit this may be expressible as a relational hyperproperty over operational traces, but leave its classification strictly open pending empirical literature analysis.*
+
+If adversarial analysis reveals that a composition of existing CS frameworks satisfies all safety properties under $H_{\text{prop}}$, no new semantic layer is required. If the analysis exposes an irreducible semantic gap, that gap defines the formal requirements for a new candidate specification.
+
+---
+
+## 🛡️ The Safety Properties Catalog ($P1$–$P4$)
+
+Every composition is evaluated against four orthogonal, non-overlapping safety properties under the **Generalized Semantic Transition Relation ($\Sigma; \Lambda \vdash I \Longrightarrow e$)** mapping input streams ($I$) to terminal target actions ($e$) through intermediate **Operational Artifacts ($\mathcal{A}$)**:
+
+$$\frac{\Sigma; \Lambda \vdash I \xrightarrow{\text{derive}} \mathcal{A} \quad \quad \mathcal{A} \in \text{Adm}(\Lambda) \quad \quad \Sigma; \Lambda \vdash \mathcal{A} \xrightarrow{\text{enact}} e}{\Sigma; \Lambda \vdash I \Longrightarrow e}$$
+
+*   **P1 — Authority Soundness:** Bounded authority must be delegable and attenuable across downstream context shifts such that a principal cannot execute or delegate permissions beyond its initial envelope.
+*   **P2 — Execution Integrity:** The byte-level parameter state of an executed action must remain structurally unaltered between the generation boundary and the interface enforcement perimeters under the stated threat model.
+*   **P3 — Semantic Consequence Preservation:** Every externally observable, irreversible effect must be demonstrably and traceably derivable from the active delegation constraints: $\Sigma \models \text{Preserves}(\Lambda, e)$.
+*   **P4 — Independent Verifiability:** An external, post-facto verifier must be capable of establishing the validity of P3 without trusting the execution runtime beyond the boundaries of an explicitly declared Trusted Computing Base (TCB).
+
+---
+
+## 🔬 Literature Taxonomy (21 Disciplines)
+
+The research program maps system interactions across 21 distinct computer science areas:
+1. **Capability Security** (Confinement & Ambient Authority Elimination)
+2. **Programming Languages** (Type Safety, Scoped-Use Semantics)
+3. **Delegated Authorization** (Offline-Verifiable Attenuation)
+4. **Authorization Engines** (Relationship Graphs & Relational Logic)
+5. **Data Provenance** (Platform-Independent Derived Lineage)
+6. **Whole-System Provenance** (Kernel-Level Telemetry Interception)
+7. **Systemic Accountability** (Tamper-Evident Non-Repudiation Logs)
+8. **Distributed Transactions** (Atomicity & Consistency Guarantees)
+9. **Workflow Systems** (Durability & State Checkpointing)
+10. **Formal Methods** (Process Calculi & Temporal Logic Modelling)
+11. **Formal Verification** (Mathematical Correctness Proofs)
+12. **Information Flow Control** (Integrity Boundaries & Labels)
+13. **Trusted Computing** (Hardware Enclave Isolation)
+14. **Language-Based Security** (Non-Interference & Secure Compilation)
+15. **Operational Semantics** (Structural Operational Semantics, Evaluation Relations)
+16. **Program Logics** (Hoare Logic, Separation Logic, Refinement Calculi)
+17. **Static Analysis** (Abstract Interpretation, Monadic Effects)
+18. **Proof-Producing Computation** (SMT Solvers, Certified Abstract Interpretation)
+19. **Secure Compilation** (Robust Safety/Hyperproperty Preservation)
+20. **Algebraic & Rewriting Frameworks** (Institution Theory, Maude, K Framework)
+21. **Runtime Verification** (Online Trace Compliance & Enforcement Monitors)
+
+---
+
+## 📊 Evaluation Status Matrix
+
+Evaluating candidate compositions over safety properties P1–P4 led to the lock phase, which confirmed the need for a unified spatiotemporal semantic layer incorporating versioned epochs and step-indexing. This has been formalized as the **Cortex Spatiotemporal Mechanics** (FC_01–FC_09):
+
+| ID | Composition Structure | P1 | P2 | P3 | P4 | Verdict / Current Status |
+| --- | --- | :---: | :---: | :---: | :---: | :---: |
+| **CC-01** | Whole-System Provenance + Capability Security | **✓** | **✓** | **✗** | **✗** | **Complete (Partially Covered)** |
+| **CC-04** | Capability Security + Program Logics | **✓** | **✓** | **~** | **✗** | **Complete (Partially Covered)** |
+| **CC-05** | Language-Based Security + Trusted Computing | - | - | - | - | **FROZEN (Identified Semantic Gaps)** |
+| **CC-08** | Runtime Verification + Capability Security | - | - | - | - | **FROZEN (Identified Semantic Gaps)** |
+| **Cortex** | Spatiotemporal Preorders + Epoch-Indexed Value/Trace Relations | **✓** | **✓** | **✓** | **✓** | **FORMALLY PROVEN & ROADMAPPED** |
+
+*Legend: **✓** (Success)  |  **✗** (Failed)  |  **~** (Partial Success)  |  **-** (Not yet evaluated / Frozen)*
+
+---
+
+## 🛠️ Repository Rules & Governance
+
+1. **LOCKED State:** Foundational survey, model, and formal construction documents are frozen once complete to maintain strict control over confirmation bias.
+2. **No Marketing Syntax:** Language remains strictly technical, quantitative, and neutral.

cortex_runtime-0.2.0.dist-info/RECORD

@@ -0,0 +1,76 @@
+cortex/__init__.py,sha256=ayyrrKRJj5LIwIGUUkvtHWMnOxRMXcP64mvmhofrQxI,1229
+cortex/__main__.py,sha256=LtCpUXpZXkUo4lEIB93tDOmynS9rQOXwJtf4_9G1qP4,273
+cortex/client.py,sha256=hSrlUTIFrS8jSe_gwzstbHK5AacKDbjRKMewVVLfFIo,10538
+cortex/compat.py,sha256=sg-IFdQZkUtLOHEeH-oz6pfb7xjpPI1nVfI7hBbYMpM,511
+cortex/exceptions.py,sha256=1QDrlro5SZjWY8-S-Et6cug5A46zZk0Gig_hwbFSpoc,1406
+cortex/plugin.py,sha256=u1ybQsfNKEIIXBnLobKzGKxH4KTt6E-txh92zpaeGaw,1535
+cortex/py.typed,sha256=bWew9mHgMy8LqMu7RuqQXFXLBxh2CRx0dUbSx-3wE48,27
+cortex/schema/__init__.py,sha256=zcDHMgeotqDxWC6uLQjHijRfqp_5QpqbgeQgGUnGvUo,536
+cortex/schema/events.py,sha256=VTyhVCEugkgDRgjcAyCnBe50x7Myu4dqSnwlGCOpr9U,5701
+cortex/tools/__init__.py,sha256=Eez_GptaErId1Uz_fEUA4ct-bBg5w0_KfjjbH-HxbHg,65
+cortex/tools/gen_test_bin.py,sha256=qZsLSBFcvmJLKK-eJ9l_LCebX_LaGZ2N0mfkkEyZf3g,1640
+cortex/tools/run_phase2_verification.sh,sha256=Vk6iVAZTe4es8hEMNFX30ePvS7xVlcqBlrAFonU3Pqk,641
+cortex/tools/verify.py,sha256=QIbZakSzZVVqucdKChNgsx6IOUNz6dpEEm5bZWw5X_w,3363
+cortex/tools/cli/__init__.py,sha256=e3zZVwAQ9XTioRj-8hQtuDydaUk0KBrqXXehEzmsY_A,37
+cortex/tools/cli/main.py,sha256=nYUM16MqbuEFthH3dDeZpHysKFtUv0qtJ1IOrRz0xD4,5729
+cortex/tools/cli/runner.py,sha256=2IIjMxA3che4MslRjNhpKItYCLazL5MY73P-dhstCWM,3739
+cortex/tools/cli/scaffolder.py,sha256=rHW5PexfOq38gnKB068A_cI7WPgnwQRAxlLwjqi-P5I,3827
+cortex/tools/kernel/__init__.py,sha256=3lXheH5-p6HxmP7R4g8KlepCjwThWJaOsUgPN95jtMY,35
+cortex/tools/kernel/context.py,sha256=fQHGHLUSvje2tACpRNJxw71yLrpPTnbGEBcEcIDilmw,600
+cortex/tools/kernel/mailbox.py,sha256=bEJt7n1vP2FrON54tHVGGJxD8MF6ZedKxhbG8thBOAc,847
+cortex/tools/kernel/registry.py,sha256=covAAh3HOvgo-OE7nkm03Eds33JA0gkSDl5D5sJ6azk,892
+cortex/tools/kernel/transport.py,sha256=bOU5vpEVvs9YOt2HID46Gtrl971F4fI_Z6HQFHazEqA,1519
+cortex/tools/kernel/actors/__init__.py,sha256=5XQuuKUE2oQydRTMAbt50uBAQS_Xw-ULPsVxJQ_Bn_A,37
+cortex/tools/kernel/actors/executor.py,sha256=kcDc0P9d6xModUX9fIwtzm_gzMAMsQHSbS_Z8KfJM_w,1523
+cortex/tools/kernel/actors/planner.py,sha256=zyyLeY6GTQOGXhsqpldiHl6pZ44R8Rxcb9iVCYo4vbg,1221
+cortex/tools/kernel/drivers/__init__.py,sha256=9RoqcBTsXb_khbmhJGn9jNfBL92F7cbJjjuciW5Bako,34
+cortex/tools/kernel/drivers/mock_robot.py,sha256=O9wJbJ28tH2bACAIcrrBlkblrjCU7sG708Y2zBzTY60,2960
+cortex/tools/kernel/drivers/rtl_verilator.py,sha256=BhVYoi6c2hJk8KogvjcwiTbp47NI0jizQkqs6QsX7qM,1743
+cortex/tools/kernel/graph/__init__.py,sha256=vKpUKReH5-hoiHI-uKYBwZgFlWBl5qRS9VMYGrGlwKI,45
+cortex/tools/kernel/graph/analyzer.py,sha256=Noimtv15VugE1RkOJu9HlLl_BX1OzTQdWXXYzDN52LU,2105
+cortex/tools/kernel/graph/execution_graph.py,sha256=AEF9brXw7oERepqaKQ6KFUr6_PlMGzrf2jm-HSJVdsQ,1531
+cortex/tools/kernel/plugin/__init__.py,sha256=MUSbSDelur4b2G1vnttUJ36MJBm6UpKaBefC-ET64gc,55
+cortex/tools/kernel/plugin/loader.py,sha256=ue0u0M9epZwMKz_8Nwkp92P1kgOT3I2uWKOl1pcWjao,2974
+cortex/tools/kernel/plugin/manifest.py,sha256=t5MDNFPwyhZBCgjYkcq889tpKiiDuRo4pyPkgJYy98M,1919
+cortex/tools/kernel/schema/__init__.py,sha256=p4MHk7QTeEKbjdLiYINl_vsOVqX5gVyhH9BWEPhvjn0,47
+cortex/tools/kernel/schema/contract.py,sha256=AYn6ggqaVUuF8pnjXfV6vwv0aStIViRzC0_Zu001jJU,434
+cortex/tools/kernel/schema/event.py,sha256=JMtJVoCdj8dLqJrf6Qfibp7gD2ab1QHtUbeq5xg_PAg,1683
+cortex/tools/kernel/schema/message.py,sha256=K2OIYmnDQW8wKEuPi3NOuuaiH0_0hA7rMfTwrjkT7Mw,3579
+cortex/tools/kernel/schema/workflow.py,sha256=z7nUqMEOdIfaxSRPyLCGkYYV8RDfLHxhyLyr51GToS0,1006
+cortex/tools/kernel/services/__init__.py,sha256=fyG3gOP4OFD7AuMad57Zcs_58s8oe-2xQhh7zJsuG1g,30
+cortex/tools/kernel/services/event_store.py,sha256=zagzioOFIEFIbfnewYZ3ubkWe5mXF0lPSjT9dcOThqc,574
+cortex/tools/kernel/services/execution_intelligence.py,sha256=vQSjxAZoDMM7-RZlLr10luhWXfbnBsYz2jBO9nlalEg,1821
+cortex/tools/kernel/services/graph_builder.py,sha256=Blirz3X1yVAoamV87MtH1YQX46lhdvxtWNAZA_pv0Hc,2923
+cortex/tools/kernel/services/replay.py,sha256=3GbgrICub2_lyhy4a0Zs9ZwL_LYqP6FC0wkF9ZIjNHw,1886
+cortex/tools/kernel/services/verification.py,sha256=KDK1-smFd9ZoWTbPnL6IaDh51W4LM6xgt7x5v2Oo1Js,3219
+cortex/tools/verification/__init__.py,sha256=BAvpX6Gr3Q_OvHV1Z9R_IFau9NbeHkLV1KDMCRywQpc,73
+cortex/tools/verification/archive.py,sha256=MgC4_IPwnIVdc1HXersFvLp5L3g2XmKpWxQ_anctoPI,1863
+cortex/tools/verification/bus.py,sha256=TkFgvTdPD6vWLPtQ7GDc7TfptZWWA5hwCiFujltklCQ,809
+cortex/tools/verification/contract.py,sha256=JKDmSSXBVrx6LzFarYqz1R_dOOSTnQ_6iLGsGlVuMxc,2536
+cortex/tools/verification/engine.py,sha256=8rwFyifsfdb_2gqgreDqvEnvduSXdXLgAZ1_5CKWeVs,4851
+cortex/tools/verification/mutation.py,sha256=bU-ZBsdGWqybuoLUXN98iYZfPMzyaOnnYhFpR7HNUQA,1633
+cortex/tools/verification/oracle.py,sha256=4e9tvZzncjnSlS-O_Co7pO_92axvvLedvwiAhAoJ0KY,7275
+cortex/tools/verification/shrink.py,sha256=S6p2v1Z3P8qMN4nNhhmiRSF_JV7HeQ4nwO4Dlmwp7lw,853
+cortex/tools/verification/adapters/__init__.py,sha256=A2Pr-RSwZy11einluN5h1vrLWMz3U-QEMwLU7_bKgH8,74
+cortex/tools/verification/adapters/base.py,sha256=LUxhPxI4Ou1M0GH__8UalNiJzM2mhM0r_h49WKxD3mg,375
+cortex/tools/verification/adapters/coq.py,sha256=Vt9nIPXkSRYiTifYn1eWl24nx_gm_X7uR8IAnh-tTQk,2427
+cortex/tools/verification/adapters/rtl.py,sha256=iJJK3jjBPO-WWxyJWlxiFxyJDWj-zcKvMLTG8pxP_jE,2469
+cortex/tools/verification/adapters/rust.py,sha256=KvWKSS9HfH1_McxRRrQubArIbaNbDviVUVVAridtmuU,2376
+cortex/tools/verification/generator/__init__.py,sha256=1jx--GkqubKHWMHXkB4JD-0z2po5XZh5iU_k1C0HdNU,44
+cortex/tools/verification/generator/composer.py,sha256=XtdPy15_9V5ic46j93ZUq33ZhkbZqbUppVHzlM6Ro4I,1201
+cortex/tools/verification/generator/program.py,sha256=CQw3I7tUAAFJf7Nd2AZHSKQWoPoV1ASHMCoZ4l30UFo,1478
+cortex/tools/verification/generator/state.py,sha256=-kFtv0aaSYBSuW8PMO9S1Y8nVri2iuiuUpJuH5qc2bo,1639
+cortex/tools/verification/invariants/__init__.py,sha256=itl3usAJj0jqBhXKYwd9i4RBaC0MUUpDxmVppqI8ZSw,50
+cortex/tools/verification/invariants/capability.py,sha256=5Pvg97oeGXxMp9yIhGvSjBcDKaJjhZUAAZKbZM2tNxw,2662
+cortex/tools/verification/metrics/__init__.py,sha256=TEvMngj6FQRb1cgZBZPZbxhMvcR6T3ZjbodoBUB-wRY,41
+cortex/tools/verification/metrics/base.py,sha256=x4_w8ZeXOcPWWFkujuHpJdxdSt6QRYY90JVarT8qxjE,344
+cortex/tools/verification/metrics/opcode.py,sha256=Yk0SSge9LAzhx4OJ401YfyNT-ePNMvgUn2Su10jnglw,703
+cortex/tools/verification/metrics/state_space.py,sha256=NvWJPR49b2CyDHudE_0li8dUeeubKe9u4HUaAotn8FY,746
+cortex/tools/verification/metrics/trap.py,sha256=g_baDirgHZUIDibCPX9SJKbCapysZaN6sTMvypCH3Qw,783
+cortex/tools/verification/schema/__init__.py,sha256=TsRgOXw80B5dcxXWayot2D_RPOqgapZXfjUXpyv_CdI,852
+cortex/tools/verification/schema/event.py,sha256=3PnHTr6zf8AscW5AHJiSnrTo-ZEhp-rsXviVepBtZ-4,1168
+cortex_runtime-0.2.0.dist-info/METADATA,sha256=8utR49w9-dj2TgQjzuNeysHnvjGuWAQnSRD7LBefLrg,12723
+cortex_runtime-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+cortex_runtime-0.2.0.dist-info/entry_points.txt,sha256=Hnet-6HKhpZG1vmd0I5n3g8SvyVNnKoQqnjRMc0d9Nc,64
+cortex_runtime-0.2.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+cortex_runtime-0.2.0.dist-info/RECORD,,

cortex_runtime-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cortex_runtime-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cortex = cortex.tools.cli.main:cli_entrypoint