responsibility-pathway-runtime 0.1.0a2__py3-none-any.whl

responsibility_pathway_runtime-0.1.0a2.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,65 @@
+responsibility_pathway_runtime-0.1.0a2.dist-info/licenses/LICENSE,sha256=LOorZGMvZRrYKJ7_pFyNmfvOz0GxAVHDX_S_l3wxuPM,1068
+rpr/__init__.py,sha256=RwGPcjeqfWFUj55KhaxOCRuEu8Im9INhstTGOYyQqS0,2981
+rpr/_generated_transitions.py,sha256=76Ndlgntg1rzibkBOLWFQy6w5k0YBFsJPqgIao0jR_4,1697
+rpr/agent_adapters.py,sha256=bo-M_uCHEa0go0nh2jzw49wJrv3JMyJVsKiHzlUsWVU,3500
+rpr/assurance_manifest.py,sha256=GB3FCNws4lqRgPje5kDb0IwRR52oyODqPBkRjWw7PeE,8700
+rpr/attempts.py,sha256=KVIau_IerQr5Z1KexeouV3FDV0Fa9eGHgfP0lGmklIA,16080
+rpr/authority.py,sha256=g2fCHOO0lN-3lNlL4iOj5JZCQ_o12JMIUItvYOQr590,3932
+rpr/backup.py,sha256=2Dr6ZWaxlczxHN8MnA78VenM3RlPC3eEwOcyQiLCwFw,4359
+rpr/candidate_readiness.py,sha256=x2Ze789xJ-rgTIXCb4fZjg8KUJxhiAxJ1bl-LlSMltY,3657
+rpr/canonical_transition_spec.py,sha256=hypwigmluciw4OxQrDVwC6zbintodr3scS1bDpNYZ5k,2984
+rpr/claim_traceability.py,sha256=PySi0oF5GbGfHPaIiEj0MsJ_IiS-pG3cgcdIWYGR8tg,6761
+rpr/clean_export.py,sha256=gJXqN_Aem2qBkXMJEbTMtczPhMLD7wN0Jngppq4gyRU,4683
+rpr/cli.py,sha256=N3H0Mh8tdaYToo6x57w3m4nuONVpMiUjrMqtNXKaiAA,863
+rpr/compensation.py,sha256=zer6PUVXOv5jIDhUIZIHft3aR5hXRGkamn4GGSUNRl4,1243
+rpr/customer_handover.py,sha256=6Ob7zBbTZKYIzx2hMsWfgTbTBnvKEaa_9Fp0YgwkEp0,9072
+rpr/delivery_acceptance.py,sha256=xcjXNQlbfg6dICMF6dkbN5pPMl_6k5e4r6kCh9gcBbE,5166
+rpr/delivery_acceptance_baseline.py,sha256=-UV3Kqu8eeF-jS_bF0_GqCW3AQUZPbcxaXHfCL7zjIk,2730
+rpr/dependency_inventory.py,sha256=gFJ58jgjoXUNV-WyPiosx4JBXGXZl0kjTGw5Z-Givvw,2676
+rpr/diagnostics.py,sha256=eh4PhXoiW-bXO6x_7Y56chErxKdqMUWXcpMfV3__7HI,4027
+rpr/epistemic_claims.py,sha256=a_bQO8QchO9XGsB6fqTsCKiC_I__OW6HWLsUTSplB-U,7840
+rpr/evidence.py,sha256=3JD6cwuzquBS1khY1dbZTJD8AWbMJFrNU7SfoIfvT3E,2423
+rpr/executor.py,sha256=KnpJfJ72l8DAwFestEcv5YtckHSujRTYQAt2S4nGBAk,4468
+rpr/formal_consistency.py,sha256=LeXzJ85_ccoZXpbTYXLKYkOkRTUu0QTqa1T575GNOcc,4810
+rpr/hash_bundle.py,sha256=T6G8G9ZVuofEL4AX8ac9OibUyMuIzz-t50BcHW9nu8c,1721
+rpr/http_executor.py,sha256=LUpCM81pLorr85l1XJfqHHXn-mUP4vnrv8Oa4OQZciM,7237
+rpr/identity.py,sha256=3t069R-MLc_qPf3pQbbQJ_WzKOIcWozeOfQz4wZPBeQ,4469
+rpr/inspection.py,sha256=liHt9YvdMVCyP4w5Ba659F8Wsk115qIjB-nLrDZlv7c,3390
+rpr/integration_acceptance_inventory.py,sha256=A3UOhB8WFNyBC3IKzkbeaNZOKYfArAJy4Cs-Q_mvifY,3824
+rpr/launch_claims.py,sha256=-uwm9TJR1U4NlchM-L3gw0xCEJ_wT-LZ-mM0jjjLRTk,1875
+rpr/lifecycle_acceptance.py,sha256=O565Bd0NXNsPiusT8f_NRYYs1Ne_kGB2alMd7Y-Sz4o,12575
+rpr/mcp_admission.py,sha256=lDK-xViedg8vh79ugl8ctVJ1kevPfR80qWiL8_HqNqM,10551
+rpr/mcp_compatibility.py,sha256=m2c0MQJ67K3PkRUq-m62tS3gT1cXdgD_3O46IvVsQn8,5174
+rpr/mcp_jsonrpc_session.py,sha256=IoE-56uYeTt62KBiWcG6AW-IafGn0m4U8FatvueUQ8o,5627
+rpr/mcp_local_subprocess_stdio.py,sha256=VGjzkMz3UHIsH7kJRlKdqhZpDFe0hSa6ULYYU-IxZHo,8373
+rpr/mcp_retained_evidence.py,sha256=Orvkexedbt3ifOAojbv91h8ioSr89-p8FS_iwCzxf04,6989
+rpr/mcp_stable_snapshot.py,sha256=6Mk-5CYAUFGAv7yd5M9kUCZsfeo2Yl0Ey87noxhHBAA,5502
+rpr/mcp_stable_transport.py,sha256=HOGQeVP2ckysRxlKnu6qLPka6T2WMK8UuygKwc8H-8Y,4872
+rpr/mcp_stdio_channel.py,sha256=wpqSmIbAkwRYiiMjMjXCsuYp3Ee69wqfCuAsvdf4lhY,5376
+rpr/mcp_stdio_framing.py,sha256=aKScCDcvArJAhA5NLC16_uzo39TsUxfiYIf3_gcizCM,6400
+rpr/mcp_subprocess_lifecycle.py,sha256=flm3TrNeLz4x-HV52-ZHJKTozEHOh81zo9K4ktp7teM,5238
+rpr/mcp_tool_executor.py,sha256=XbjU3A71HqF0WQojPvIKIVur5I4QrLo7uJgNLL9xgJI,7315
+rpr/message_executor.py,sha256=7YLfSXkqmvPcq3WQ8oq0SLFBVwCt_lG5S1wC5OcwObs,7580
+rpr/models.py,sha256=G8kTSyla5t1HWmKjBMWxg_AJ_7rtDYsi2wjSSb4WblA,3556
+rpr/principal.py,sha256=1lOT8Ym2FcW7INRJqHfbKTwWSxHXX86HMiVaqhYEphw,1607
+rpr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rpr/rc_execution.py,sha256=YO3Mj_wO79QW5W_HtbBhuPQr4ahW29ndqHSeHRP3lE4,8634
+rpr/read_only_connection.py,sha256=XgBKOvCibFQtNJ97M8A6dJOw0Rcs4IiPg4AovoNEqpE,4401
+rpr/reconciliation.py,sha256=deou6YeGqaXVKiQisvlb6bL5sFzcFwRSemvM6M0qwGY,2292
+rpr/redaction.py,sha256=Pdq48eprlyxb9BvHVnwmXn9jeJ5BXdUEAPo9xO_Udvw,1916
+rpr/release_audit.py,sha256=enbOK5pfcNfUa2YbhL-38J6TIDGM4J3-SX06pJCzAs8,4344
+rpr/release_gate.py,sha256=Gd219MNz2BrAIAybTyoCpYK-PsES46MByUlmcC1lfl0,2335
+rpr/repair.py,sha256=Z1vW1FOZ-RUBa7hUMC7CrjZcp_qiqMTn4Ua7Ai2TliM,6749
+rpr/rpe.py,sha256=qOY8uql_ZWrJXwvYqKZGKRsRhE_exZY6i7C_GL_EHZ0,5145
+rpr/runtime.py,sha256=zk5Dh_D9hdka_Sc87G4zTiEOOPUdEYz6ODOOJE79hEo,21880
+rpr/sbom.py,sha256=Dj-zjO7be1v2CNJ1_KBhoxFyNlinkr3oUxHgEXjAl8w,2764
+rpr/security_review.py,sha256=JXGSoUauhz-Z-NDDd-RJrjwroCwcBQM_PNO440rPcnI,2616
+rpr/source_context.py,sha256=0leXTlorPZXVFGKjyDEpgnTiynMYU7tlEyr8h1AsDoU,3112
+rpr/state_machine.py,sha256=ulnlef4AC3dpxsSEq8ueXWT_VusyVkwLl6v8TXn3VCA,483
+rpr/storage.py,sha256=nw_1ON27XUNqGUKlSXHZ3PByudjBr5uyjkOv5W4F1Jw,9693
+rpr/tenant.py,sha256=LevzR8eipmRe0NNDQi1feD0Tk2zbRBzxX5lQ51C15VM,6242
+responsibility_pathway_runtime-0.1.0a2.dist-info/METADATA,sha256=c00NvzEtcV00UJkCkLmWfuKB3ufXpZWKZkFb_yOmFsY,6538
+responsibility_pathway_runtime-0.1.0a2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+responsibility_pathway_runtime-0.1.0a2.dist-info/entry_points.txt,sha256=Rtm2BOb2RUFT7LRVK3ADREGxPELseAz_dRxMPplULhU,37
+responsibility_pathway_runtime-0.1.0a2.dist-info/top_level.txt,sha256=-MpVZCITUsm3s5OxjrfOYmnLAMxTal0N1KewaSYPJrU,4
+responsibility_pathway_runtime-0.1.0a2.dist-info/RECORD,,

