capability-reasoning-kernel 0.5.0rc2__tar.gz → 0.6.0__tar.gz

{capability_reasoning_kernel-0.5.0rc2 → capability_reasoning_kernel-0.6.0}/.github/workflows/ci.yml

@@ -46,7 +46,7 @@ jobs:
           persist-credentials: false
 
       - name: Install uv
-        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
         with:
           version: "0.12.10"
           checksum: "173d95a0c32d18c896c46ba6fafbf3cf9c14ab74b033f81b76c883ef492a976b"
@@ -84,7 +84,7 @@ jobs:
           persist-credentials: false
 
       - name: Install uv
-        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
         with:
           version: "0.12.10"
           checksum: "173d95a0c32d18c896c46ba6fafbf3cf9c14ab74b033f81b76c883ef492a976b"
@@ -129,7 +129,7 @@ jobs:
           persist-credentials: false
 
       - name: Install uv
-        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
         with:
           version: "0.12.10"
           checksum: "173d95a0c32d18c896c46ba6fafbf3cf9c14ab74b033f81b76c883ef492a976b"

{capability_reasoning_kernel-0.5.0rc2 → capability_reasoning_kernel-0.6.0}/.github/workflows/pages.yml

@@ -39,7 +39,7 @@ jobs:
           enablement: true # self-enable Pages (build_type=workflow) on first run — no manual Settings step
 
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@56afc609e74202658d3ffba0e8f6dda462b719fa # v3
+        uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0
         with:
           path: docs
 

{capability_reasoning_kernel-0.5.0rc2 → capability_reasoning_kernel-0.6.0}/.github/workflows/release.yml

@@ -27,7 +27,7 @@ jobs:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+      - uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
         with:
           version: "0.12.10"
           checksum: "173d95a0c32d18c896c46ba6fafbf3cf9c14ab74b033f81b76c883ef492a976b"

{capability_reasoning_kernel-0.5.0rc2 → capability_reasoning_kernel-0.6.0}/CHANGELOG.md

@@ -4,6 +4,51 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.0] - 2026-09-06
+
+Stable executable host-conformance release. It promotes the candidate after reference, package,
+provider and real-consumer validation while keeping live host-adapter acceptance a separate claim.
+
+### Changed
+
+- Validate all nine `operational-v1` cases through the packaged reference target and all four
+  `gate-v1` cases through Vibemonitor's real pre-pipeline checkpoint on Python 3.12 and 3.13.
+- Verify the release wheel and source distribution through checksummed CI round trips, isolated
+  installation, TestPyPI and PyPI publication, plus the required live DeepSeek provider gate.
+- Preserve the evidence boundary: consumer conformance does not establish an organic
+  enforce-to-PR run, complete `RunSession` adoption, or live adapter UAT.
+
+## [0.6.0rc1] - 2026-09-06
+
+First executable host-conformance candidate. It turns the operational checklist into a versioned,
+key-free profile without claiming that package tests replace live-adapter acceptance.
+
+### Added
+
+- Public `reasoning_kernel.conformance` API with fixed `gate-v1` and `operational-v1` profiles,
+  trusted host scenarios and external-effect observations.
+- Sanitized JSON reports with pass, fail and inconclusive outcomes, plus a
+  `reasoning-kernel-conformance` CLI suitable for CI artifacts.
+- Nine-case reference suite covering benign and injected flows, capability denial, invalid output,
+  failures around effects, audit failure and crash/reopen without replay.
+- Four-case Gate profile for consumers that use the verifier as a pre-pipeline checkpoint without
+  embedding the operational session runtime.
+- Structural report checks requiring every started effect to have a preceding successful Gate
+  decision and every completion to follow its matching start.
+
+## [0.5.0] - 2026-09-06
+
+First stable operational embedding release. It promotes the two release candidates after package,
+provider and real-consumer compatibility validation; each host remains responsible for validating
+its own live adapters and policies.
+
+### Changed
+
+- Qualify OpenAI SDK 3.8 through the required live DeepSeek compatibility gate without calling the
+  OpenAI service, and update the locked Pyright version.
+- Upgrade the SHA-pinned uv and Pages actions after CI artifact round-trip and rendered Pages checks.
+- Validate Vibemonitor's real `KernelGate` integration and complete consumer suite on Python 3.14.
+
 ## [0.5.0rc2] - 2026-09-06
 
 Maintenance candidate following the first published operational release. Publication remains
