forge-autonomy 2.7.30__tar.gz → 2.7.31__tar.gz

{forge_autonomy-2.7.30 → forge_autonomy-2.7.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forge-autonomy
-Version: 2.7.30
+Version: 2.7.31
 Summary: Forge mission planning, producer contracts, and evidence interpretation runtime.
 Author: Forge maintainers
 License-Expression: Apache-2.0

{forge_autonomy-2.7.30 → forge_autonomy-2.7.31}/forge/planner/codex_cli_session.py

@@ -32,7 +32,10 @@ from forge.provider_security import (
     ProviderAuthenticationMode,
 )
 from forge.runtime.database import _timestamp
-from .openai_responses import ProviderSubmissionAmbiguous, _mission_gap, _schema_for_approved_contract
+from .openai_responses import (
+    ProviderSubmissionAmbiguous, _canonical_required_policy_values, _mission_gap,
+    _schema_for_approved_contract,
+)
 from .provider_adapter import BoundedActionDerivationProvider, ProviderDerivationRequest, ProviderDerivationResponse
 
 
@@ -407,7 +410,9 @@ class CodexCliChatGPTSessionPlanningProvider:
             diagnostic = _replace_diagnostic(run.diagnostic, CodexCliInvocationClassification.COMPLETED_CONTRACT_INVALID)
         else:
             try:
-                proposals, refinement = _parse_response(request, document, self.adapter_version)
+                proposals, refinement = _parse_response(
+                    request, document, self.adapter_version, derivation_policy
+                )
                 status = "completed"
                 diagnostic = _replace_diagnostic(run.diagnostic, CodexCliInvocationClassification.COMPLETED_VALID)
             except (KeyError, TypeError, ValueError, json.JSONDecodeError):
@@ -737,7 +742,7 @@ def _output_schema(scopes: tuple[str, ...], policy: DerivationPolicy,
 
 
 def _parse_response(request: ProviderDerivationRequest, document: object,
-                    adapter_version: str) -> tuple[tuple[DerivedActionProposal, ...] | None, GovernanceRefinementRequired | None]:
+                    adapter_version: str, derivation_policy: DerivationPolicy) -> tuple[tuple[DerivedActionProposal, ...] | None, GovernanceRefinementRequired | None]:
     if not isinstance(document, dict) or set(document) != {"result"} or not isinstance(document.get("result"), dict):
         raise ValueError("structured response is not an object")
     document = document["result"]
@@ -750,12 +755,12 @@ def _parse_response(request: ProviderDerivationRequest, document: object,
     items = document.get("proposals")
     if not isinstance(items, list) or not items:
         raise ValueError("structured response lacks proposals")
-    proposals = tuple(_proposal(request, item, adapter_version) for item in items)
+    proposals = tuple(_proposal(request, item, adapter_version, derivation_policy) for item in items)
     return proposals, None
 
 
 def _proposal(request: ProviderDerivationRequest, item: object,
-              adapter_version: str) -> DerivedActionProposal:
+              adapter_version: str, derivation_policy: DerivationPolicy) -> DerivedActionProposal:
     if not isinstance(item, dict) or set(item) != _PROPOSAL_FIELDS:
         raise ValueError("proposal contains missing or extra fields")
     for key in ("logical_action_id", "scope", "objective"):
@@ -772,7 +777,12 @@ def _proposal(request: ProviderDerivationRequest, item: object,
         item["logical_action_id"], item["scope"], item["objective"], _unique_strings(item["dependencies"]),
         _unique_strings(item["write_scopes"]), _unique_strings(item["expected_evidence"]),
         _unique_strings(item["validation_strategy"]), item["priority"], item["postponed"],
-        _unique_strings(item["human_gates"]), _unique_strings(item["risk_inputs"]),
+        _canonical_required_policy_values(
+            item["human_gates"], derivation_policy.required_human_gates, field="human_gates"
+        ),
+        _canonical_required_policy_values(
+            item["risk_inputs"], derivation_policy.required_risk_inputs, field="risk_inputs"
+        ),
         ProposalProvenance(request.derivation_id, request.snapshot.id, request.snapshot.digest, adapter_version,
                            request.provider_id, request.model, _unique_strings(item["source_evidence_refs"])),
         _mission_gap(item["mission_gap"]),

{forge_autonomy-2.7.30 → forge_autonomy-2.7.31}/forge/planner/openai_responses.py

@@ -385,7 +385,14 @@ class OpenAIResponsesPlanningProvider:
             secret = None
             self.configuration.policy_service._release_generation_permit(permit)
         try:
-            proposals, refinement = self._parse(request, document)
+            write_scopes, human_gates, risk_inputs = (
+                self.configuration.preflight_authority.approved_derivation_policy_for(
+                    request.snapshot.mission_id
+                )
+            )
+            proposals, refinement = self._parse(
+                request, document, DerivationPolicy(write_scopes, human_gates, risk_inputs)
+            )
             return ProviderDerivationResponse(self._evidence(request, document, ProviderSideEffectState.HAPPENED_AND_CONFIRMED, started, str(document.get("status", "completed"))), proposals=proposals, governance_refinement=refinement)
         except (KeyError, TypeError, ValueError, json.JSONDecodeError):
             # A confirmed invalid response is never passed to deterministic validation.
@@ -541,7 +548,8 @@ class OpenAIResponsesPlanningProvider:
         if input_tokens + output_tokens > policy.context_token_bound:
             raise ValueError("bounded planning request exceeds canonical G011 context token bound")
 
-    def _parse(self, request: ProviderDerivationRequest, document: dict[str, object]) -> tuple[tuple[DerivedActionProposal, ...] | None, GovernanceRefinementRequired | None]:
+    def _parse(self, request: ProviderDerivationRequest, document: dict[str, object],
+               derivation_policy: DerivationPolicy) -> tuple[tuple[DerivedActionProposal, ...] | None, GovernanceRefinementRequired | None]:
         if document.get("status") != "completed": raise ValueError("response was not completed")
         text = _structured_output_text(document)
         parsed = json.loads(text)
@@ -553,7 +561,10 @@ class OpenAIResponsesPlanningProvider:
             str(item["logical_action_id"]), str(item["scope"]), str(item["objective"]),
             tuple(item["dependencies"]), tuple(item["write_scopes"]), tuple(item["expected_evidence"]),
             tuple(item["validation_strategy"]), int(item["priority"]), bool(item["postponed"]),
-            tuple(item["human_gates"]), tuple(item["risk_inputs"]),
+            _canonical_required_policy_values(item["human_gates"], derivation_policy.required_human_gates,
+                                              field="human_gates"),
+            _canonical_required_policy_values(item["risk_inputs"], derivation_policy.required_risk_inputs,
+                                              field="risk_inputs"),
             ProposalProvenance(request.derivation_id, request.snapshot.id, request.snapshot.digest,
                                self.adapter_version, request.provider_id, request.model,
                                tuple(item["source_evidence_refs"])),
@@ -731,3 +742,20 @@ def _required_enum_array(values: tuple[str, ...]) -> dict[str, object]:
         raise ValueError("canonical derivation constraint set is invalid")
     return {"type": "array", "items": {"type": "string", "enum": list(values)},
             "minItems": len(values), "maxItems": len(values)}
+
+
+def _canonical_required_policy_values(raw: object, required: tuple[str, ...], *, field: str) -> tuple[str, ...]:
+    """Bind required governance annotations to the canonical approved policy.
+
+    The supported strict schemas can constrain array length and enum members,
+    but cannot require every enum member exactly once.  A provider can
+    therefore repeat one allowed member and omit another while still
+    satisfying the transport schema.  The provider does not own these
+    annotations: after checking the same bounded shape and allow-list, bind
+    the proposal to the complete approved set.  The downstream validator
+    remains the final fail-closed authority check.
+    """
+    if (not isinstance(raw, list) or len(raw) != len(required)
+            or any(not isinstance(value, str) or value not in required for value in raw)):
+        raise ValueError(f"proposal {field} does not match the approved policy shape")
+    return required

{forge_autonomy-2.7.30 → forge_autonomy-2.7.31}/forge_autonomy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forge-autonomy
-Version: 2.7.30
+Version: 2.7.31
 Summary: Forge mission planning, producer contracts, and evidence interpretation runtime.
 Author: Forge maintainers
 License-Expression: Apache-2.0

{forge_autonomy-2.7.30 → forge_autonomy-2.7.31}/product-version.json

@@ -1,5 +1,5 @@
 {
   "product": "forge",
   "schema_version": 1,
-  "version": "2.7.30"
+  "version": "2.7.31"
 }

{forge_autonomy-2.7.30 → forge_autonomy-2.7.31}/tests/test_codex_cli_session.py

@@ -339,6 +339,43 @@ class CodexCliSessionTests(unittest.TestCase):
         self.assertEqual(response.proposals[0].validation_strategy, ("unit test",))
         self.assertEqual(response.proposals[0].provenance.source_evidence_refs, ("mission_state",))
 
+    def test_required_governance_arrays_bind_to_complete_approved_policy(self):
+        self.configure()
+        policy = DerivationPolicy(
+            self.policy.allowed_write_scopes,
+            ("architecture-review", "security-review"),
+            ("provider-ambiguity", "scope-drift"),
+        )
+        repeated = document()
+        proposal = repeated["result"]["proposals"][0]
+        proposal["human_gates"] = ["architecture-review", "architecture-review"]
+        proposal["risk_inputs"] = ["scope-drift", "scope-drift"]
+        response = self.provider(Runner(repeated)).invoke(
+            self.request(), approved_scopes=("planner-contract",), derivation_policy=policy,
+        )
+        self.assertEqual(response.evidence.status, "completed")
+        self.assertEqual(
+            response.proposals[0].human_gates,
+            ("architecture-review", "security-review"),
+        )
+        self.assertEqual(
+            response.proposals[0].risk_inputs,
+            ("provider-ambiguity", "scope-drift"),
+        )
+        ActionDerivationValidator().validate(
+            response.proposals or (), self.snapshot, self.input, policy,
+        )
+
+    def test_required_governance_arrays_reject_values_outside_approved_policy(self):
+        self.configure()
+        outside = document()
+        outside["result"]["proposals"][0]["risk_inputs"] = ["invented-risk"]
+        response = self.provider(Runner(outside)).invoke(
+            self.request(), approved_scopes=("planner-contract",), derivation_policy=self.policy,
+        )
+        self.assertIsNone(response.proposals)
+        self.assertEqual(response.evidence.status, "contract_invalid")
+
     def test_object_root_preserves_governance_refinement_without_permitting_mixed_variants(self):
         self.configure()
         refinement = {"result": {"kind": "governance_refinement", "reason": "needs architecture"}}

{forge_autonomy-2.7.30 → forge_autonomy-2.7.31}/tests/test_criterion_planning_context.py

@@ -210,7 +210,10 @@ class CriterionPlanningContextTests(unittest.TestCase):
                 "triggering_evidence_refs": ["receipt-a"], "planning_snapshot_digest": snapshot.digest,
                 "causal_objective": "Realize K2 from the missing artifact assertion.", "mission_caused_by_action_ids": []},
         }]}}
