Release AKTA v0.8.1

CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to AKTA are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.8.0] - 2026-06-29
+
+### Added
+
+- `akta-review-cli` mode requires AKTA record before subprocess (`--akta-record`); fails closed with clear error
+- First-class `04_scope_review_summary.json` artifact in reconstructable demo; PCS bundle includes `scope_review_summary.json`
+- Fixture-driven SCOPE narrowing: `tests/fixtures/scope_scope_order.json`, `scope_valid_narrowing.json`
+- Makefile targets: `demo-reconstructable-cross-repo`, `verify-reconstructable-cross-repo`
+- Tests: `test_akta_review_requires_record.py`, `test_reconstructable_summary_artifact.py`, `test_scope_narrowing_fixture.py`
+
+### Changed
+
+- `validate_approval_grant()` uses fixture narrowing pairs instead of hard-coded `active_protocol_update` → `protocol_draft` only
+- Reconstructable demo artifact numbering 00–12 with `10_pcs_bundle/`; cross-repo output at `dist/reconstructable_cross_repo/`
+- `reconstruction_report.md` cites `summary.json` contract and checks assurance levels and tool lists
+- `ScopeAdapterResult` includes `summary` for all adapter modes
+
 ## [0.7.1] - 2026-06-28
 
 ### Added

Makefile

@@ -1,4 +1,4 @@
-.PHONY: install test eval-canonical eval-public eval-public-100 eval-oracle eval-holdout eval-v06 demo-weak-evidence demo-akta-weak-evidence demo-akta-scope-protocol-drift demo-reconstructable ci
+.PHONY: install test eval-canonical eval-public eval-public-100 eval-oracle eval-holdout eval-v06 demo-weak-evidence demo-akta-weak-evidence demo-akta-scope-protocol-drift demo-reconstructable demo-reconstructable-cross-repo verify-reconstructable-cross-repo ci
 
 PYTHON ?= python
 
@@ -26,6 +26,13 @@ eval-v06:
 demo-reconstructable:
 	$(PYTHON) scripts/demo_reconstructable_experiment.py
 
+demo-reconstructable-cross-repo:
+	$(PYTHON) -c "import os,sys; ok=bool(os.environ.get('SCOPE_REPO_PATH') or os.environ.get('SCOPE_CLI')); (print('Set SCOPE_REPO_PATH or SCOPE_CLI for live SCOPE') if not ok else None); sys.exit(0 if ok else 1)"
+	$(PYTHON) scripts/demo_reconstructable_experiment.py --cross-repo
+
+verify-reconstructable-cross-repo:
+	$(PYTHON) scripts/verify_reconstructable_cross_repo.py
+
 demo-weak-evidence:
 	$(PYTHON) scripts/demo_weak_evidence.py
 

README.md

@@ -135,7 +135,7 @@ REST API, MCP server, and batch evaluation are available for integrators — see
 | **PF-Core** | Runtime proof obligations tied to admissibility decisions | [PF-Core bridge](docs/pf_core_bridge.md) |
 | **PCS** | Packages decisions, records, and hashes for release verification | [PCS export](docs/pcs_export.md) |
 
-SCOPE connects in several modes — offline simulation (default), Python import from a sibling checkout, subprocess CLI, or a one-shot review command. Details and conformance checks: [scope_live_conformance.md](docs/scope_live_conformance.md).
+SCOPE connects in several modes — offline simulation (default), Python import from a sibling checkout, subprocess CLI, or a one-shot review command (`scope akta review` requires both AKTA trigger and record). Reconstructable cross-repo demo: `make demo-reconstructable-cross-repo` then `make verify-reconstructable-cross-repo`. Details: [scope_live_conformance.md](docs/scope_live_conformance.md).
 
 Cross-repo environment variables for optional CI jobs: [.github/CROSS_REPO_CI.md](.github/CROSS_REPO_CI.md).
 
