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

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

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

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

@@ -769,15 +769,21 @@ def _proposal(request: ProviderDerivationRequest, item: object,
     if not isinstance(item["postponed"], bool):
         raise ValueError("proposal postponed flag is invalid")
     return DerivedActionProposal(
-        item["logical_action_id"], item["scope"], item["objective"], tuple(item["dependencies"]),
-        tuple(item["write_scopes"]), tuple(item["expected_evidence"]), tuple(item["validation_strategy"]),
-        item["priority"], item["postponed"], tuple(item["human_gates"]), tuple(item["risk_inputs"]),
+        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"]),
         ProposalProvenance(request.derivation_id, request.snapshot.id, request.snapshot.digest, adapter_version,
-                           request.provider_id, request.model, tuple(item["source_evidence_refs"])),
+                           request.provider_id, request.model, _unique_strings(item["source_evidence_refs"])),
         _mission_gap(item["mission_gap"]),
     )
 
 
+def _unique_strings(values: list[str]) -> tuple[str, ...]:
+    """Remove repetition without adding authority or changing string content."""
+    return tuple(dict.fromkeys(values))
+
+
 def _refinement(snapshot: PlanningSnapshot, reason: str) -> GovernanceRefinementRequired:
     return GovernanceRefinementRequired(tuple(item.source_id for item in snapshot.evidence),
                                         "deterministic validation required", "provider-output", "blocked", reason)

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

@@ -668,6 +668,14 @@ def _schema_for_approved_contract(scopes: tuple[str, ...], write_scopes: tuple[s
         raise ValueError("canonical derivation policy is required")
     schema = json.loads(json.dumps(_SCHEMA))
     properties = schema["properties"]["proposals"]["items"]["properties"]
+    # Keep Structured Outputs at least as strict as the parser that consumes
+    # them.  Evidence, validation, and provenance are required by the typed
+    # proposal model, so their arrays must contain at least one non-empty
+    # value.  Dependencies may be empty for the first executable proposal.
+    for key in ("dependencies", "expected_evidence", "validation_strategy", "source_evidence_refs"):
+        properties[key]["items"]["minLength"] = 1
+    for key in ("expected_evidence", "validation_strategy", "source_evidence_refs"):
+        properties[key]["minItems"] = 1
     properties["scope"] = {
         "type": "string", "enum": list(scopes),
     }
@@ -694,7 +702,9 @@ def _schema_for_approved_contract(scopes: tuple[str, ...], write_scopes: tuple[s
                                           "items": {"type": "string", "enum": [item.source_id for item in snapshot.evidence]}},
              "planning_snapshot_digest": {"type": "string", "enum": [snapshot.digest]},
              "causal_objective": {"type": "string", "minLength": 1},
-             "mission_caused_by_action_ids": {"type": "array", "items": {"type": "string"}},
+             "mission_caused_by_action_ids": {
+                 "type": "array", "items": {"type": "string", "minLength": 1},
+             },
          }},
         {"type": "null"},
     ]}
@@ -708,9 +718,10 @@ def _mission_gap(document: object) -> MissionGapBinding | None:
         raise ValueError("Mission-gap binding is malformed")
     return MissionGapBinding(
         MissionGapClassification(str(document["classification"])),
-        tuple(document["criterion_ids"]), tuple(document["triggering_evidence_refs"]),
+        tuple(dict.fromkeys(document["criterion_ids"])),
+        tuple(dict.fromkeys(document["triggering_evidence_refs"])),
         str(document["planning_snapshot_digest"]), str(document["causal_objective"]),
-        tuple(document["mission_caused_by_action_ids"]),
+        tuple(dict.fromkeys(document["mission_caused_by_action_ids"])),
     )
 
 

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

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

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

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

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