-        proposals, refinement = _parse_response(request, response, "1.0")
+        proposals, refinement = _parse_response(
+            request, response, "1.0",
+            DerivationPolicy(("evidence",), ("protected delivery",), ("scope-drift",)),
+        )
         self.assertIsNone(refinement)
         class ParsedProvider:
             def derive(self, actual_snapshot):

{forge_autonomy-2.7.30 → forge_autonomy-2.7.31}/tests/test_installed_forge_update.py

@@ -295,7 +295,7 @@ class InstalledForgeUpdateTests(unittest.TestCase):
                 "github_release": {"draft": False},
             },
         }, sort_keys=True), encoding="utf-8")
-        if version in {"2.7.25", "2.7.26", "2.7.27", "2.7.28", "2.7.29", "2.7.30"}:
+        if version in {"2.7.25", "2.7.26", "2.7.27", "2.7.28", "2.7.29", "2.7.30", "2.7.31"}:
             # Captured from the actual installed-composition command used by
             # both workflow stages; only the synthetic wheel binding changes.
             summary = json.loads((Path(__file__).parent / "fixtures" /
@@ -1516,6 +1516,29 @@ class InstalledForgeUpdateTests(unittest.TestCase):
         with self.assertRaisesRegex(update.InstalledForgeUpdateError, "noncanonical"):
             update.validate_qualified_artifact(changed)
 
+    def test_2730_to_2731_same_schema_release_preserves_history_and_requires_composition(self):
+        before = self._same_schema39_transition(existing_version="2.7.30", target_version="2.7.31")
+        self.assertEqual(update.transition_schemas(self.request), (39, 39))
+        self.assertEqual(update.validate_qualified_artifact(self.request)["release_route"], "NORMAL")
+        controller = self._controller()
+        self.assertEqual(controller.backup_path.name, "forge-schema39.sqlite3")
+        after = self._qualified_schema39_copy(controller, before)
+        for table, evidence in before["tables"].items():
+            if table != "runtime_metadata":
+                self.assertEqual(after["tables"][table], evidence, table)
+        self.assertEqual(after["protected_metadata_digest"], before["protected_metadata_digest"])
+        self.assertEqual(after["schema_digest"], before["schema_digest"])
+        update.verify_preservation(before, after, self.request)
+        receipt = Path(self.request.qualification_receipt)
+        document = json.loads(receipt.read_text())
+        del document["qualification"]["criterion_completion"]
+        receipt.write_text(json.dumps(document, sort_keys=True))
+        changed = update.UpdateRequest(**{
+            **self.request.__dict__, "qualification_receipt_sha256": update.file_digest(receipt),
+        })
+        with self.assertRaisesRegex(update.InstalledForgeUpdateError, "noncanonical"):
+            update.validate_qualified_artifact(changed)
+
     def test_schema39_same_schema_replay_preserves_database_and_fences_after_activation_boundary(self):
         before = self._same_schema39_transition()
         controller = self._controller()
@@ -1581,10 +1604,10 @@ class InstalledForgeUpdateTests(unittest.TestCase):
         receipt = Path(receipt_value).resolve()
         release = json.loads(receipt.read_text(encoding="utf-8"))
         target_version = release["version"]
-        target_schema = 39 if target_version in {"2.7.25", "2.7.26", "2.7.27", "2.7.28", "2.7.29", "2.7.30"} else 38
+        target_schema = 39 if target_version in {"2.7.25", "2.7.26", "2.7.27", "2.7.28", "2.7.29", "2.7.30", "2.7.31"} else 38
         previous_version = {
             "2.7.26": "2.7.25", "2.7.27": "2.7.26", "2.7.28": "2.7.27",
-            "2.7.29": "2.7.28", "2.7.30": "2.7.29",
+            "2.7.29": "2.7.28", "2.7.30": "2.7.29", "2.7.31": "2.7.30",
         }.get(target_version)
         if previous_version is not None:
             RuntimeBootstrap(data_root=self.data_root, forge_version=previous_version).open().close()