responsibility_pathway_runtime-0.1.0a2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

responsibility_pathway_runtime-0.1.0a2.dist-info/entry_points.txt

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

responsibility_pathway_runtime-0.1.0a2.dist-info/licenses/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.dist-info/top_level.txt

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

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",
+]

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})

rpr/agent_adapters.py

@@ -0,0 +1,88 @@
+# Copyright (c) 2026 Akihisa Ono
+# SPDX-License-Identifier: MIT
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any, Callable, Mapping
+
+from .executor import ExecutionRequest, Executor
+from .runtime import ResponsibilityPathwayRuntime
+
+
+@dataclass(frozen=True)
+class AgentToolCall:
+    tool_name: str
+    arguments: Mapping[str, Any]
+    call_id: str
+
+
+@dataclass(frozen=True)
+class AgentToolOutcome:
+    allowed: bool
+    pathway_id: str
+    state: str
+    output: Mapping[str, Any]
+    reason: str | None = None
+
+
+class RprToolBoundary:
+    """Framework-neutral boundary used by concrete agent-framework adapters."""
+
+    def __init__(self, runtime: ResponsibilityPathwayRuntime, executor_for: Callable[[str], Executor]) -> None:
+        self.runtime = runtime
+        self.executor_for = executor_for
+
+    def invoke(self, *, pathway_id: str, actor: str, call: AgentToolCall) -> AgentToolOutcome:
+        request = ExecutionRequest(
+            operation_id=call.call_id,
+            attempt_id=call.call_id,
+            idempotency_key=call.call_id,
+            action=call.tool_name,
+            parameters=dict(call.arguments),
+        )
+        result = self.runtime.execute(pathway_id, request, actor=actor, executor=self.executor_for(call.tool_name))
+        state = self.runtime.store.get_state(pathway_id).value
+        return AgentToolOutcome(
+            allowed=result.status.value == "succeeded",
+            pathway_id=pathway_id,
+            state=state,
+            output={
+                "status": result.status.value,
+                "evidence": dict(result.evidence),
+                "readback": None if result.readback is None else {
+                    "verified": result.readback.verified,
+                    "observed": dict(result.readback.observed),
+                    "reason": result.readback.reason,
+                },
+            },
+            reason=result.reason,
+        )
+
+
+def openai_function_tool_handler(boundary: RprToolBoundary, *, pathway_id: str, actor: str, tool_name: str) -> Callable[[str], str]:
+    """Return a dependency-free handler suitable for wrapping with Agents SDK `function_tool`.
+
+    RPR does not import the SDK. The application wraps this callable and may attach SDK tool
+    guardrails. Hosted and built-in tools require a different integration boundary.
+    """
+
+    def handler(arguments_json: str) -> str:
+        arguments = json.loads(arguments_json)
+        call_id = str(arguments.pop("_rpr_call_id"))
+        outcome = boundary.invoke(pathway_id=pathway_id, actor=actor, call=AgentToolCall(tool_name, arguments, call_id))
+        return json.dumps(outcome.output | {"pathway_id": outcome.pathway_id, "state": outcome.state, "reason": outcome.reason}, ensure_ascii=False)
+
+    return handler
+
+
+def langgraph_tool_node(boundary: RprToolBoundary, *, pathway_id: str, actor: str, tool_name: str) -> Callable[[Mapping[str, Any]], Mapping[str, Any]]:
+    """Return a node callable usable from a LangGraph `StateGraph` or tool wrapper."""
+
+    def node(state: Mapping[str, Any]) -> Mapping[str, Any]:
+        call_id = str(state["call_id"])
+        arguments = dict(state.get("arguments", {}))
+        outcome = boundary.invoke(pathway_id=pathway_id, actor=actor, call=AgentToolCall(tool_name, arguments, call_id))
+        return dict(state) | {"rpr": {"allowed": outcome.allowed, "state": outcome.state, "output": dict(outcome.output), "reason": outcome.reason}}
+
+    return node