@@ -201,6 +246,9 @@ Initial reference implementation of the Reasoning Kernel pattern (strong / CaMeL
 invariants, no-effect-bypasses-the-Verifier by construction, the deterministic declassification seam,
 and the worked email-exfiltration demo.
 
+[0.6.0]: https://github.com/gianlucamazza/reasoning-kernel/releases/tag/v0.6.0
+[0.6.0rc1]: https://github.com/gianlucamazza/reasoning-kernel/releases/tag/v0.6.0rc1
+[0.5.0]: https://github.com/gianlucamazza/reasoning-kernel/releases/tag/v0.5.0
 [0.5.0rc2]: https://github.com/gianlucamazza/reasoning-kernel/releases/tag/v0.5.0rc2
 [0.5.0rc1]: https://github.com/gianlucamazza/reasoning-kernel/releases/tag/v0.5.0rc1
 [0.4.2]: https://github.com/gianlucamazza/reasoning-kernel/releases/tag/v0.4.2

{capability_reasoning_kernel-0.5.0rc2 → capability_reasoning_kernel-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: capability-reasoning-kernel
-Version: 0.5.0rc2
+Version: 0.6.0
 Summary: Reference implementation of the Reasoning Kernel pattern (strong / CaMeL-like form)
 Project-URL: Homepage, https://github.com/gianlucamazza/reasoning-kernel
 Project-URL: Repository, https://github.com/gianlucamazza/reasoning-kernel
@@ -105,7 +105,7 @@ The trusted, deterministic kernel is the **interpreter + capability/provenance g
 Reasoner providers: Anthropic, OpenAI, Deepseek (OpenAI-compatible, reusing the `openai` SDK via a
 `base_url` — no separate dependency), plus a deterministic `FakeProvider` for key-free tests — all
 behind one interface (`reasoner/base.py`). Configured providers can be exercised through the same
-live contract (`just test-live`). The 0.5 release workflow requires DeepSeek qualification; OpenAI
+live contract (`just test-live`). The release workflow requires DeepSeek qualification; OpenAI
 and Anthropic remain independently contract-tested unless a release explicitly qualifies them live.
 
 ## No effect bypasses the Verifier — by construction
@@ -157,13 +157,35 @@ pre-commit) and how to configure provider keys. Release notes are in
 
 Install: `pip install capability-reasoning-kernel` — it **imports as** `import reasoning_kernel`
 (the PyPI name differs because `reasoning-kernel` was taken by an unrelated project).
-Install the operational candidate explicitly with
-`pip install capability-reasoning-kernel==0.5.0rc2`.
+Install the conformance release explicitly with
+`pip install capability-reasoning-kernel==0.6.0`.
 
 For operational embedding, use `RunSession` with a persistent sink and bounded defaults; see
 [operations and migration](docs/OPERATIONS.md) and the [conformance checklist](docs/CONFORMANCE.md).
-It isolates each run, records partial effects and refuses automatic replay. The 0.5 line is a
-published pre-release; package publication is not evidence of validated host integration.
+It isolates each run, records partial effects and refuses automatic replay. Package publication and
+consumer compatibility tests are not evidence that a host's live adapters are correctly configured.
+
+### Executable host conformance
+
+Version 0.6 adds fixed `gate-v1` and `operational-v1` profiles for turning host tests into sanitized,
+repeatable evidence. `gate-v1` covers hosts that use the verifier as a pre-pipeline checkpoint;
+`operational-v1` covers complete `RunSession` integrations. Run the key-free operational reference:
+
+```bash
+reasoning-kernel-conformance \
+  reasoning_kernel.conformance.reference:reference_suite \
+  --output conformance.json
+```
+
+An application supplies a trusted zero-argument factory returning `ConformanceSuite` for one profile.
+Each required `ScenarioKind` runs in isolation and returns a `ConformanceObservation` containing the
+decision or kernel result and counts observed in the external test world. Expectations are fixed by
+the profile: applications cannot redefine a denial as success. Exit `0` means every case passed; `1` means a failure or
+inconclusive case; `2` means an invalid suite or runner, or an error while loading the factory, running
+the suite, serializing the report, or writing `--output`. Reports contain only version metadata,
+scenario/check identifiers and outcomes—never prompts, payloads, paths or raw provider errors.
+
+See [the conformance guide](docs/CONFORMANCE.md) for the required cases and host factory contract.
 
 Explicit low-level wiring remains available. The package root re-exports the building blocks. Sketch (see
 [`demo/email_exfil.py`](src/reasoning_kernel/demo/email_exfil.py) for a complete, runnable version):

{capability_reasoning_kernel-0.5.0rc2 → capability_reasoning_kernel-0.6.0}/README.md

@@ -66,7 +66,7 @@ The trusted, deterministic kernel is the **interpreter + capability/provenance g
 Reasoner providers: Anthropic, OpenAI, Deepseek (OpenAI-compatible, reusing the `openai` SDK via a
 `base_url` — no separate dependency), plus a deterministic `FakeProvider` for key-free tests — all
 behind one interface (`reasoner/base.py`). Configured providers can be exercised through the same
-live contract (`just test-live`). The 0.5 release workflow requires DeepSeek qualification; OpenAI
+live contract (`just test-live`). The release workflow requires DeepSeek qualification; OpenAI
 and Anthropic remain independently contract-tested unless a release explicitly qualifies them live.
 
 ## No effect bypasses the Verifier — by construction
@@ -118,13 +118,35 @@ pre-commit) and how to configure provider keys. Release notes are in
 
 Install: `pip install capability-reasoning-kernel` — it **imports as** `import reasoning_kernel`
 (the PyPI name differs because `reasoning-kernel` was taken by an unrelated project).
