From 189c81be1812ee32ffc28148fb63539c66417661 Mon Sep 17 00:00:00 2001 From: Edwin Amirian Date: Mon, 10 Aug 2026 15:06:06 -0700 Subject: [PATCH] feat: prove reviewed impact disposition --- README.md | 21 ++- ROADMAP.md | 7 +- ...-reviewed-impact-disposition-2026-08-10.md | 103 +++++++++++ ...iewed-impact-disposition-work-packet-v1.md | 77 ++++++++ .../test_p2c4_reviewed_impact_disposition.py | 50 ++++++ scripts/p2c3_measured_feedback.py | 19 +- scripts/p2c4_reviewed_impact_disposition.py | 169 ++++++++++++++++++ 7 files changed, 439 insertions(+), 7 deletions(-) create mode 100644 docs/audits/world-intelligence-p2c4-reviewed-impact-disposition-2026-08-10.md create mode 100644 docs/design/world-intelligence-p2c4-reviewed-impact-disposition-work-packet-v1.md create mode 100644 domain_packs/tests/test_p2c4_reviewed_impact_disposition.py create mode 100644 scripts/p2c4_reviewed_impact_disposition.py diff --git a/README.md b/README.md index 3b64648..4cd5c90 100644 --- a/README.md +++ b/README.md @@ -194,6 +194,13 @@ general Brief-quality score, or network-freshness proof. The proposal is not app on the unreleased Core candidate in [PR #88](https://github.com/augmented-cognition-engine/core/pull/88), so World 0.9.0 and its `ace-core>=0.5.0,<0.6` release contract remain unchanged. +P2C4 submits that exact proposal to a separate governed review path. A named, authenticated World +reviewer records `reject` with `no_action`: the bounded `useful` classification and `promote` +proposal remain immutable, and no governed head changes. The rationale rejects broader promotion +because structural coverage does not establish citation correctness, general Brief quality, human +benefit, causality, or live freshness. Exact replay returns the historical Decision without new +authorization. This is explicit disposition, not reclassification or proposal application. + ## What the public World proof demonstrates Generate a self-contained visual Reality Brief and its exact machine-readable backing data: @@ -284,6 +291,9 @@ $PY -m scripts.p2c2_governed_reality_brief "$WORKSPACE" # Candidate measured Outcome -> governed-feedback extension (requires Core PR #88 source) $PY -m scripts.p2c3_measured_feedback "$WORKSPACE" + +# Stacked candidate: explicit reject/no-action review of the exact proposal +$PY -m scripts.p2c4_reviewed_impact_disposition "$WORKSPACE" ``` The released 0.9.0 gates are reproducible through the locked environment, as CI does. The @@ -346,10 +356,13 @@ workspace export followed by separate verification and promotion. The [World Intelligence roadmap](ROADMAP.md) owns current domain direction. Detailed packet history remains in [`docs/world-intelligence-roadmap-status-2026-08-06.md`](docs/world-intelligence-roadmap-status-2026-08-06.md), -and release history is in [`CHANGELOG.md`](CHANGELOG.md). The next bounded work is a separately -reviewed disposition of the P2C3 non-effective proposal plus a separately reviewed opt-in network -transport and P2D multi-source conflict/correction with LIVE inputs. None of these steps may add -autonomous publishing, delivery, persuasion, or action authority to a Domain Pack. +and release history is in [`CHANGELOG.md`](CHANGELOG.md). P2C4 now demonstrates a separately +authorized reject/no-action disposition of the P2C3 proposal without effective state change. The +next bounded measurement work is an independently reviewed product outcome such as citation +correctness, contradiction coverage, correction quality, detection delay, or false-alert rate. +Separately reviewed opt-in network transport and P2D multi-source conflict/correction with LIVE +inputs remain independent work. None of these steps may add autonomous publishing, delivery, +persuasion, or action authority to a Domain Pack. ## Community and security diff --git a/ROADMAP.md b/ROADMAP.md index 90772b8..c674e21 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -16,7 +16,7 @@ source code into the platform. See the [0.9.0 release record](docs/releases/world-intelligence-p2c2-v0.9.0.md). -## Candidate — P2C3 measured feedback over the public journey +## Candidate — P2C3/P2C4 measured feedback and reviewed disposition - The exact 0.9.0 Brief and a World-owned source-only control pass through two matched reviewed export pairs under one frozen structural citation-coverage criterion. @@ -24,10 +24,15 @@ See the [0.9.0 release record](docs/releases/world-intelligence-p2c2-v0.9.0.md). conditions, and cutoff feed the domain-neutral Core + Intelligence measured-impact contract. - The candidate classifies the bounded result as useful and appends only a non-effective, non-selectable promote proposal; exact replay performs no reauthorization. +- A separate authenticated and authorized World reviewer rejects broader promotion with an exact + `no_action` Core Decision. The useful evaluation and promote proposal remain unchanged, and no + effective governed-state head changes. - This is source-checkout evidence against Core PR #88, not a released World capability, human benefit finding, causal claim, network-freshness proof, or applied governance change. See the [P2C3 candidate work packet](docs/design/world-intelligence-p2c3-measured-feedback-work-packet-v1.md). +The follow-on [P2C4 work packet](docs/design/world-intelligence-p2c4-reviewed-impact-disposition-work-packet-v1.md) +freezes the exact proposal-disposition boundary. ## Next — trustworthy live orientation diff --git a/docs/audits/world-intelligence-p2c4-reviewed-impact-disposition-2026-08-10.md b/docs/audits/world-intelligence-p2c4-reviewed-impact-disposition-2026-08-10.md new file mode 100644 index 0000000..7ae5288 --- /dev/null +++ b/docs/audits/world-intelligence-p2c4-reviewed-impact-disposition-2026-08-10.md @@ -0,0 +1,103 @@ +# World Intelligence P2C4 reviewed impact disposition audit — 2026-08-10 + +Status: **stacked candidate evidence only; not a release or applied governance change** + +## Source identity + +- World base: P2C3 commit `c712b2ca9bf67381a9862f07eb780f5c13e2f379` +- World branch: `codex/measured-impact-world-disposition` +- Core base: measured-impact kickoff commit `9078018a5fd3c310011b6c9efbfe5255e0e36887` +- Core dependency: stacked `codex/measured-impact-disposition` candidate +- Released identity intentionally unchanged: `ace-domain-world-intelligence==0.9.0`, + `ace-core>=0.5.0,<0.6` + +## Exact point-in-time result + +One candidate run retained the P2C3 `useful` classification and non-effective `promote` proposal, +then recorded a separately authorized Core Decision whose subject was that exact proposal: + +```text +evaluation: impact_evaluation:8c133e576587fae76927828ab882210d +evaluation material: sha256:68808bb0f0d462035fb297e0c14825910a5fe4e1510fd8994cc20d1a704d4f59 +proposal: impact_governance_proposal:c8021b5d1798ef9c61ab90abacccbddf +proposal material: sha256:7eddbeb2485db19ac19ee6c5540925bd7a6dc89d3b50ec521a3ed7226785730d +decision: decision:5e0ca6230ab92ed3702a5363264ff098 +decision material: sha256:ef4027ba44b9a25569b0071dd27a22fc81256c44787c7cf8040c304be2e5a840 +measured classification: useful +proposal action: promote +reviewer disposition: reject +Decision action disposition: no_action +proposal applied: false +effective governed state changed: false +historical replay: true +replay reauthorization: false +``` + +The rationale rejected broader promotion because the exact criterion measured only structural +coverage of two required admitted Observation identities in reviewed exports. The Decision did not +reclassify the evaluation or replace the proposal. + +## Verification + +Stacked source-checkout verification with the Core disposition candidate and the separately +packaged reference action adapter: + +```text +python -B -m pytest domain_packs/tests/test_p2c3_measured_feedback.py \ + domain_packs/tests/test_p2c4_reviewed_impact_disposition.py -q --tb=short +4 passed in 0.88s + +ruff check scripts/p2c3_measured_feedback.py \ + scripts/p2c4_reviewed_impact_disposition.py \ + domain_packs/tests/test_p2c4_reviewed_impact_disposition.py +PASS + +ruff format --check scripts/p2c3_measured_feedback.py \ + scripts/p2c4_reviewed_impact_disposition.py \ + domain_packs/tests/test_p2c4_reviewed_impact_disposition.py +PASS + +python -B -m pytest -q --tb=short +87 passed in 17.00s + +python -B -m pytest adapters/federal_register_source/tests -q --tb=short +26 passed in 0.26s + +python -B -m pytest tests/test_release_contract.py -q --tb=short +7 passed in 0.04s + +# Locked environment with public ace-core==0.5.0 and no candidate source checkout. +python -B -m pytest -q --tb=short -rs +82 passed, 5 skipped in 15.38s + +uv build --out-dir +Successfully built unchanged 0.9.0 source distribution and inert data-only wheel + +git diff --check +PASS +``` + +The five locked-environment skips are explicit boundaries: one P2C2 test requires the separately +packaged reference adapter, two P2C3 tests require the unreleased measured-impact contract, and two +P2C4 tests require the stacked proposal-disposition contract. The public 0.5 dependency range and +0.9.0 artifact therefore remain coherent. The built wheel contains only inert Domain Pack data and +no candidate script, test, adapter, or audit Python. + +## Claim boundary + +The named World principal and governed role/grant prove that the fixture followed explicit product +review policy; this neutral contract does not independently prove biological personhood. Recorded +official source responses preserve exact public provenance but do not prove a live network request +or test-time freshness. The useful result remains a deterministic two-pair structural rule, not a +causal estimate, population result, correctness score, or human-benefit finding. + +P2C4 proves that ACE can retain a measured result, retain its proposed governance action, and +record a contrary authorized disposition without silently applying or rewriting either. It does +not publish 0.6, pass SI4, update the Domain Pack release, or create effective state. + +## Remaining work + +The next measurement packet needs independently reviewed product-quality evidence such as citation +correctness, contradiction coverage, correction quality, detection delay, or false-alert rate. +Market reproduction, public Core artifacts, compatibility/security/release gates, opt-in live +transport, and any separately authorized proposal application remain outside this candidate. diff --git a/docs/design/world-intelligence-p2c4-reviewed-impact-disposition-work-packet-v1.md b/docs/design/world-intelligence-p2c4-reviewed-impact-disposition-work-packet-v1.md new file mode 100644 index 0000000..91c7852 --- /dev/null +++ b/docs/design/world-intelligence-p2c4-reviewed-impact-disposition-work-packet-v1.md @@ -0,0 +1,77 @@ +# World Intelligence P2C4 reviewed impact disposition work packet (v1) + +**Status:** stacked source-checkout candidate; this packet does not release World Intelligence, +apply a governance proposal, close ACE Core issue #38, or complete ACE 0.6.0. + +**Frozen:** 2026-08-10 from World P2C3 commit +`c712b2ca9bf67381a9862f07eb780f5c13e2f379`, stacked on the Core measured-impact disposition +candidate. + +## Objective + +Extend the recorded official-public-data journey through one explicit governed feedback decision: + +```text +Observation -> Shift -> Signal -> Brief -> Decision -> reviewed Action + -> observed Outcome -> useful evaluation -> promote proposal + -> authorized reject/no-action Decision +``` + +The packet must preserve both judgments. The frozen structural citation-coverage criterion remains +`useful` and continues to propose `promote`; a separately authenticated and authorized World +reviewer rejects broader promotion because that measure does not establish citation correctness, +general Brief quality, human benefit, causality, or live network freshness. + +## Product-owned policy and Core boundary + +World owns the reviewer role, disposition-operation binding, authority grant, and rationale. The +fixture uses the named principal `principal:world-impact-governor` and role +`role:world-impact-governor`. Core owns authentication, exact authority closure, generic Decision, +immutable persistence, and replay. Intelligence owns the unchanged domain-neutral evaluation and +proposal contracts. + +The fixture's named role and grant make the product's human-review policy explicit; they are not a +universal identity-verification or biological-personhood claim. The Domain Pack remains inert JSON +and gains no executable behavior or authority. + +## Exact acceptance + +P2C4 must: + +1. rerun the P2C3 official-record journey through the exact Brief, treatment/control Actions, + Outcomes, `useful` evaluation, and non-effective `promote` proposal; +2. install a separate disposition operation/capability/authority closure in the acceptance host; +3. submit the exact evaluation and proposal references to Core's disposition service; +4. record `reject` with `no_action` and the exact proposal as Decision subject; +5. preserve the evaluation classification and proposal action without mutation; +6. prove the governed-state head map is identical before and after disposition; +7. replay the exact Decision through a fresh service whose authorizer raises if invoked; and +8. keep proposal application, human benefit, causality, network freshness, and autonomous + publishing explicitly false. + +## Files and rollback + +This packet owns: + +- `scripts/p2c4_reviewed_impact_disposition.py`; +- `domain_packs/tests/test_p2c4_reviewed_impact_disposition.py`; +- the additive P2C3 state handoff used only by composed acceptance; +- this work packet, its audit record, and restrained README/roadmap references. + +It does not edit the shipped Domain Pack, connector, version metadata, dependency range, lockfile, +release record, or public artifacts. Rollback removes the additive harness, tests, state handoff, +and candidate documentation. Any Decision already persisted by a host remains immutable history. + +## Non-claims and next packet + +P2C4 proves an explicit authorized rejection of one non-effective proposal over deterministic +recorded official-public-data fixtures. It does not prove a live network request, citation +correctness, contradiction recall, calibration, correction quality, detection delay, false-alert +rate, general usefulness, customer value, causality, or human benefit. The Decision does not apply +the proposal and creates no effective policy or subject state. + +The next bounded measurement packet should add one independently reviewed product outcome—such as +citation correctness, contradiction coverage, correction quality, detection delay, or false-alert +rate—under frozen controls. Opt-in network transport and P2D multi-source correction remain +separate. Actual proposal application is a later Core-authorized packet only if product policy +justifies changing effective state. diff --git a/domain_packs/tests/test_p2c4_reviewed_impact_disposition.py b/domain_packs/tests/test_p2c4_reviewed_impact_disposition.py new file mode 100644 index 0000000..d7e2ad5 --- /dev/null +++ b/domain_packs/tests/test_p2c4_reviewed_impact_disposition.py @@ -0,0 +1,50 @@ +from __future__ import annotations + +import importlib.util + +import pytest + + +def _require_candidate_contracts() -> None: + if importlib.util.find_spec("ace.application.measured_impact_disposition") is None: + pytest.skip("P2C4 candidate requires the stacked ACE Core proposal-disposition contract") + if importlib.util.find_spec("ace_reference_workspace_action") is None: + pytest.skip("P2C4 candidate requires the separately packaged Core reference adapter") + + +@pytest.mark.asyncio +async def test_structurally_useful_result_reaches_exact_reject_no_action_disposition(tmp_path) -> None: + _require_candidate_contracts() + from scripts.p2c4_reviewed_impact_disposition import run_reviewed_disposition + + result = await run_reviewed_disposition(tmp_path) + + assert result["measured_feedback"]["evaluation"]["classification"] == "useful" + assert result["measured_feedback"]["proposal"]["action"] == "promote" + assert result["disposition"]["decision"]["intent"]["subject"] == result["disposition"]["proposal_reference"] + assert result["disposition"]["decision"]["intent"]["disposition"] == "reject" + assert result["disposition"]["decision"]["intent"]["action_disposition"] == "no_action" + assert result["disposition"]["effective_state_changed"] is False + assert result["disposition"]["replayed"] is True + assert result["disposition"]["no_reauthorization"] is True + + +@pytest.mark.asyncio +async def test_reviewed_disposition_preserves_the_public_claim_boundary(tmp_path) -> None: + _require_candidate_contracts() + from scripts.p2c4_reviewed_impact_disposition import run_reviewed_disposition + + result = await run_reviewed_disposition(tmp_path) + + assert result["scope"] == { + "measured_classification_preserved": "useful", + "proposal_action_preserved": "promote", + "proposal_disposition": "reject", + "proposal_applied": False, + "human_benefit_claimed": False, + "causality_claimed": False, + "network_freshness_claimed": False, + "autonomous_publication": False, + } + rationale = result["disposition"]["decision"]["intent"]["rationale"] + assert "does not establish" in rationale diff --git a/scripts/p2c3_measured_feedback.py b/scripts/p2c3_measured_feedback.py index 35d7eb9..6890b95 100644 --- a/scripts/p2c3_measured_feedback.py +++ b/scripts/p2c3_measured_feedback.py @@ -546,7 +546,11 @@ def _install_impact_policy(state: dict[str, Any]): return criterion_head, impact_binding -async def run_measured_feedback(workspace_root: Path) -> dict[str, Any]: +async def run_measured_feedback( + workspace_root: Path, + *, + state_sink: dict[str, Any] | None = None, +) -> dict[str, Any]: """Run official records through matched Outcomes and proposal-only feedback.""" state: dict[str, Any] = {"workspace_root": workspace_root} @@ -711,7 +715,7 @@ async def run_measured_feedback(workspace_root: Path) -> dict[str, Any]: if admission.proposal is None or admission.proposal.action is not ImpactGovernanceAction.PROMOTE: raise AssertionError("useful World evaluation did not emit the product-mapped proposal") - return { + result = { "contract": "ace.world-intelligence.measured-feedback/v1alpha1", "journey": prior, "criterion": { @@ -745,6 +749,17 @@ async def run_measured_feedback(workspace_root: Path) -> dict[str, Any]: "autonomous_publication": False, }, } + if state_sink is not None: + state_sink.update(state) + state_sink.update( + { + "impact_binding": impact_binding, + "impact_criterion": criterion, + "impact_request": request, + "impact_admission": admission, + } + ) + return result def main() -> None: diff --git a/scripts/p2c4_reviewed_impact_disposition.py b/scripts/p2c4_reviewed_impact_disposition.py new file mode 100644 index 0000000..6d28b5b --- /dev/null +++ b/scripts/p2c4_reviewed_impact_disposition.py @@ -0,0 +1,169 @@ +"""Explicitly reject broader promotion of the exact P2C3 structural result.""" + +from __future__ import annotations + +import asyncio +import json +from pathlib import Path +from typing import Any + +from ace.application import ( + MeasuredImpactDispositionRequestV1Alpha1, + MeasuredImpactDispositionService, +) +from ace.core import ( + CapabilityArtifactIdentityV1Alpha1, + DecisionActionDisposition, + DecisionDisposition, + GovernedOperationBindingV1Alpha1, + GovernedStateHeadPreconditionV1Alpha1, + capability_state_ref_for_artifact, +) + +from scripts.p2c2_governed_reality_brief import _context, _head +from scripts.p2c3_measured_feedback import run_measured_feedback + +DISPOSITION_ARTIFACT = CapabilityArtifactIdentityV1Alpha1( + capability="measured_impact_proposal_disposition", + contract="ace.application.measured-impact-disposition-service/v1alpha1", + implementation_id="world_measured_impact_disposition_candidate", + implementation_version="0.1.0", + artifact_digest="sha256:" + "d" * 64, +) + + +class _ReplayMustNotAuthorize: + async def authorize_action(self, request): + raise AssertionError(f"historical disposition requested new authority: {request.authorization_key}") + + +def _install_disposition_policy(state: dict[str, Any]) -> GovernedOperationBindingV1Alpha1: + environment = state["environment"] + runtime = state["runtime"] + product_id = environment.fixture["product_id"] + operation_head = _head( + product_id, + "governed_operation_configuration", + "governed_operation_configuration:world-measured-impact-disposition", + 50, + ) + binding = GovernedOperationBindingV1Alpha1( + product_id=product_id, + artifact=DISPOSITION_ARTIFACT, + configuration_ref=operation_head.state_id, + authority="append_measured_impact_disposition", + grant_ref="authority_grant:world-measured-impact-disposition", + state_head_precondition=GovernedStateHeadPreconditionV1Alpha1.from_head(operation_head), + ) + capability_head = _head( + product_id, + "capability_state", + capability_state_ref_for_artifact(DISPOSITION_ARTIFACT), + 51, + ) + authority_head = _head( + product_id, + "authority_grant", + binding.grant_ref, + 52, + ) + for head in (operation_head, capability_head, authority_head): + environment.store.set_governed_state_head(head) + runtime.heads[head.state_kind, head.state_id] = head + runtime.bindings = (*runtime.bindings, binding) + return binding + + +async def run_reviewed_disposition(workspace_root: Path) -> dict[str, Any]: + """Run P2C3, then record one exact reject/no-action human Decision.""" + + state: dict[str, Any] = {} + measured = await run_measured_feedback(workspace_root, state_sink=state) + environment = state["environment"] + binding = _install_disposition_policy(state) + evaluation_ref, proposal_ref = state["impact_admission"].transaction_receipt.records + context = _context(environment.context, "principal:world-impact-governor") + request = MeasuredImpactDispositionRequestV1Alpha1( + product_id=environment.fixture["product_id"], + authenticated_context=context, + evaluation=evaluation_ref, + proposal=proposal_ref, + reviewer_role_ref="role:world-impact-governor", + disposition=DecisionDisposition.REJECT, + rationale=( + "Reject broader promotion of the Reality Brief. The exact useful result establishes " + "structural citation coverage under one frozen fixture criterion, but does not establish " + "citation correctness, general Brief quality, human benefit, causality, or live freshness." + ), + decided_at=state["clock"](), + ) + heads_before = dict(environment.store.governed_state_heads) + admission = await MeasuredImpactDispositionService( + store=environment.store, + authorizer=state["reasoning"], + operation_binding=binding, + ).decide(request) + heads_after = dict(environment.store.governed_state_heads) + replay = await MeasuredImpactDispositionService( + store=environment.store, + authorizer=_ReplayMustNotAuthorize(), + operation_binding=binding, + ).decide(request) + if ( + admission.replayed + or not replay.replayed + or admission.decision != replay.decision + or admission.transaction_receipt != replay.transaction_receipt + ): + raise AssertionError("reviewed impact disposition did not replay exact historical material") + if ( + admission.decision.intent.disposition is not DecisionDisposition.REJECT + or admission.decision.intent.action_disposition is not DecisionActionDisposition.NO_ACTION + or admission.decision.intent.subject != proposal_ref + ): + raise AssertionError("reviewed impact disposition crossed the exact reject/no-action boundary") + if heads_after != heads_before: + raise AssertionError("reviewed proposal disposition mutated effective governed state") + + return { + "contract": "ace.world-intelligence.reviewed-impact-disposition/v1alpha1", + "measured_feedback": measured, + "disposition": { + "decision": admission.decision.model_dump(mode="json"), + "decision_reference": admission.decision_reference.model_dump(mode="json"), + "proposal_reference": proposal_ref.model_dump(mode="json"), + "evaluation_reference": evaluation_ref.model_dump(mode="json"), + "replayed": replay.replayed, + "no_reauthorization": True, + "effective_state_changed": False, + }, + "scope": { + "measured_classification_preserved": measured["evaluation"]["classification"], + "proposal_action_preserved": measured["proposal"]["action"], + "proposal_disposition": admission.decision.intent.disposition.value, + "proposal_applied": False, + "human_benefit_claimed": False, + "causality_claimed": False, + "network_freshness_claimed": False, + "autonomous_publication": False, + }, + } + + +def main() -> None: + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("workspace_root", type=Path) + args = parser.parse_args() + print( + json.dumps( + asyncio.run(run_reviewed_disposition(args.workspace_root)), + indent=2, + sort_keys=True, + ) + ) + + +if __name__ == "__main__": + main()