rpr/assurance_manifest.py

@@ -0,0 +1,195 @@
+# Copyright (c) 2026 Akihisa Ono
+# SPDX-License-Identifier: MIT
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Mapping
+
+
+class AssuranceManifestError(ValueError):
+    """The assurance manifest is malformed or exceeds its declared boundary."""
+
+
+_ALLOWED_STATUSES = {
+    "not_implemented",
+    "implemented_unverified",
+    "passing",
+    "failing",
+    "deferred",
+    "out_of_scope",
+}
+_EVIDENCE_ORDER = {f"E{level}": level for level in range(6)}
+_REQUIRED_HUMAN_GATES = {
+    "repository_publicization",
+    "pages_publication",
+    "package_release",
+    "tag_or_github_release",
+    "external_or_live_mcp_connection",
+    "credential_use",
+    "license_change",
+    "claim_escalation_to_e4_or_e5",
+}
+_REQUIRED_NOT_PERMITTED = {
+    "full formal verification",
+    "legal or regulatory compliance",
+    "arbitrary third-party MCP compatibility",
+    "live external MCP interoperability",
+    "distributed correctness",
+    "production readiness",
+    "signed non-repudiation",
+    "release-complete declaration without authorization",
+}
+_REQUIRED_CLAIM_FIELDS = {
+    "claim_id",
+    "status",
+    "evidence_level",
+    "statement",
+    "implementation_anchors",
+    "test_anchors",
+    "retained_evidence",
+    "residual_owner",
+    "blocked_by",
+    "residual_risks",
+}
+
+
+def load_assurance_manifest(path: str | Path, *, root: str | Path | None = None) -> dict[str, Any]:
+    manifest_path = Path(path)
+    try:
+        payload = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise AssuranceManifestError(f"manifest_load_failed: {type(exc).__name__}: {exc}") from exc
+    validate_assurance_manifest(payload, root=manifest_path.parent.parent if root is None else root)
+    return payload
+
+
+def validate_assurance_manifest(payload: Any, *, root: str | Path | None = None) -> None:
+    if not isinstance(payload, Mapping):
+        raise AssuranceManifestError("manifest_must_be_object")
+    if payload.get("schema_version") != 1:
+        raise AssuranceManifestError("unsupported_schema_version")
+    if payload.get("product") != "Responsibility Pathway Runtime":
+        raise AssuranceManifestError("unexpected_product")
+    if payload.get("canonical_source") != "YutoriKomeiji/responsibility-pathway-runtime":
+        raise AssuranceManifestError("unexpected_canonical_source")
+    if payload.get("release_boundary") != "public_alpha_candidate":
+        raise AssuranceManifestError("release_boundary_must_be_public_alpha_candidate")
+
+    human_gates = _string_set(payload.get("human_gate_required_for"), "human_gate_required_for")
+    missing_gates = _REQUIRED_HUMAN_GATES - human_gates
+    if missing_gates:
+        raise AssuranceManifestError(f"missing_human_gates: {sorted(missing_gates)!r}")
+
+    maximum = payload.get("maximum_current_evidence_level")
+    if maximum not in _EVIDENCE_ORDER:
+        raise AssuranceManifestError("invalid_maximum_current_evidence_level")
+    if _EVIDENCE_ORDER[maximum] > _EVIDENCE_ORDER["E3"]:
+        raise AssuranceManifestError("evidence_level_escalation_requires_human_gate")
+
+    boundary = payload.get("global_claim_boundary")
+    if not isinstance(boundary, Mapping):
+        raise AssuranceManifestError("global_claim_boundary_must_be_object")
+    permitted = boundary.get("permitted")
+    if not isinstance(permitted, str) or not permitted.strip():
+        raise AssuranceManifestError("global_permitted_wording_required")
+    not_permitted = _string_set(payload.get("global_claim_boundary", {}).get("not_permitted"), "global_claim_boundary.not_permitted")
+    missing_prohibitions = _REQUIRED_NOT_PERMITTED - not_permitted
+    if missing_prohibitions:
+        raise AssuranceManifestError(f"missing_claim_prohibitions: {sorted(missing_prohibitions)!r}")
+
+    source_documents = _string_list(payload.get("source_documents"), "source_documents", allow_empty=False)
+    claims = payload.get("claims")
+    if not isinstance(claims, list) or not claims:
+        raise AssuranceManifestError("claims_must_be_non_empty_list")
+
+    claim_ids: set[str] = set()
+    for index, claim in enumerate(claims):
+        _validate_claim(claim, index=index, maximum=maximum, claim_ids=claim_ids)
+
+    if root is not None:
+        root_path = Path(root)
+        for relative in source_documents:
+            _require_relative_file(root_path, relative, "source_document")
+        for claim in claims:
+            for relative in claim["implementation_anchors"]:
+                _require_relative_file(root_path, relative, f"implementation_anchor:{claim['claim_id']}")
+            for relative in claim["test_anchors"]:
+                _require_relative_file(root_path, relative, f"test_anchor:{claim['claim_id']}")
+
+
+def _validate_claim(claim: Any, *, index: int, maximum: str, claim_ids: set[str]) -> None:
+    if not isinstance(claim, Mapping):
+        raise AssuranceManifestError(f"claim_{index}_must_be_object")
+    missing = _REQUIRED_CLAIM_FIELDS - set(claim)
+    if missing:
+        raise AssuranceManifestError(f"claim_{index}_missing_fields: {sorted(missing)!r}")
+
+    claim_id = claim.get("claim_id")
+    if not isinstance(claim_id, str) or not claim_id.strip():
+        raise AssuranceManifestError(f"claim_{index}_invalid_id")
+    if claim_id in claim_ids:
+        raise AssuranceManifestError(f"duplicate_claim_id: {claim_id}")
+    claim_ids.add(claim_id)
+
+    status = claim.get("status")
+    if status not in _ALLOWED_STATUSES:
+        raise AssuranceManifestError(f"claim_{claim_id}_invalid_status")
+    evidence_level = claim.get("evidence_level")
+    if evidence_level not in _EVIDENCE_ORDER:
+        raise AssuranceManifestError(f"claim_{claim_id}_invalid_evidence_level")
+    if _EVIDENCE_ORDER[evidence_level] > _EVIDENCE_ORDER[maximum]:
+        raise AssuranceManifestError(f"claim_{claim_id}_exceeds_manifest_maximum")
+    if status == "passing" and _EVIDENCE_ORDER[evidence_level] < _EVIDENCE_ORDER["E2"]:
+        raise AssuranceManifestError(f"claim_{claim_id}_passing_without_sufficient_evidence")
+
+    statement = claim.get("statement")
+    if not isinstance(statement, str) or not statement.strip():
+        raise AssuranceManifestError(f"claim_{claim_id}_statement_required")
+    owner = claim.get("residual_owner")
+    if not isinstance(owner, str) or not owner.strip():
+        raise AssuranceManifestError(f"claim_{claim_id}_residual_owner_required")
+
+    implementation = _string_list(claim.get("implementation_anchors"), f"claim_{claim_id}.implementation_anchors", allow_empty=False)
+    tests = _string_list(claim.get("test_anchors"), f"claim_{claim_id}.test_anchors", allow_empty=True)
+    _string_list(claim.get("retained_evidence"), f"claim_{claim_id}.retained_evidence", allow_empty=True)
+    blocked_by = _string_list(claim.get("blocked_by"), f"claim_{claim_id}.blocked_by", allow_empty=True)
+    risks = _string_list(claim.get("residual_risks"), f"claim_{claim_id}.residual_risks", allow_empty=False)
+
+    if status == "passing" and not tests:
+        raise AssuranceManifestError(f"claim_{claim_id}_passing_without_test_anchor")
+    if status == "implemented_unverified" and not blocked_by:
+        raise AssuranceManifestError(f"claim_{claim_id}_unverified_without_blocker")
+    if not implementation or not risks:
+        raise AssuranceManifestError(f"claim_{claim_id}_missing_assurance_boundary")
+
+
+def _string_list(value: Any, field: str, *, allow_empty: bool) -> list[str]:
+    if not isinstance(value, list):
+        raise AssuranceManifestError(f"{field}_must_be_list")
+    if not allow_empty and not value:
+        raise AssuranceManifestError(f"{field}_must_not_be_empty")
+    result: list[str] = []
+    for item in value:
+        if not isinstance(item, str) or not item.strip():
+            raise AssuranceManifestError(f"{field}_contains_invalid_string")
+        result.append(item)
+    if len(result) != len(set(result)):
+        raise AssuranceManifestError(f"{field}_contains_duplicates")
+    return result
+
+
+def _string_set(value: Any, field: str) -> set[str]:
+    return set(_string_list(value, field, allow_empty=False))
+
+
+def _require_relative_file(root: Path, relative: str, field: str) -> None:
+    candidate = Path(relative)
+    if candidate.is_absolute() or ".." in candidate.parts:
+        raise AssuranceManifestError(f"{field}_must_be_relative")
+    resolved = (root / candidate).resolve()
+    root_resolved = root.resolve()
+    if root_resolved != resolved and root_resolved not in resolved.parents:
+        raise AssuranceManifestError(f"{field}_escapes_root")
+    if not resolved.is_file():
+        raise AssuranceManifestError(f"{field}_missing: {relative}")