-Install the operational candidate explicitly with
-`pip install capability-reasoning-kernel==0.5.0rc2`.
+Install the conformance release explicitly with
+`pip install capability-reasoning-kernel==0.6.0`.
 
 For operational embedding, use `RunSession` with a persistent sink and bounded defaults; see
 [operations and migration](docs/OPERATIONS.md) and the [conformance checklist](docs/CONFORMANCE.md).
-It isolates each run, records partial effects and refuses automatic replay. The 0.5 line is a
-published pre-release; package publication is not evidence of validated host integration.
+It isolates each run, records partial effects and refuses automatic replay. Package publication and
+consumer compatibility tests are not evidence that a host's live adapters are correctly configured.
+
+### Executable host conformance
+
+Version 0.6 adds fixed `gate-v1` and `operational-v1` profiles for turning host tests into sanitized,
+repeatable evidence. `gate-v1` covers hosts that use the verifier as a pre-pipeline checkpoint;
+`operational-v1` covers complete `RunSession` integrations. Run the key-free operational reference:
+
+```bash
+reasoning-kernel-conformance \
+  reasoning_kernel.conformance.reference:reference_suite \
+  --output conformance.json
+```
+
+An application supplies a trusted zero-argument factory returning `ConformanceSuite` for one profile.
+Each required `ScenarioKind` runs in isolation and returns a `ConformanceObservation` containing the
+decision or kernel result and counts observed in the external test world. Expectations are fixed by
+the profile: applications cannot redefine a denial as success. Exit `0` means every case passed; `1` means a failure or
+inconclusive case; `2` means an invalid suite or runner, or an error while loading the factory, running
+the suite, serializing the report, or writing `--output`. Reports contain only version metadata,
+scenario/check identifiers and outcomes—never prompts, payloads, paths or raw provider errors.
+
+See [the conformance guide](docs/CONFORMANCE.md) for the required cases and host factory contract.
 
 Explicit low-level wiring remains available. The package root re-exports the building blocks. Sketch (see
 [`demo/email_exfil.py`](src/reasoning_kernel/demo/email_exfil.py) for a complete, runnable version):

