responsibility-pathway-runtime 0.1.0a2__tar.gz

responsibility_pathway_runtime-0.1.0a2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Akihisa Ono
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

responsibility_pathway_runtime-0.1.0a2/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: responsibility-pathway-runtime
+Version: 0.1.0a2
+Summary: A responsibility-pathway runtime for AI agent actions
+Author: Akihisa Ono
+License-Expression: MIT
+Project-URL: Homepage, https://yutorikomeiji.github.io/responsibility-pathway-runtime/
+Project-URL: Documentation, https://yutorikomeiji.github.io/responsibility-pathway-runtime/
+Project-URL: Repository, https://github.com/YutoriKomeiji/responsibility-pathway-runtime
+Project-URL: Issues, https://github.com/YutoriKomeiji/responsibility-pathway-runtime/issues
+Project-URL: Demo, https://yutorikomeiji.github.io/responsibility-pathway-runtime/demo.html
+Keywords: ai-agents,governance,responsibility,human-in-the-loop,runtime
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Responsibility Pathway Runtime
+
+**Govern external actions without losing evidence, recovery, or the human decision point.**
+
+Responsibility Pathway Runtime (RPR) is an MIT-licensed Python runtime for applications that need to place an explicit responsibility pathway in front of consequential external actions. It helps a host application preserve actor and authority declarations, execution-attempt continuity, readback evidence, fail-closed ambiguity handling, repair routes, and Human Gate decisions.
+
+> **Public alpha source and live demo — 0.1.0a2**  
+> Freeze ID: `RPR-CF-2026-08-02-01`  
+> Tested final rehearsal profile: Linux, Python 3.11  
+> The repository, product site, and browser demo are public. A final tag, GitHub Release, and package-registry distribution have not yet been published.  
+> RPR is not a legal-responsibility engine, identity provider, secret manager, production gateway, or guarantee of exactly-once effects across arbitrary remote systems.
+
+[Product site](https://yutorikomeiji.github.io/responsibility-pathway-runtime/) · [Live browser demo](https://yutorikomeiji.github.io/responsibility-pathway-runtime/demo.html) · [日本語の入口](docs/ja/README.md) · [Quick Start](docs/en/quick-start.md) · [Product documentation](docs/en/README.md) · [Report an issue](https://github.com/YutoriKomeiji/responsibility-pathway-runtime/issues)
+
+## Why RPR
+
+AI agents and automation can execute faster than people can reconstruct what happened. RPR provides a bounded runtime layer where an integrating application can:
+
+- declare actors, authority, and the proposed action;
+- evaluate and retain an explicit pathway state;
+- bind operations, attempts, and idempotency identity;
+- require independent readback before completion;
+- stop ambiguous writes as `write_status_unknown` instead of false success;
+- retain Human Gate, repair, resume, reconciliation, and evidence continuity;
+- survive restart without silently repeating unresolved effects.
+
+## Verified in the frozen alpha candidate
+
+- pathway registration and authorized state transitions;
+- persistent pathway and execution-attempt stores;
+- Human Gate, repair, resume, and reconciliation boundaries;
+- local-file, allow-listed HTTP, durable outbound-message, and real MCP subprocess paths;
+- HTTP and MCP fault injection;
+- crash/restart continuity and duplicate-dispatch prevention;
+- backup, restore, diagnostics, uninstall, package/CLI residue checks, and customer-data retention;
+- clean wheel and source-distribution installation;
+- two independent byte-for-byte reproducible builds;
+- English-primary and Japanese-parallel product documentation;
+- Lean 4 verification of selected published state-machine invariants;
+- Chromium and Pyodide execution of the CI-built RPR wheel in the public browser demo.
+
+## We need field-test reports for
+
+RPR is public so real users can report reproducible environment and integration findings. Please open an Issue for:
+
+- Windows, macOS, other Linux distributions, containers, and Python environments beyond the final Linux/Python 3.11 rehearsal;
+- proxy, TLS, enterprise identity, credential handling, remote MCP, and service-specific connectivity;
+- framework, agent, CI/CD, RPA, batch, and application integrations;
+- installation, upgrade, backup/restore, removal, and operational usability;
+- confusing states, missing examples, documentation gaps, and unsupported assumptions.
+
+A user report is field evidence for that environment. It does not imply universal production readiness.
+
+## Quick Start
+
+Until a package-registry distribution or GitHub Release is published, install from the public repository in a disposable environment:
+
+```bash
+git clone https://github.com/YutoriKomeiji/responsibility-pathway-runtime.git
+cd responsibility-pathway-runtime
+python3.11 -m venv .venv
+. .venv/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+rpr --help
+```
+
+To inspect the runtime without installing it locally, use the [live browser demo](https://yutorikomeiji.github.io/responsibility-pathway-runtime/demo.html). The demo runs the CI-built RPR wheel in Pyodide with SQLite; only the external payment provider is simulated.
+
+The verified candidate artifact hashes are recorded in [`release-evidence/replacement-freeze-2026-08-02.json`](release-evidence/replacement-freeze-2026-08-02.json). Those candidate artifacts are not yet a general package distribution.
+
+## Integration boundary
+
+The host application remains responsible for authentication, credential isolation, network controls, bypass prevention, domain-specific authorization, and the independent readback source. RPE integration is optional; RPE absence, malformed output, or unsupported results must not become implicit permission.
+
+## Documentation
+
+- [Product, scope, and architecture](docs/en/product-scope-architecture.md)
+- [Installation, operations, and recovery](docs/en/install-operations-recovery.md)
+- [Security, limitations, integration, and API](docs/en/security-integration-api.md)
+- [Verification, known issues, release notes, and UAT](docs/en/verification-release-uat.md)
+- [Support and field testing](SUPPORT.md)
+- [Security reporting](SECURITY.md)
+- [Contributing](CONTRIBUTING.md)
+
+## License
+
+RPR is released under the [MIT License](LICENSE). Copyright © 2026 Akihisa Ono.

responsibility_pathway_runtime-0.1.0a2/README.md

@@ -0,0 +1,88 @@
+# Responsibility Pathway Runtime
+
+**Govern external actions without losing evidence, recovery, or the human decision point.**
+
+Responsibility Pathway Runtime (RPR) is an MIT-licensed Python runtime for applications that need to place an explicit responsibility pathway in front of consequential external actions. It helps a host application preserve actor and authority declarations, execution-attempt continuity, readback evidence, fail-closed ambiguity handling, repair routes, and Human Gate decisions.
+
+> **Public alpha source and live demo — 0.1.0a2**  
+> Freeze ID: `RPR-CF-2026-08-02-01`  
+> Tested final rehearsal profile: Linux, Python 3.11  
+> The repository, product site, and browser demo are public. A final tag, GitHub Release, and package-registry distribution have not yet been published.  
+> RPR is not a legal-responsibility engine, identity provider, secret manager, production gateway, or guarantee of exactly-once effects across arbitrary remote systems.
+
+[Product site](https://yutorikomeiji.github.io/responsibility-pathway-runtime/) · [Live browser demo](https://yutorikomeiji.github.io/responsibility-pathway-runtime/demo.html) · [日本語の入口](docs/ja/README.md) · [Quick Start](docs/en/quick-start.md) · [Product documentation](docs/en/README.md) · [Report an issue](https://github.com/YutoriKomeiji/responsibility-pathway-runtime/issues)
+
+## Why RPR
+
+AI agents and automation can execute faster than people can reconstruct what happened. RPR provides a bounded runtime layer where an integrating application can:
+
+- declare actors, authority, and the proposed action;
+- evaluate and retain an explicit pathway state;
+- bind operations, attempts, and idempotency identity;
+- require independent readback before completion;
+- stop ambiguous writes as `write_status_unknown` instead of false success;
+- retain Human Gate, repair, resume, reconciliation, and evidence continuity;
+- survive restart without silently repeating unresolved effects.
+
+## Verified in the frozen alpha candidate
+
+- pathway registration and authorized state transitions;
+- persistent pathway and execution-attempt stores;
+- Human Gate, repair, resume, and reconciliation boundaries;
+- local-file, allow-listed HTTP, durable outbound-message, and real MCP subprocess paths;
+- HTTP and MCP fault injection;
+- crash/restart continuity and duplicate-dispatch prevention;
+- backup, restore, diagnostics, uninstall, package/CLI residue checks, and customer-data retention;
+- clean wheel and source-distribution installation;
+- two independent byte-for-byte reproducible builds;
+- English-primary and Japanese-parallel product documentation;
+- Lean 4 verification of selected published state-machine invariants;
+- Chromium and Pyodide execution of the CI-built RPR wheel in the public browser demo.
+
+## We need field-test reports for
+
+RPR is public so real users can report reproducible environment and integration findings. Please open an Issue for:
+
+- Windows, macOS, other Linux distributions, containers, and Python environments beyond the final Linux/Python 3.11 rehearsal;
+- proxy, TLS, enterprise identity, credential handling, remote MCP, and service-specific connectivity;
+- framework, agent, CI/CD, RPA, batch, and application integrations;
+- installation, upgrade, backup/restore, removal, and operational usability;
+- confusing states, missing examples, documentation gaps, and unsupported assumptions.
+
+A user report is field evidence for that environment. It does not imply universal production readiness.
+
+## Quick Start
+
+Until a package-registry distribution or GitHub Release is published, install from the public repository in a disposable environment:
+
+```bash
+git clone https://github.com/YutoriKomeiji/responsibility-pathway-runtime.git
+cd responsibility-pathway-runtime
+python3.11 -m venv .venv
+. .venv/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+rpr --help
+```
+
+To inspect the runtime without installing it locally, use the [live browser demo](https://yutorikomeiji.github.io/responsibility-pathway-runtime/demo.html). The demo runs the CI-built RPR wheel in Pyodide with SQLite; only the external payment provider is simulated.
+
+The verified candidate artifact hashes are recorded in [`release-evidence/replacement-freeze-2026-08-02.json`](release-evidence/replacement-freeze-2026-08-02.json). Those candidate artifacts are not yet a general package distribution.
+
+## Integration boundary
+
+The host application remains responsible for authentication, credential isolation, network controls, bypass prevention, domain-specific authorization, and the independent readback source. RPE integration is optional; RPE absence, malformed output, or unsupported results must not become implicit permission.
+
+## Documentation
+
+- [Product, scope, and architecture](docs/en/product-scope-architecture.md)
+- [Installation, operations, and recovery](docs/en/install-operations-recovery.md)
+- [Security, limitations, integration, and API](docs/en/security-integration-api.md)
+- [Verification, known issues, release notes, and UAT](docs/en/verification-release-uat.md)
+- [Support and field testing](SUPPORT.md)
+- [Security reporting](SECURITY.md)
+- [Contributing](CONTRIBUTING.md)
+
+## License
+
+RPR is released under the [MIT License](LICENSE). Copyright © 2026 Akihisa Ono.

responsibility_pathway_runtime-0.1.0a2/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "responsibility-pathway-runtime"
+version = "0.1.0a2"
+description = "A responsibility-pathway runtime for AI agent actions"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "Akihisa Ono"}]
+keywords = ["ai-agents", "governance", "responsibility", "human-in-the-loop", "runtime"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Topic :: Software Development :: Quality Assurance",
+  "Typing :: Typed"
+]
+
+[project.urls]
+Homepage = "https://yutorikomeiji.github.io/responsibility-pathway-runtime/"
+Documentation = "https://yutorikomeiji.github.io/responsibility-pathway-runtime/"
+Repository = "https://github.com/YutoriKomeiji/responsibility-pathway-runtime"
+Issues = "https://github.com/YutoriKomeiji/responsibility-pathway-runtime/issues"
+Demo = "https://yutorikomeiji.github.io/responsibility-pathway-runtime/demo.html"
+
+[project.scripts]
+rpr = "rpr.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+rpr = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

responsibility_pathway_runtime-0.1.0a2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

responsibility_pathway_runtime-0.1.0a2/src/responsibility_pathway_runtime.egg-info/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: responsibility-pathway-runtime
+Version: 0.1.0a2
+Summary: A responsibility-pathway runtime for AI agent actions
+Author: Akihisa Ono
+License-Expression: MIT
+Project-URL: Homepage, https://yutorikomeiji.github.io/responsibility-pathway-runtime/
+Project-URL: Documentation, https://yutorikomeiji.github.io/responsibility-pathway-runtime/
+Project-URL: Repository, https://github.com/YutoriKomeiji/responsibility-pathway-runtime
+Project-URL: Issues, https://github.com/YutoriKomeiji/responsibility-pathway-runtime/issues
+Project-URL: Demo, https://yutorikomeiji.github.io/responsibility-pathway-runtime/demo.html
+Keywords: ai-agents,governance,responsibility,human-in-the-loop,runtime
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Responsibility Pathway Runtime
+
+**Govern external actions without losing evidence, recovery, or the human decision point.**
+
+Responsibility Pathway Runtime (RPR) is an MIT-licensed Python runtime for applications that need to place an explicit responsibility pathway in front of consequential external actions. It helps a host application preserve actor and authority declarations, execution-attempt continuity, readback evidence, fail-closed ambiguity handling, repair routes, and Human Gate decisions.
+
+> **Public alpha source and live demo — 0.1.0a2**  
+> Freeze ID: `RPR-CF-2026-08-02-01`  
+> Tested final rehearsal profile: Linux, Python 3.11  
+> The repository, product site, and browser demo are public. A final tag, GitHub Release, and package-registry distribution have not yet been published.  
+> RPR is not a legal-responsibility engine, identity provider, secret manager, production gateway, or guarantee of exactly-once effects across arbitrary remote systems.
+
+[Product site](https://yutorikomeiji.github.io/responsibility-pathway-runtime/) · [Live browser demo](https://yutorikomeiji.github.io/responsibility-pathway-runtime/demo.html) · [日本語の入口](docs/ja/README.md) · [Quick Start](docs/en/quick-start.md) · [Product documentation](docs/en/README.md) · [Report an issue](https://github.com/YutoriKomeiji/responsibility-pathway-runtime/issues)
+
+## Why RPR
+
+AI agents and automation can execute faster than people can reconstruct what happened. RPR provides a bounded runtime layer where an integrating application can:
+
+- declare actors, authority, and the proposed action;
+- evaluate and retain an explicit pathway state;
+- bind operations, attempts, and idempotency identity;
+- require independent readback before completion;
+- stop ambiguous writes as `write_status_unknown` instead of false success;
+- retain Human Gate, repair, resume, reconciliation, and evidence continuity;
+- survive restart without silently repeating unresolved effects.
+
+## Verified in the frozen alpha candidate
+
+- pathway registration and authorized state transitions;
+- persistent pathway and execution-attempt stores;
+- Human Gate, repair, resume, and reconciliation boundaries;
+- local-file, allow-listed HTTP, durable outbound-message, and real MCP subprocess paths;
+- HTTP and MCP fault injection;
+- crash/restart continuity and duplicate-dispatch prevention;
+- backup, restore, diagnostics, uninstall, package/CLI residue checks, and customer-data retention;
+- clean wheel and source-distribution installation;
+- two independent byte-for-byte reproducible builds;
+- English-primary and Japanese-parallel product documentation;
+- Lean 4 verification of selected published state-machine invariants;
+- Chromium and Pyodide execution of the CI-built RPR wheel in the public browser demo.
+
+## We need field-test reports for
+
+RPR is public so real users can report reproducible environment and integration findings. Please open an Issue for:
+
+- Windows, macOS, other Linux distributions, containers, and Python environments beyond the final Linux/Python 3.11 rehearsal;
+- proxy, TLS, enterprise identity, credential handling, remote MCP, and service-specific connectivity;
+- framework, agent, CI/CD, RPA, batch, and application integrations;
+- installation, upgrade, backup/restore, removal, and operational usability;
+- confusing states, missing examples, documentation gaps, and unsupported assumptions.
+
+A user report is field evidence for that environment. It does not imply universal production readiness.
+
+## Quick Start
+
+Until a package-registry distribution or GitHub Release is published, install from the public repository in a disposable environment:
+
+```bash
+git clone https://github.com/YutoriKomeiji/responsibility-pathway-runtime.git
+cd responsibility-pathway-runtime
+python3.11 -m venv .venv
+. .venv/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e .
+rpr --help
+```
+
+To inspect the runtime without installing it locally, use the [live browser demo](https://yutorikomeiji.github.io/responsibility-pathway-runtime/demo.html). The demo runs the CI-built RPR wheel in Pyodide with SQLite; only the external payment provider is simulated.
+
+The verified candidate artifact hashes are recorded in [`release-evidence/replacement-freeze-2026-08-02.json`](release-evidence/replacement-freeze-2026-08-02.json). Those candidate artifacts are not yet a general package distribution.
+
+## Integration boundary
+
+The host application remains responsible for authentication, credential isolation, network controls, bypass prevention, domain-specific authorization, and the independent readback source. RPE integration is optional; RPE absence, malformed output, or unsupported results must not become implicit permission.
+
+## Documentation
+
+- [Product, scope, and architecture](docs/en/product-scope-architecture.md)
+- [Installation, operations, and recovery](docs/en/install-operations-recovery.md)
+- [Security, limitations, integration, and API](docs/en/security-integration-api.md)
+- [Verification, known issues, release notes, and UAT](docs/en/verification-release-uat.md)
+- [Support and field testing](SUPPORT.md)
+- [Security reporting](SECURITY.md)
+- [Contributing](CONTRIBUTING.md)
+
+## License
+
+RPR is released under the [MIT License](LICENSE). Copyright © 2026 Akihisa Ono.

responsibility_pathway_runtime-0.1.0a2/src/responsibility_pathway_runtime.egg-info/SOURCES.txt

@@ -0,0 +1,139 @@
+LICENSE
+README.md
+pyproject.toml
+src/responsibility_pathway_runtime.egg-info/PKG-INFO
+src/responsibility_pathway_runtime.egg-info/SOURCES.txt
+src/responsibility_pathway_runtime.egg-info/dependency_links.txt
+src/responsibility_pathway_runtime.egg-info/entry_points.txt
+src/responsibility_pathway_runtime.egg-info/top_level.txt
+src/rpr/__init__.py
+src/rpr/_generated_transitions.py
+src/rpr/agent_adapters.py
+src/rpr/assurance_manifest.py
+src/rpr/attempts.py
+src/rpr/authority.py
+src/rpr/backup.py
+src/rpr/candidate_readiness.py
+src/rpr/canonical_transition_spec.py
+src/rpr/claim_traceability.py
+src/rpr/clean_export.py
+src/rpr/cli.py
+src/rpr/compensation.py
+src/rpr/customer_handover.py
+src/rpr/delivery_acceptance.py
+src/rpr/delivery_acceptance_baseline.py
+src/rpr/dependency_inventory.py
+src/rpr/diagnostics.py
+src/rpr/epistemic_claims.py
+src/rpr/evidence.py
+src/rpr/executor.py
+src/rpr/formal_consistency.py
+src/rpr/hash_bundle.py
+src/rpr/http_executor.py
+src/rpr/identity.py
+src/rpr/inspection.py
+src/rpr/integration_acceptance_inventory.py
+src/rpr/launch_claims.py
+src/rpr/lifecycle_acceptance.py
+src/rpr/mcp_admission.py
+src/rpr/mcp_compatibility.py
+src/rpr/mcp_jsonrpc_session.py
+src/rpr/mcp_local_subprocess_stdio.py
+src/rpr/mcp_retained_evidence.py
+src/rpr/mcp_stable_snapshot.py
+src/rpr/mcp_stable_transport.py
+src/rpr/mcp_stdio_channel.py
+src/rpr/mcp_stdio_framing.py
+src/rpr/mcp_subprocess_lifecycle.py
+src/rpr/mcp_tool_executor.py
+src/rpr/message_executor.py
+src/rpr/models.py
+src/rpr/principal.py
+src/rpr/py.typed
+src/rpr/rc_execution.py
+src/rpr/read_only_connection.py
+src/rpr/reconciliation.py
+src/rpr/redaction.py
+src/rpr/release_audit.py
+src/rpr/release_gate.py
+src/rpr/repair.py
+src/rpr/rpe.py
+src/rpr/runtime.py
+src/rpr/sbom.py
+src/rpr/security_review.py
+src/rpr/source_context.py
+src/rpr/state_machine.py
+src/rpr/storage.py
+src/rpr/tenant.py
+tests/test_abort_residual_binding.py
+tests/test_assurance_manifest.py
+tests/test_attempt_fingerprint_identity.py
+tests/test_attempt_fingerprint_limits.py
+tests/test_backup_export.py
+tests/test_candidate_readiness.py
+tests/test_candidate_readiness_ci.py
+tests/test_canonical_transition_spec.py
+tests/test_claim_traceability.py
+tests/test_customer_handover.py
+tests/test_delivery_acceptance.py
+tests/test_delivery_acceptance_baseline.py
+tests/test_dependency_inventory.py
+tests/test_epistemic_claims.py
+tests/test_execution_admission.py
+tests/test_execution_boundary.py
+tests/test_fallback_persistence_failure.py
+tests/test_formal_consistency.py
+tests/test_hardening.py
+tests/test_http_and_attempts.py
+tests/test_http_fault_injection_acceptance.py
+tests/test_identity_tenant.py
+tests/test_inspection.py
+tests/test_integration_acceptance_inventory.py
+tests/test_invariant_matrix.py
+tests/test_launch_claims.py
+tests/test_lifecycle_acceptance.py
+tests/test_mcp_admission.py
+tests/test_mcp_compatibility.py
+tests/test_mcp_executor_protocol_boundary.py
+tests/test_mcp_json_limits.py
+tests/test_mcp_jsonrpc_session.py
+tests/test_mcp_local_subprocess_stdio.py
+tests/test_mcp_retained_evidence.py
+tests/test_mcp_runtime_integration.py
+tests/test_mcp_stable_snapshot.py
+tests/test_mcp_stable_transport.py
+tests/test_mcp_stdio_channel.py
+tests/test_mcp_stdio_framing.py
+tests/test_mcp_stdio_stack_e2e.py
+tests/test_mcp_subprocess_fault_injection_acceptance.py
+tests/test_mcp_subprocess_lifecycle.py
+tests/test_mcp_tool_executor.py
+tests/test_message_reconciliation_adapters.py
+tests/test_operational_diagnostics.py
+tests/test_operational_diagnostics_example.py
+tests/test_product_e2e.py
+tests/test_product_e2e_explicit_compensation.py
+tests/test_product_e2e_human_gate_return.py
+tests/test_product_e2e_repair_resume_retry.py
+tests/test_product_e2e_rpe_reconciliation.py
+tests/test_product_e2e_rpe_unavailable_substitution.py
+tests/test_read_only_connection.py
+tests/test_reconciliation_result_persistence.py
+tests/test_release_audit.py
+tests/test_release_gate.py
+tests/test_release_prep_bundle.py
+tests/test_release_security_review.py
+tests/test_repair_attempt_linkage.py
+tests/test_repair_resume_e2e.py
+tests/test_result_persistence_strict_json.py
+tests/test_resume_authorization_restart.py
+tests/test_retry_authorization_rotation.py
+tests/test_running_attempt_binding.py
+tests/test_runtime.py
+tests/test_runtime_reconciliation.py
+tests/test_runtime_restart_finalization_commit.py
+tests/test_runtime_restart_finished_attempt.py
+tests/test_runtime_restart_started_attempt.py
+tests/test_schema_registries.py
+tests/test_schema_version.py
+tests/test_source_context.py

responsibility_pathway_runtime-0.1.0a2/src/responsibility_pathway_runtime.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

responsibility_pathway_runtime-0.1.0a2/src/responsibility_pathway_runtime.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rpr = rpr.cli:main

responsibility_pathway_runtime-0.1.0a2/src/responsibility_pathway_runtime.egg-info/top_level.txt

@@ -0,0 +1 @@
+rpr

responsibility_pathway_runtime-0.1.0a2/src/rpr/__init__.py

@@ -0,0 +1,36 @@
+# Copyright (c) 2026 Akihisa Ono
+# SPDX-License-Identifier: MIT
+"""Responsibility Pathway Runtime public API."""
+
+from .agent_adapters import AgentToolCall, AgentToolOutcome, RprToolBoundary, langgraph_tool_node, openai_function_tool_handler
+from .attempts import AttemptConflictError, ExecutionAttemptRecord, SQLiteExecutionAttemptLedger
+from .authority import AuthorityError
+from .compensation import CompensationPlan, CompensationStatus, NoAutomaticCompensation
+from .executor import ExecutionRequest, ExecutionResult, ExecutionStatus, LocalFileExecutor, ReadbackEvidence
+from .http_executor import HttpMutationExecutor, JsonFieldReadback, ReadbackStrategy
+from .identity import ExternalTokenVerifierResolver, VerifiedClaimsPrincipalResolver, VerifiedTokenClaims
+from .message_executor import DeliveryReceipt, MessageTransport, OutboundMessageExecutor, SQLiteOutbox
+from .models import ActionClass, EnvironmentTrust, PathwayDefinition, PathwayState, RuntimeDecision
+from .principal import Principal, PrincipalError, StaticActorBinding, TrustedPrincipalResolver
+from .reconciliation import ReconciliationResult, ReconciliationStatus, ReconciliationStrategy, reconcile_started_attempt
+from .redaction import EvidenceLimitError, RedactionPolicy
+from .rpe import PythonRpeEvaluator, RestRpeEvaluator, RpeContractError
+from .runtime import EvidenceVerificationResult, RegistrationResult, ResponsibilityPathwayRuntime
+from .source_context import SourceAuthority, SourceContext, SourceContextError
+from .storage import IdempotencyConflictError, SQLiteStore
+from .tenant import SQLiteTenantRegistry, TenantBoundaryError, TenantContext, TenantScopedRuntime
+
+__all__ = [
+    "ActionClass", "AgentToolCall", "AgentToolOutcome", "AttemptConflictError", "AuthorityError",
+    "CompensationPlan", "CompensationStatus", "DeliveryReceipt", "EnvironmentTrust", "EvidenceLimitError",
+    "EvidenceVerificationResult", "ExecutionAttemptRecord", "ExecutionRequest", "ExecutionResult", "ExecutionStatus",
+    "ExternalTokenVerifierResolver", "HttpMutationExecutor", "IdempotencyConflictError", "JsonFieldReadback",
+    "LocalFileExecutor", "MessageTransport", "NoAutomaticCompensation", "OutboundMessageExecutor",
+    "PathwayDefinition", "PathwayState", "Principal", "PrincipalError", "PythonRpeEvaluator", "ReadbackEvidence",
+    "ReadbackStrategy", "ReconciliationResult", "ReconciliationStatus", "ReconciliationStrategy", "RedactionPolicy",
+    "RegistrationResult", "ResponsibilityPathwayRuntime", "RestRpeEvaluator", "RpeContractError", "RprToolBoundary",
+    "RuntimeDecision", "SQLiteExecutionAttemptLedger", "SQLiteOutbox", "SQLiteStore", "SQLiteTenantRegistry",
+    "SourceAuthority", "SourceContext", "SourceContextError", "StaticActorBinding", "TenantBoundaryError",
+    "TenantContext", "TenantScopedRuntime", "TrustedPrincipalResolver", "VerifiedClaimsPrincipalResolver",
+    "VerifiedTokenClaims", "langgraph_tool_node", "openai_function_tool_handler", "reconcile_started_attempt",
+]

responsibility_pathway_runtime-0.1.0a2/src/rpr/_generated_transitions.py

@@ -0,0 +1,25 @@
+# Copyright (c) 2026 Akihisa Ono
+# SPDX-License-Identifier: MIT
+# Generated from specs/pathway-state-machine.json. Do not edit manually.
+from __future__ import annotations
+
+from .models import PathwayState
+
+ALLOWED_TRANSITIONS: dict[PathwayState, frozenset[PathwayState]] = {
+    PathwayState.PROPOSED: frozenset({PathwayState.AWAITING_APPROVAL, PathwayState.APPROVED, PathwayState.DENIED}),
+    PathwayState.AWAITING_APPROVAL: frozenset({PathwayState.APPROVED, PathwayState.DENIED, PathwayState.HUMAN_GATE}),
+    PathwayState.APPROVED: frozenset({PathwayState.RUNNING, PathwayState.HELD, PathwayState.ABORTED}),
+    PathwayState.RUNNING: frozenset({PathwayState.COMPLETED, PathwayState.STOPPED, PathwayState.PARTIALLY_COMPLETED, PathwayState.WRITE_STATUS_UNKNOWN, PathwayState.REPAIR_REQUIRED}),
+    PathwayState.HELD: frozenset({PathwayState.HUMAN_GATE, PathwayState.APPROVED, PathwayState.ABORTED}),
+    PathwayState.HUMAN_GATE: frozenset({PathwayState.APPROVED, PathwayState.DENIED, PathwayState.ABORTED}),
+    PathwayState.STOPPED: frozenset({PathwayState.REPAIR_REQUIRED, PathwayState.ABORTED}),
+    PathwayState.PARTIALLY_COMPLETED: frozenset({PathwayState.REPAIR_REQUIRED}),
+    PathwayState.WRITE_STATUS_UNKNOWN: frozenset({PathwayState.COMPLETED, PathwayState.REPAIR_REQUIRED}),
+    PathwayState.REPAIR_REQUIRED: frozenset({PathwayState.READY_TO_RESUME, PathwayState.ABORTED}),
+    PathwayState.READY_TO_RESUME: frozenset({PathwayState.RUNNING, PathwayState.ABORTED}),
+    PathwayState.COMPLETED: frozenset(),
+    PathwayState.DENIED: frozenset(),
+    PathwayState.ABORTED: frozenset(),
+}
+
+TERMINAL_STATES = frozenset({PathwayState.COMPLETED, PathwayState.DENIED, PathwayState.ABORTED})