@@ -200,7 +200,7 @@ Read [CONTRIBUTING.md](CONTRIBUTING.md) for pull-request expectations, [GOVERNAN
 
 ## Project status
 
-**v0.7.1** (`akta-protocol`) is the current reference kernel. It implements the full admissibility loop — gate, record, review triggers, grant re-gating, PF export, and PCS packaging — with 385+ tests and a green `make ci` suite. Biology, chemistry, and clinical domain overlays are experimental and not deployment-ready without institutional governance. Fully autonomous scientific operator profiles are defined for taxonomy only and are not supported at runtime. AKTA is a reference implementation under the MIT license, not a safety certification. Known gaps and non-goals: [docs/limitations.md](docs/limitations.md).
+**v0.8.0** (`akta-protocol`) is the current reference kernel. Biology, chemistry, and clinical domain overlays are experimental and not deployment-ready without institutional governance. Fully autonomous scientific operator profiles are defined for taxonomy only and are not supported at runtime. AKTA is a reference implementation under the MIT license, not a safety certification. Known gaps and non-goals: [docs/limitations.md](docs/limitations.md).
 
 ---
 

adapters/pcs/export_artifact.py

@@ -31,6 +31,7 @@ def build_pcs_manifest(
     *,
     file_hashes: dict[str, str] | None = None,
     include_review_trigger: bool = False,
+    include_scope_summary: bool = False,
     include_scope_packet: bool = False,
     include_scope_decision: bool = False,
     include_scope_grant: bool = False,
@@ -42,6 +43,8 @@ def build_pcs_manifest(
     files = list(CORE_FILES)
     if include_review_trigger:
         files.append("review_trigger.json")
+    if include_scope_summary:
+        files.append("scope_review_summary.json")
     if include_scope_packet:
         files.append("scope_review_packet.json")
     if include_scope_decision:
@@ -107,6 +110,7 @@ def validate_pcs_bundle(bundle_dir: str | Path) -> None:
         json.loads((bundle_dir / "akta_decision.json").read_text(encoding="utf-8")),
         file_hashes=file_hashes,
         include_review_trigger=(bundle_dir / "review_trigger.json").exists(),
+        include_scope_summary=(bundle_dir / "scope_review_summary.json").exists(),
         include_scope_packet=(bundle_dir / "scope_review_packet.json").exists(),
         include_scope_decision=(bundle_dir / "scope_decision.json").exists(),
         include_scope_grant=(bundle_dir / "scope_grant.json").exists(),
@@ -122,6 +126,7 @@ def export_pcs_bundle(
     out_dir: str | Path,
     *,
     decision: dict[str, Any] | None = None,
+    scope_review_summary: dict[str, Any] | None = None,
     scope_review_packet: dict[str, Any] | None = None,
     scope_decision: dict[str, Any] | None = None,
     scope_grant: dict[str, Any] | None = None,
@@ -190,6 +195,10 @@ def _write(name: str, content: str) -> None:
     if review_trigger:
         _write("review_trigger.json", json.dumps(review_trigger, indent=2))
 
+    has_scope_summary = scope_review_summary is not None
+    if scope_review_summary is not None:
+        _write("scope_review_summary.json", json.dumps(scope_review_summary, indent=2))
+
     has_scope_packet = scope_review_packet is not None
     if scope_review_packet is not None:
         _write("scope_review_packet.json", json.dumps(scope_review_packet, indent=2))
@@ -220,6 +229,7 @@ def _write(name: str, content: str) -> None:
         decision_payload,
         file_hashes=artifacts,
         include_review_trigger=has_review_trigger,
+        include_scope_summary=has_scope_summary,
         include_scope_packet=has_scope_packet,
         include_scope_decision=has_scope_decision,
         include_scope_grant=has_scope_grant,

adapters/scope/client.py

@@ -37,6 +37,7 @@ class ScopeAdapterResult:
     review_packet: dict[str, Any] | None = None
     grant: dict[str, Any] | None = None
     decision: dict[str, Any] | None = None
+    summary: dict[str, Any] | None = None
     error: str | None = None
 
 
@@ -176,7 +177,7 @@ def _decision_input_for_grant(granted: str, trigger: dict[str, Any]) -> dict[str
     requested = trigger.get("requested_scope", "protocol_draft")
     if granted == requested:
         return {
-            "type": "approve_scope",
+            "type": "approve",
             "approved_scope": granted,
             "rationale": "Approved at requested scope.",
         }
@@ -255,6 +256,13 @@ def _python_import_scope(
         review_packet=packet,
         grant=grant,
         decision=decision,
+        summary=_synthesize_scope_summary(
+            adapter_mode=ADAPTER_MODE_PYTHON_IMPORT,
+            trigger=trigger,
+            packet=packet,
+            decision=decision,
+            grant=grant,
+        ),
     )
 
 
@@ -296,12 +304,51 @@ def _validate_akta_review_summary(summary: dict[str, Any]) -> None:
     validate_against_schema(summary, "scope_akta_review_summary.schema.json")
 
 
+def _synthesize_scope_summary(
+    *,
+    adapter_mode: str,
+    trigger: dict[str, Any],
+    packet: dict[str, Any],
+    decision: dict[str, Any],
+    grant: dict[str, Any],
+) -> dict[str, Any]:
+    """Build summary.json-compatible contract for non-akta-review adapter modes."""
+    auth = grant.get("authorization") or {}
+    approved = auth.get("approved_scope") or grant.get("granted_scope") or ""
+    requested = (
+        grant.get("requested_scope")
+        or (grant.get("source") or {}).get("requested_scope")
+        or trigger.get("requested_scope")
+        or ""
+    )
+    return {
+        "status": "completed",
+        "approved_scope": approved,
+        "requested_scope": requested,
+        "allowed_tools": list(auth.get("allowed_tools") or grant.get("allowed_tools") or []),
+        "blocked_tools": list(auth.get("blocked_tools") or grant.get("blocked_tools") or []),
+        "adapter_contract_version": "scope-akta-review-v0.8",
+        "identity_assurance_level": "IAL0",
+        "signing_assurance_level": "SAL1",
+        "adapter_mode": adapter_mode,
+        "packet_id": packet.get("packet_id"),
+        "decision_id": decision.get("decision_id"),
+        "grant_id": grant.get("grant_id"),
+    }
+
+
 def _akta_review_cli_scope(
     trigger: dict[str, Any],
     record: dict[str, Any] | None,
     granted: str,
     reviewer_id: str,
 ) -> ScopeAdapterResult:
+    if record is None:
+        return ScopeAdapterResult(
+            adapter_mode=ADAPTER_MODE_AKTA_REVIEW_CLI,
+            error="SCOPE akta-review CLI mode requires an AKTA record.",
+        )
+
     cli = os.environ.get("SCOPE_CLI", "scope")
     with tempfile.TemporaryDirectory(prefix="akta-scope-akta-review-") as tmp:
         tmp_path = Path(tmp)
@@ -388,6 +435,7 @@ def _akta_review_cli_scope(
         review_packet=packet,
         grant=grant,
         decision=decision,
+        summary=summary,
     )
 
 
@@ -492,6 +540,13 @@ def _cli_scope(
         review_packet=packet,
         grant=grant,
         decision=decision,
+        summary=_synthesize_scope_summary(
+            adapter_mode=ADAPTER_MODE_CLI,
+            trigger=trigger,
+            packet=packet,
+            decision=decision,
+            grant=grant,
+        ),
     )
 
 
@@ -532,6 +587,13 @@ def _simulated_scope(
         review_packet=packet,
         grant=grant,
         decision=decision,
+        summary=_synthesize_scope_summary(
+            adapter_mode=ADAPTER_MODE_SIMULATED,
+            trigger=trigger,
+            packet=packet,
+            decision=decision,
+            grant=grant,
+        ),
     )
 
 

akta/review_loop.py

@@ -17,38 +17,49 @@
     enforce_grant_expiry,
     is_review_expired,
 )
-from akta.scope_contract import _scope_grant_approved_scope, _scope_grant_requested_scope
+from akta.scope_contract import (
+    _scope_grant_approved_scope,
+    _scope_grant_requested_scope,
+    is_valid_narrowing_grant,
+    scope_rank,
+)
 from akta.scope_mapping import VALID_REQUESTED_SCOPES
 
 SCOPE_RANK_ORDER: dict[str, int] = {
-    "protocol_draft": 1,
-    "active_protocol_update": 2,
-    "single_validation_plan": 3,
-    "single_validation_run_draft": 3,
-    "single_run_queue_priority": 4,
-    "robot_queue_submission": 5,
-    "execution_payload_preparation": 5,
-    "publication_claim": 6,
-    "scientific_memory_import": 4,
-    "draft_only": 0,
+    scope: scope_rank(scope)
+    for scope in (
+        "protocol_draft",
+        "active_protocol_update",
+        "single_validation_plan",
+        "single_validation_run_draft",
+        "single_run_queue_priority",
+        "robot_queue_submission",
+        "execution_payload_preparation",
+        "publication_claim",
+        "scientific_memory_import",
+        "draft_only",
+    )
 }
 
 
+def _scope_rank(scope: str) -> int:
+    try:
+        return scope_rank(scope)
+    except FileNotFoundError:
+        return SCOPE_RANK_ORDER.get(scope, 99)
+
+
 def _evidence_rank(evidence_state: str) -> int:
     if evidence_state.startswith("E") and len(evidence_state) > 1 and evidence_state[1].isdigit():
         return int(evidence_state[1])
     return 0
 
 
-def _scope_rank(scope: str) -> int:
-    return SCOPE_RANK_ORDER.get(scope, 99)
-
-
 def grant_scope_covers_action(granted_scope: str, requested_scope: str) -> bool:
     """Return True when granted scope covers the requested scope (narrow grants only)."""
     if granted_scope == requested_scope:
         return True
-    if requested_scope == "active_protocol_update" and granted_scope == "protocol_draft":
+    if is_valid_narrowing_grant(granted_scope=granted_scope, requested_scope=requested_scope):
         return True
     return _scope_rank(granted_scope) >= _scope_rank(requested_scope)