{capability_reasoning_kernel-0.5.0rc2 → capability_reasoning_kernel-0.6.0}/SECURITY.md

@@ -38,9 +38,11 @@ permissive policy written on top of it.
 
 | Version | Supported |
 |---------|-----------|
+| `0.6.x` | ✅; validate host adapters before application use |
+| `0.6.0rc1` | Superseded candidate; upgrade to `0.6.0` |
+| `0.5.x` | ✅; validate host adapters before application use |
 | `0.4.x` | ✅ |
-| `0.5.0rc2` | Current candidate; report issues, validate adapters before application use |
-| `0.5.0rc1` | Superseded candidate; upgrade to the current candidate |
+| `0.5.0rc1`, `0.5.0rc2` | Superseded candidates; upgrade to `0.5.0` |
 | `< 0.4` | ❌ |
 
 ## Reporting a vulnerability

capability_reasoning_kernel-0.6.0/docs/CONFORMANCE.md

@@ -0,0 +1,93 @@
+# Conformance and operational acceptance
+
+Conformance establishes mediation points. Policy correctness and host configuration are separate
+requirements; an allow-all policy can conform without useful confidentiality protection.
+
+| Requirement | Test evidence |
+|---|---|
+| Every model input is assembled by the host/kernel | `test_invariant_a`, `test_subject_provenance` |
+| Each callable invocation has its own preceding Gate authorization | `test_no_bypass_conformance`, `test_operational` |
+| Parsing, merging and delegation cannot launder provenance | `test_provenance_propagation`, `test_merge`, `test_subkernel` |
+| Delegated authority never exceeds its parent | `test_composition`, `test_subkernel`, `test_operational` |
+| Egress READs receive provenance checks | `test_operational` |
+| Normalized checked values are the executed values | `test_operational` |
+| Contexts/budgets are isolated between roots and shared within a tree | `test_operational` |
+| Failure stops later work and preserves partial-effect evidence | `test_operational`, `test_reasoner_robustness` |
+| Storage failure before start prevents the callable | `test_operational` |
+| Process crashes leave durable evidence; reopening cannot replay | `test_operational` |
+| Provider refusal, truncation and fallback errors are terminal | `test_provider_contracts` |
+
+Reproduce these scenarios against application policies and wiring, including tools returning invalid
+output or raising after an effect. Validators and policies are trusted code and must not perform I/O.
+Supplying an external model authorizes data transfer; quarantining it does not make that transfer private.
+
+Before application use, verify identity mapping, destination restrictions, adapter provenance, egress
+declarations, finite adapter timeouts, shared-client thread safety, audit access/retention and operator
+reconciliation. Exercise clean and injected input with the chosen providers. Record local, CI,
+published-artifact and live-adapter evidence separately.
+
+Conformance does not include rollback, exactly-once external effects, automatic recovery, tamper-proof
+storage, a Python security sandbox or correctness of arbitrary declassification policies.
+
+## Executable profiles
+
+The `reasoning_kernel.conformance` package turns the requirements above into fixed host acceptance
+profiles. Use `gate-v1` when the host embeds the verifier as a pre-pipeline checkpoint but does not
+use `RunSession`; use `operational-v1` for the complete operational runtime. A suite selects one
+profile and must provide each of its `ScenarioKind` values exactly once.
+
+### `gate-v1`
+
+| Scenario | Required evidence |
+|---|---|
+| `gate_authorized` | An authorized proposal is allowed, not enforcement-skipped, and audited |
+| `gate_capability_denied` | Missing capability is denied, enforcement-skipped, audited, and launches nothing |
+| `gate_tainted_egress_denied` | Tainted egress is denied, enforcement-skipped, audited, and launches nothing |
+| `gate_internal_error_denied` | An internal mapping error fails closed, is audited, and launches nothing |
+
+### `operational-v1`
+
+| Scenario | Required evidence |
+|---|---|
+| `benign_effect` | An authorized effect succeeds and is externally observable |
+| `injected_control` | Injected content cannot redirect control or the authorized destination |
+| `injected_egress` | An attempted tainted exfiltration is blocked with no unauthorized effect |
+| `capability_denied` | Missing authority blocks the WRITE before its callable |
+| `invalid_output` | Invalid adapter output is recorded and later effects do not run |
+| `tool_failure_before_effect` | The outcome is uncertain, no effect is observed and execution stops |
+| `tool_failure_after_effect` | The effect is observed but remains uncertain and execution stops |
+| `audit_failure_before_dispatch` | Failure to persist the start prevents the callable |
+| `crash_reopen_no_replay` | The incomplete root is discoverable and its ID cannot be reused |
+
+The host factory is trusted Python code and must return a `ConformanceSuite`. Operational scenario
+callables build fresh `RunSession` instances and test worlds. Gate scenarios exercise the host's real
+checkpoint in enforcement mode. Both return `ConformanceObservation`. `authorized_effects`,
+`unauthorized_effects` and `subsequent_effects` count externally visible WRITE effects, not READ calls
+or trace records. The host must observe the destination system or a faithful test double; the kernel
+cannot infer an external commit from its own log.
+The suite name is a 1–64 character identifier containing only letters, digits, `.`, `_` or `-`; it
+must not contain a customer name, path or other operational data.
+
+```python
+from reasoning_kernel.conformance import ConformanceScenario, ConformanceSuite, ScenarioKind
+
+def build_suite() -> ConformanceSuite:
+    return ConformanceSuite(
+        name="my-agent",
+        profile="operational-v1",
+        scenarios=(
+            ConformanceScenario(ScenarioKind.BENIGN_EFFECT, run_benign),
+            # ...exactly one callable for every operational-v1 ScenarioKind...
+        ),
+    )
+```
+
+Run `reasoning-kernel-conformance my_agent.conformance:build_suite --output conformance.json`.
+The JSON schema is versioned independently from the profile. A report is deliberately payload-free
+and is evidence from trusted host observers, not a signed attestation. Passing it does not establish
+production identity mapping, credentials, network policy, retention or live-adapter correctness.
+
+In CI, install an exact package version, run the command above and retain `conformance.json` as an
+artifact only after the command exits successfully. Inspect `cases[].outcome` and `cases[].checks`:
+`fail` means observed evidence violated a fixed expectation, while `inconclusive` means the scenario
+could not produce trustworthy evidence. Neither is a pass and there is no permissive CLI override.