@@ -250,6 +250,13 @@ class CodexCliSessionTests(unittest.TestCase):
         self.assertEqual(runner.schemas[0]["required"], ["result"])
         self.assertEqual(runner.schemas[0]["properties"]["result"]["anyOf"][0]["properties"]["proposals"]["items"]["properties"]["write_scopes"]["items"]["enum"],
                          ["forge/planner"])
+        proposal_properties = runner.schemas[0]["properties"]["result"]["anyOf"][0]["properties"]["proposals"]["items"]["properties"]
+        for key in ("dependencies", "expected_evidence", "validation_strategy", "source_evidence_refs"):
+            self.assertEqual(proposal_properties[key]["items"]["minLength"], 1)
+        for key in ("expected_evidence", "validation_strategy", "source_evidence_refs"):
+            self.assertEqual(proposal_properties[key]["minItems"], 1)
+        gap_properties = proposal_properties["mission_gap"]["anyOf"][0]["properties"]
+        self.assertEqual(gap_properties["mission_caused_by_action_ids"]["items"]["minLength"], 1)
         evidence = self.invocation_documents()
         self.assertEqual([item["state"] for item in evidence], ["STARTED", "HAPPENED_AND_CONFIRMED"])
         self.assertEqual(evidence[-1]["diagnostic"]["classification"], "COMPLETED_VALID")
@@ -317,6 +324,21 @@ class CodexCliSessionTests(unittest.TestCase):
         self.assertEqual(response.evidence.status, "contract_invalid")
         self.assertEqual(self.invocation_documents()[-1]["diagnostic"]["classification"], "COMPLETED_CONTRACT_INVALID")
 
+    def test_schema_valid_repeated_array_values_are_canonicalized(self):
+        self.configure()
+        repeated = document()
+        proposal = repeated["result"]["proposals"][0]
+        proposal["expected_evidence"] = ["unit test", "unit test"]
+        proposal["validation_strategy"] = ["unit test", "unit test"]
+        proposal["source_evidence_refs"] = ["mission_state", "mission_state"]
+        response = self.provider(Runner(repeated)).invoke(
+            self.request(), approved_scopes=("planner-contract",), derivation_policy=self.policy,
+        )
+        self.assertEqual(response.evidence.status, "completed")
+        self.assertEqual(response.proposals[0].expected_evidence, ("unit test",))
+        self.assertEqual(response.proposals[0].validation_strategy, ("unit test",))
+        self.assertEqual(response.proposals[0].provenance.source_evidence_refs, ("mission_state",))
+
     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.28 → forge_autonomy-2.7.30}/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"}:
+        if version in {"2.7.25", "2.7.26", "2.7.27", "2.7.28", "2.7.29", "2.7.30"}:
             # 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" /
@@ -1447,6 +1447,75 @@ class InstalledForgeUpdateTests(unittest.TestCase):
         with self.assertRaisesRegex(update.InstalledForgeUpdateError, "noncanonical"):
             update.validate_qualified_artifact(changed)
 
+    def test_2727_to_2728_same_schema_release_preserves_history_and_requires_composition(self):
+        before = self._same_schema39_transition(existing_version="2.7.27", target_version="2.7.28")
+        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["publication_receipt"]["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_2728_to_2729_same_schema_release_preserves_history_and_requires_composition(self):
+        before = self._same_schema39_transition(existing_version="2.7.28", target_version="2.7.29")
+        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_2729_to_2730_same_schema_release_preserves_history_and_requires_composition(self):
+        before = self._same_schema39_transition(existing_version="2.7.29", target_version="2.7.30")
+        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()
@@ -1512,8 +1581,11 @@ 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"} else 38
-        previous_version = {"2.7.26": "2.7.25", "2.7.27": "2.7.26"}.get(target_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
+        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",
+        }.get(target_version)
         if previous_version is not None:
             RuntimeBootstrap(data_root=self.data_root, forge_version=previous_version).open().close()
         legacy_interpreter = Path(os.environ.get("FORGE_LEGACY_INTERPRETER", sys.executable))