{capability_reasoning_kernel-0.5.0rc2 → capability_reasoning_kernel-0.6.0}/docs/DEVELOPMENT.md

@@ -19,6 +19,7 @@ Python 3.12+ is required. The default suite needs no API keys: it runs against t
 |--------------------|--------------------------------------------------------------------------|
 | `just check`       | `lint` + `typecheck` + `test` — everything CI runs, in one command        |
 | `just demo`        | Worked demo (FakeProvider): legit send commits; injection inert; exfil blocked |
+| `just conformance` | Complete key-free `operational-v1` reference profile                    |
 | `just demo-subkernel` | §5.4 composition demo: untrusted content delegated at a reduced grant  |
 | `just demo-limits` | Termination demo: `RunLimits` aborts the run closed before the second effect |
 | `just demo-reasoner-error` | Fail-closed demo: a failing reasoner commits nothing (`plan_rejected`) |
@@ -48,11 +49,15 @@ Python 3.12+ is required. The default suite needs no API keys: it runs against t
 CI (`.github/workflows/ci.yml`) runs lint, typecheck, and the covered test suite on a Python
 3.12 + 3.13 + 3.14 matrix on push / PR and on release tags via a reusable workflow.
 `just package-check` validates wheel/sdist metadata and an isolated wheel install. The live job runs
-manually and when a release calls the reusable workflow with required providers. The 0.5 release
+manually and when a release calls the reusable workflow with required providers. The release
 workflow requires DeepSeek before package build or publication. Release notes live in
 [`CHANGELOG.md`](../CHANGELOG.md);
 security reporting and scope in [`SECURITY.md`](../SECURITY.md).
 
+The conformance CLI is included in wheel smoke testing. It imports a trusted host factory, executes
+the selected fixed profile and returns a non-zero status for failures, inconclusive evidence or invalid suite
+configuration; it never calls a live provider on its own.
+
 The pyright configuration selects `.venv` explicitly, avoiding accidental system-Python imports.
 Operational contracts and migration are in [OPERATIONS.md](OPERATIONS.md); the integration
 acceptance checklist is in [CONFORMANCE.md](CONFORMANCE.md). Provider refusal/truncation handling

{capability_reasoning_kernel-0.5.0rc2 → capability_reasoning_kernel-0.6.0}/docs/OPERATIONS.md

@@ -1,4 +1,4 @@
-# Operational embedding and migration (0.5 candidate)
+# Operational embedding and migration (0.5)
 
 `RunSession` is the bounded, single-use entry point. The host supplies authenticated identity, a
 trusted query, a fixed grant, deterministic policy, schemas and adapters. Authentication, scheduling,
@@ -147,3 +147,7 @@ providers must pass on the tagged commit before the package is built. It then bu
 hashes, publishes to TestPyPI, verifies served bytes, promotes those artifacts to PyPI and verifies
 the public bytes again. OIDC publishers/environments must be configured. Provider qualification is
 still distinct from host-adapter acceptance.
+
+Use the executable `operational-v1` profile in [CONFORMANCE.md](CONFORMANCE.md) to standardize host
+tests and CI evidence. A passing report demonstrates the supplied scenarios and observers only; it
+does not replace a controlled live-adapter UAT.

{capability_reasoning_kernel-0.5.0rc2 → capability_reasoning_kernel-0.6.0}/docs/index.html

@@ -435,6 +435,11 @@
         <span class="mod">memory/trace.py</span>
         <p>An append-only record of decisions and invocations. Operational sessions persist authorization and start before calling a tool. Missing completion after a crash means an uncertain effect requiring reconciliation.</p>
       </div>
+      <div class="role">
+        <div class="head"><span class="name">Conformance kit</span><span class="trust t">trusted</span></div>
+        <span class="mod">conformance/</span>
+        <p>A fixed operational profile turns host scenarios and external observations into a sanitized CI report. Expectations belong to the profile, not to the host being tested.</p>
+      </div>
     </div>
   </div>
 </section>
@@ -662,7 +667,7 @@ result = kernel.run(ctx)             <span class="c"># committed is None if it f
   <div class="wrap">
     <p class="eyebrow">Get started</p>
     <h2>Read it, fork it, conform to it</h2>
-    <p class="lede">It is a reference implementation and spec — a vetted skeleton, not a turn-key product. Install it, run the worked demo, or conform your own agent to the pattern.</p>
+    <p class="lede">It is a reference implementation and spec — a vetted skeleton, not a turn-key product. Install it, run the worked demo, then execute the versioned conformance profile against your own host.</p>
     <div class="cta">
       <div class="install">
         <span class="dollar">$</span>

{capability_reasoning_kernel-0.5.0rc2 → capability_reasoning_kernel-0.6.0}/justfile

@@ -35,6 +35,10 @@ test-live:
 demo:
     uv run python -m reasoning_kernel.demo.email_exfil
 
+# run the complete key-free operational conformance profile
+conformance:
+    uv run reasoning-kernel-conformance reasoning_kernel.conformance.reference:reference_suite
+
 # run the demo end-to-end against a REAL provider (needs a key in .env)
 demo-live:
     uv run python -m reasoning_kernel.demo.live_run

{capability_reasoning_kernel-0.5.0rc2 → capability_reasoning_kernel-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "capability-reasoning-kernel"
-version = "0.5.0rc2"
+version = "0.6.0"
 description = "Reference implementation of the Reasoning Kernel pattern (strong / CaMeL-like form)"
 authors = [{ name = "Gianluca Mazza — Venere Labs" }]
 license = { text = "MIT" }
@@ -46,6 +46,7 @@ dev = ["pytest>=8.0", "pytest-cov>=5.0", "ruff>=0.9", "pyright>=1.1.380", "twine
 
 [project.scripts]
 reasoning-kernel-demo = "reasoning_kernel.demo.email_exfil:main"
+reasoning-kernel-conformance = "reasoning_kernel.conformance.cli:entrypoint"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/reasoning_kernel"]
@@ -64,6 +65,7 @@ venv = ".venv"
 include = ["src/reasoning_kernel"]
 pythonVersion = "3.12"
 strict = [
+  "src/reasoning_kernel/conformance", # executable host acceptance contract
   "src/reasoning_kernel/schemas", # contract layer
   "src/reasoning_kernel/kernel",  # the trusted core: interpreter, gate, dispatcher, taint
   "src/reasoning_kernel/memory",  # trusted core: ValueStore (tainted-value custody) + TraceWriter

{capability_reasoning_kernel-0.5.0rc2 → capability_reasoning_kernel-0.6.0}/scripts/check_artifacts.py

@@ -39,7 +39,17 @@ def main() -> None:
             check=True,
             stdout=subprocess.DEVNULL,
         )
-    print("Wheel import, public API and deterministic demo passed in an isolated environment.")
+        subprocess.run(
+            [
+                str(python.parent / "reasoning-kernel-conformance"),
+                "reasoning_kernel.conformance.reference:reference_suite",
+            ],
+            cwd=directory,
+            env=env,
+            check=True,
+            stdout=subprocess.DEVNULL,
+        )
+    print("Wheel import, demo and conformance CLI passed in an isolated environment.")
 
 
 if __name__ == "__main__":

capability_reasoning_kernel-0.6.0/src/reasoning_kernel/conformance/__init__.py

@@ -0,0 +1,31 @@
+"""Executable, versioned evidence that a host preserves the kernel's contracts."""
+
+from reasoning_kernel.conformance.models import (
+    GATE_V1_KINDS,
+    OPERATIONAL_V1_KINDS,
+    ConformanceCaseResult,
+    ConformanceObservation,
+    ConformanceProfile,
+    ConformanceReport,
+    ConformanceScenario,
+    ConformanceSuite,
+    ScenarioKind,
+)
+from reasoning_kernel.conformance.runner import (
+    ConformanceConfigurationError,
+    run_conformance,
+)
+
+__all__ = [
+    "GATE_V1_KINDS",
+    "OPERATIONAL_V1_KINDS",
+    "ConformanceCaseResult",
+    "ConformanceConfigurationError",
+    "ConformanceObservation",
+    "ConformanceProfile",
+    "ConformanceReport",
+    "ConformanceScenario",
+    "ConformanceSuite",
+    "ScenarioKind",
+    "run_conformance",
+]

capability_reasoning_kernel-0.6.0/src/reasoning_kernel/conformance/cli.py

@@ -0,0 +1,54 @@
+"""Command-line entry point for host conformance suites."""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import sys
+from collections.abc import Callable, Sequence
+from pathlib import Path
+
+from reasoning_kernel.conformance.models import ConformanceSuite
+from reasoning_kernel.conformance.runner import ConformanceConfigurationError, run_conformance
+
+
+def _load_factory(reference: str) -> Callable[[], object]:
+    module_name, separator, attribute = reference.partition(":")
+    if not separator or not module_name or not attribute:
+        raise ConformanceConfigurationError("factory must use module:attribute syntax")
+    factory = getattr(importlib.import_module(module_name), attribute)
+    if not callable(factory):
+        raise ConformanceConfigurationError("factory is not callable")
+    return factory
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Run Reasoning Kernel host conformance")
+    parser.add_argument("factory", help="trusted host suite factory as module:attribute")
+    parser.add_argument("--output", type=Path, help="write the sanitized JSON report to this path")
+    args = parser.parse_args(argv)
+
+    try:
+        candidate = _load_factory(args.factory)()
+        if not isinstance(candidate, ConformanceSuite):
+            raise ConformanceConfigurationError("factory did not return ConformanceSuite")
+        report = run_conformance(candidate)
+        rendered = report.model_dump_json(indent=2) + "\n"
+        if args.output is None:
+            sys.stdout.write(rendered)
+        else:
+            args.output.write_text(rendered, encoding="utf-8")
+            outcome = "PASS" if report.passed else "FAIL"
+            print(f"{outcome} {report.profile} ({len(report.cases)} cases)")
+        return 0 if report.passed else 1
+    except Exception:
+        print("conformance configuration or runner error", file=sys.stderr)
+        return 2
+
+
+def entrypoint() -> None:
+    raise SystemExit(main())
+
+
+if __name__ == "__main__":
+    entrypoint()

capability_reasoning_kernel-0.6.0/src/reasoning_kernel/conformance/models.py

@@ -0,0 +1,103 @@
+"""Public contracts for executable host conformance evidence."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from reasoning_kernel.schemas.trace import RunResult
+
+ConformanceProfile = Literal["gate-v1", "operational-v1"]
+
+
+class ScenarioKind(StrEnum):
+    """Required cases in the versioned conformance profiles."""
+
+    BENIGN_EFFECT = "benign_effect"
+    INJECTED_CONTROL = "injected_control"
+    INJECTED_EGRESS = "injected_egress"
+    CAPABILITY_DENIED = "capability_denied"
+    INVALID_OUTPUT = "invalid_output"
+    TOOL_FAILURE_BEFORE_EFFECT = "tool_failure_before_effect"
+    TOOL_FAILURE_AFTER_EFFECT = "tool_failure_after_effect"
+    AUDIT_FAILURE_BEFORE_DISPATCH = "audit_failure_before_dispatch"
+    CRASH_REOPEN_NO_REPLAY = "crash_reopen_no_replay"
+    GATE_AUTHORIZED = "gate_authorized"
+    GATE_CAPABILITY_DENIED = "gate_capability_denied"
+    GATE_TAINTED_EGRESS_DENIED = "gate_tainted_egress_denied"
+    GATE_INTERNAL_ERROR_DENIED = "gate_internal_error_denied"
+
+
+OPERATIONAL_V1_KINDS = tuple(kind for kind in ScenarioKind if not kind.value.startswith("gate_"))
+GATE_V1_KINDS = tuple(kind for kind in ScenarioKind if kind.value.startswith("gate_"))
+
+
+@dataclass(frozen=True, slots=True)
+class ConformanceObservation:
+    """Evidence returned by trusted host code for one isolated scenario.
+
+    Effect counts cover externally visible WRITE effects, not READ calls. The
+    kernel deliberately cannot infer external state from its own trace.
+    """
+
+    result: RunResult | None = None
+    authorized_effects: int = 0
+    unauthorized_effects: int = 0
+    subsequent_effects: int = 0
+    replay_refused: bool | None = None
+    incomplete_discovered: bool | None = None
+    decision_allowed: bool | None = None
+    decision_enforced: bool | None = None
+    audit_recorded: bool | None = None
+
+    def __post_init__(self) -> None:
+        if min(self.authorized_effects, self.unauthorized_effects, self.subsequent_effects) < 0:
+            raise ValueError("effect counts cannot be negative")
+
+
+@dataclass(frozen=True, slots=True)
+class ConformanceScenario:
+    """A required scenario and the trusted host factory that executes it."""
+
+    kind: ScenarioKind
+    run: Callable[[], ConformanceObservation]
+
+
+@dataclass(frozen=True, slots=True)
+class ConformanceSuite:
+    """One host target implementing exactly one complete versioned profile."""
+
+    name: str
+    scenarios: tuple[ConformanceScenario, ...]
+    profile: ConformanceProfile = "operational-v1"
+
+    def __post_init__(self) -> None:
+        if re.fullmatch(r"[A-Za-z0-9._-]{1,64}", self.name) is None:
+            raise ValueError("suite name must be a safe identifier")
+
+
+class ConformanceCaseResult(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    kind: ScenarioKind
+    outcome: Literal["pass", "fail", "inconclusive"]
+    checks: list[str] = Field(default_factory=list)
+
+
+class ConformanceReport(BaseModel):
+    """Payload-free, machine-readable result of one conformance run."""
+
+    model_config = ConfigDict(frozen=True)
+
+    schema_version: Literal[1] = 1
+    profile: ConformanceProfile
+    suite: str
+    package_version: str
+    python_version: str
+    passed: bool
+    cases: list[ConformanceCaseResult]