forge-autonomy 2.7.24__tar.gz → 2.7.26__tar.gz

{forge_autonomy-2.7.24 → forge_autonomy-2.7.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forge-autonomy
-Version: 2.7.24
+Version: 2.7.26
 Summary: Forge mission planning, producer contracts, and evidence interpretation runtime.
 Author: Forge maintainers
 License-Expression: Apache-2.0
@@ -134,6 +134,16 @@ and atomically activates a versioned slot. It is not packaged as a Forge
 Runtime command and does not replace Forge Platform's normal installer/update
 composition boundary.
 
+## Mission 3 acceptance preflight
+
+The [18 September 2026 Mission 3 preflight report](docs/operations/MISSION_3_PREFLIGHT_ACCEPTANCE_2026_09_18.md)
+records `AUTONOMY_E2E_ACCEPTANCE = NIET_GEHAALD` and
+`MISSION_EXECUTION_STATE = NIET_GESTART`. Installed artifact and authenticated
+peer checks passed, but the installed criterion-to-evidence composition cannot
+prove the required dynamic successor Action. No production reset or Mission was
+started. The report includes the unchanged C01–C20 and preserves historical
+failures; it does not authorize a repair or replacement attempt.
+
 ## Operational-history reset
 
 Forge schema 38 provides a bounded, product-owned maintenance service under

{forge_autonomy-2.7.24 → forge_autonomy-2.7.26}/README.md

@@ -117,6 +117,16 @@ and atomically activates a versioned slot. It is not packaged as a Forge
 Runtime command and does not replace Forge Platform's normal installer/update
 composition boundary.
 
+## Mission 3 acceptance preflight
+
+The [18 September 2026 Mission 3 preflight report](docs/operations/MISSION_3_PREFLIGHT_ACCEPTANCE_2026_09_18.md)
+records `AUTONOMY_E2E_ACCEPTANCE = NIET_GEHAALD` and
+`MISSION_EXECUTION_STATE = NIET_GESTART`. Installed artifact and authenticated
+peer checks passed, but the installed criterion-to-evidence composition cannot
+prove the required dynamic successor Action. No production reset or Mission was
+started. The report includes the unchanged C01–C20 and preserves historical
+failures; it does not authorize a repair or replacement attempt.
+
 ## Operational-history reset
 
 Forge schema 38 provides a bounded, product-owned maintenance service under

{forge_autonomy-2.7.24 → forge_autonomy-2.7.26}/forge/__main__.py

@@ -122,6 +122,29 @@ def main(argv: list[str] | None = None) -> int:
     finish_reset.add_argument("--verification-digest")
     finish_reset.add_argument("--cancel-before-apply", action="store_true")
     subparsers.add_parser("status", help="print read-only runtime status as JSON")
+    mission = subparsers.add_parser("mission", help="govern and run one selected Mission")
+    mission_commands = mission.add_subparsers(dest="mission_command", required=True)
+    for name, description in (
+        ("inspect", "validate Mission input and evidence fit without allocation"),
+        ("approve-business", "record canonical Business approval"),
+        ("approve-architecture", "record canonical Architecture approval"),
+        ("admit", "allocate and admit the canonically approved Mission"),
+    ):
+        command = mission_commands.add_parser(name, help=description)
+        command.add_argument("--input", required=True)
+    for name, description in (
+        ("run", "start once and control the selected Mission to a terminal or declared stop"),
+        ("reopen", "continue the same durable Mission execution"),
+        ("status", "read the exact Mission status and result"),
+        ("stop", "request a controlled foreground stop"),
+    ):
+        command = mission_commands.add_parser(name, help=description)
+        command.add_argument("--mission-id", required=True)
+        if name == "run":
+            command.add_argument("--repository-truth", required=True)
+        if name in {"run", "reopen"}:
+            command.add_argument("--poll-seconds", type=float, default=1.0)
+            command.add_argument("--maximum-wait-seconds", type=float, default=3600.0)
     execution_host = subparsers.add_parser("execution-host", help="manage the selected Execution Host peer")
     execution_host_commands = execution_host.add_subparsers(dest="execution_host_command", required=True)
     configure = execution_host_commands.add_parser("configure", help="persist one explicit EP peer binding")
@@ -159,6 +182,41 @@ def main(argv: list[str] | None = None) -> int:
         help="bounded interactive setup timeout in seconds (maximum: 120)",
     )
     args = parser.parse_args(argv)
+    if args.command == "mission":
+        from . import mission_cli
+        try:
+            command = args.mission_command
+            if command == "inspect":
+                result = mission_cli.inspect(args.input)
+            elif command in {"approve-business", "approve-architecture"}:
+                if args.data_root is None:
+                    raise ValueError("--data-root is required for Mission governance")
+                result = mission_cli.approve(args.data_root, args.input,
+                                             "business" if command == "approve-business" else "architecture")
+            elif command == "admit":
+                if args.data_root is None:
+                    raise ValueError("--data-root is required for Mission admission")
+                result = mission_cli.admit(args.data_root, args.input)
+            elif command == "status":
+                result = mission_cli.status(args.data_root, args.mission_id)
+            elif command == "stop":
+                result = mission_cli.stop(args.data_root, args.mission_id)
+            else:
+                if args.data_root is None:
+                    raise ValueError("--data-root is required for Mission execution")
+                result = mission_cli.run(args.data_root, args.mission_id,
+                    truth_path=args.repository_truth if command == "run" else None,
+                    poll_seconds=args.poll_seconds, maximum_wait_seconds=args.maximum_wait_seconds)
+            print(json.dumps(result, sort_keys=True))
+            if command == "inspect":
+                return 0 if result["status"] == "VALID" else 2
+            if command == "stop":
+                return 0 if result["stop_requested"] else 2
+            if command in {"run", "reopen"}:
+                return 0 if result["status"] == "COMPLETED" else 2
+            return 0
+        except (OSError, ValueError, KeyError, sqlite3.Error, RuntimeError, PermissionError) as error:
+            return _failure("mission " + args.mission_command, error)
     if args.command == "server" and args.server_command == "init":
         from .runtime import RuntimeBootstrap
         database = RuntimeBootstrap(data_root=args.data_root, forge_version=canonical_version()).open()

{forge_autonomy-2.7.24 → forge_autonomy-2.7.26}/forge/architecture/workspace.py

@@ -107,7 +107,8 @@ class ArchitectureWorkspace:
         mission, revision = self._current(mission_id)
         if mission.status is not ArchitectureMissionStatus.ARCHITECTURE_REVIEW:
             raise ArchitectureWorkspaceError("only Missions in architecture_review may be refined")
-        allowed = {"scope", "engineering_constraints", "acceptance_criteria", "technical_assumptions", "dependencies", "required_capabilities", "required_disciplines", "risks"}
+        allowed = {"scope", "engineering_constraints", "acceptance_criteria", "technical_assumptions", "dependencies", "required_capabilities", "required_disciplines", "risks", "criterion_assessment_contracts", "maximum_actions",
+                   "maximum_consecutive_no_progress_actions", "repository_evidence_source"}
         if not changes or set(changes) - allowed:
             raise ArchitectureWorkspaceError("architecture refinement may update only engineering governance fields")
         refined = replace(mission, **changes)

forge_autonomy-2.7.26/forge/completion/host_control_observer.py

@@ -0,0 +1,164 @@
+"""Interpret EP-owned validation records without executing a command."""
+from __future__ import annotations
+
+from hashlib import sha256
+import json
+import re
+from typing import Any, Mapping
+
+from forge.models.criterion_observation import CriterionObservation, canonical_digest
+from forge.models.mission_completion import mission_criterion_id
+
+
+_DIGEST = re.compile(r"sha256:[0-9a-f]{64}\Z")
+
+
+def _canonical(value: object) -> str:
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False, allow_nan=False)
+
+
+def _valid_digest(value: object) -> bool:
+    return isinstance(value, str) and _DIGEST.fullmatch(value) is not None
+
+
+def approved_observation_selector(requirement) -> str | None:
+    """Identify an EP unittest observation from its exact approved binding."""
+    try:
+        command = json.loads(requirement.command)
+    except (TypeError, ValueError):
+        return None
+    if (not isinstance(command, list) or len(command) != 4
+            or command[:3] != ["{python}", "-m", "unittest"]
+            or not isinstance(command[3], str)):
+        return None
+    selector = command[3]
+    if (len(selector) > 100 or re.fullmatch(
+            r"[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)+", selector) is None):
+        return None
+    validation_id = "unittest_selector_" + sha256(selector.encode("utf-8")).hexdigest()[:16]
+    if (requirement.validation_id != validation_id
+            or requirement.control_identity != "python3 -m unittest " + selector
+            or requirement.control_category != "repository"
+            or requirement.validation_profile_version != "1.0"
+            or requirement.profile_reference != "validation-profile-registry:FULL@1.0"):
+        return None
+    return selector
+
+
+def _control_matches(requirement, context: Mapping[str, Any], run_id: str,
+                     validated_revision: str | None) -> tuple[bool, str, dict[str, object] | None]:
+    if not requirement.control_definition_digest:
+        return False, "APPROVED_CONTROL_DEFINITION_MISSING", None
+    version = context.get("contract_version")
+    if version not in {"1.0", "1.1"} or context.get("status") != "AVAILABLE":
+        return False, "HOST_CONTROL_EVIDENCE_UNAVAILABLE", None
+    currentness = context.get("currentness")
+    if (validated_revision is None or context.get("candidate_sha") != validated_revision
+            or context.get("profile_currentness_conflict") is not False
+            or not isinstance(currentness, int) or isinstance(currentness, bool) or currentness < 0
+            or not _valid_digest(context.get("profile_digest"))):
+        return False, "HOST_CONTROL_CANDIDATE_OR_PROFILE_MISMATCH", None
+    if (context.get("validation_profile_version") != requirement.validation_profile_version
+            or context.get("profile_reference") != requirement.profile_reference):
+        return False, "HOST_CONTROL_PROFILE_VERSION_MISMATCH", None
+    controls = context.get("controls")
+    required = context.get("required_validation_controls")
+    if not isinstance(controls, Mapping) or not isinstance(required, list):
+        return False, "HOST_CONTROL_BINDINGS_INVALID", None
+    observation_controls = context.get("observation_validation_controls", []) if version == "1.1" else []
+    if not isinstance(observation_controls, list):
+        return False, "HOST_CONTROL_BINDINGS_INVALID", None
+    required_binding = required.count(requirement.validation_id) == 1
+    observation_matches = [item for item in observation_controls
+                           if isinstance(item, Mapping)
+                           and item.get("validation_id") == requirement.validation_id]
+    observation_binding = (version == "1.1" and len(observation_matches) == 1
+                           and approved_observation_selector(requirement) is not None)
+    if required_binding == observation_binding:
+        return False, "HOST_CONTROL_BINDING_MISSING_OR_DUPLICATE", None
+    command_identity = json.loads(requirement.command)
+    definition = {"validation_profile_version": context["validation_profile_version"],
+                  "profile_reference": context["profile_reference"],
+                  "validation_id": requirement.validation_id,
+                  "category": requirement.control_category,
+                  "control_identity": requirement.control_identity,
+                  "command_identity": command_identity}
+    digest = "sha256:" + sha256(_canonical(definition).encode("utf-8")).hexdigest()
+    if digest != requirement.control_definition_digest:
+        return False, "HOST_CONTROL_DEFINITION_MISMATCH", None
+    control = (controls.get(requirement.validation_id) if required_binding
+               else observation_matches[0])
+    if not isinstance(control, Mapping):
+        return False, "HOST_CONTROL_RECORD_MISSING", None
+    if (control.get("validation_id") != requirement.validation_id
+            or control.get("category") != requirement.control_category
+            or control.get("control_identity") != requirement.control_identity
+            or control.get("control_definition_digest") != digest
+            or control.get("required_for_profile") is not required_binding
+            or control.get("currentness") != currentness):
+        return False, "HOST_CONTROL_RECORD_CONFLICT", None
+    if (control.get("execution_status") != "EXECUTED" or control.get("result") != "PASS"
+            or control.get("evidence_authority") != "command_terminal"
+            or control.get("evidence_ref") != "command_terminal"
+            or control.get("exit_code") != 0
+            or not isinstance(control.get("command_id"), str) or not control["command_id"]):
+        return False, "HOST_CONTROL_NOT_EXECUTED_AND_PASSED", None
+    detail = control.get("result_detail")
+    if not isinstance(detail, Mapping):
+        return False, "HOST_CONTROL_RESULT_DETAIL_MISSING", None
+    if (detail.get("status") != "AVAILABLE" or detail.get("capture_status") != "AVAILABLE"
+            or detail.get("schema") != "deterministic-validation-result-detail-v1"
+            or detail.get("run_id") != run_id
+            or detail.get("command_id") != control["command_id"]
+            or detail.get("validation_id") != requirement.validation_id
+            or detail.get("exit_code") != 0
+            or not isinstance(detail.get("artifact_id"), str) or not detail["artifact_id"]
+            or not _valid_digest(detail.get("digest")) or not _valid_digest(detail.get("output_digest"))):
+        return False, "HOST_CONTROL_RESULT_DETAIL_INVALID", None
+    count = detail.get("test_count")
+    minimum_test_count = (max(1, requirement.minimum_test_count) if observation_binding
+                          else requirement.minimum_test_count)
+    if minimum_test_count and (not isinstance(count, int) or isinstance(count, bool)
+                               or count < minimum_test_count
+                               or detail.get("test_count_source") != "unittest_terminal_summary"):
+        return False, "HOST_CONTROL_TEST_COUNT_INSUFFICIENT", None
+    return True, "APPROVED_HOST_CONTROL_EXECUTED_AND_PASSED", {
+        "validation_id": requirement.validation_id, "control_identity": requirement.control_identity,
+        "control_definition_digest": digest, "validation_profile_version": requirement.validation_profile_version,
+        "profile_reference": requirement.profile_reference, "category": requirement.control_category,
+        "candidate_sha": validated_revision, "run_id": run_id, "command_id": control["command_id"],
+        "result_detail_digest": detail["digest"], "output_digest": detail["output_digest"],
+        "test_count": count, "execution_status": "EXECUTED", "result": "PASS", "exit_code": 0,
+    }
+
+
+class HostControlCriterionObserver:
+    def observe(self, mission, reference, evidence) -> tuple[CriterionObservation, ...]:
+        context = evidence.validation_controls
+        observations = []
+        for contract in mission.criterion_assessment_contracts:
+            for requirement in contract.requirements:
+                if requirement.kind != "host_control":
+                    continue
+                control_context = context if isinstance(context, Mapping) else {}
+                delivered = reference.repository_revision
+                candidate = reference.candidate_revision
+                if (contract.validity_policy == "current_revision" and candidate != delivered
+                        and control_context.get("candidate_sha") == candidate):
+                    valid, reason, measured = False, "HOST_CONTROL_DELIVERY_REVISION_NOT_VALIDATED", None
+                else:
+                    expected_revision = (delivered if contract.validity_policy == "current_revision" else
+                                         delivered if control_context.get("candidate_sha") == delivered else candidate)
+                    valid, reason, measured = _control_matches(
+                        requirement, control_context, evidence.host_run_id, expected_revision)
+                observations.append(CriterionObservation(
+                    mission.id, canonical_digest(mission.to_dict()), mission_criterion_id(mission.id, contract.criterion),
+                    contract.digest, requirement.requirement_id, reference.receipt_id, reference.action_id,
+                    reference.report_id, reference.repository_revision, reference.repository_evidence_digest,
+                    "host_control", requirement.control_identity, "ep-terminal-artifact",
+                    reference.repository_evidence_digest if valid else None,
+                    _canonical(measured) if valid else None, "PASS" if valid else "UNAVAILABLE", reason,
+                    requirement_digest=requirement.digest, candidate_revision=reference.candidate_revision,
+                    schema_version="1.1",
+                ))
+        return tuple(observations)

forge_autonomy-2.7.26/forge/completion/mission.py

@@ -0,0 +1,229 @@
+"""Deterministic Architecture Mission completion evaluation."""
+
+from __future__ import annotations
+
+from hashlib import sha256
+import json
+from typing import Any, Mapping, Sequence
+
+from forge.models.architecture_mission import ArchitectureMission
+from forge.models.mission_completion import (
+    CanonicalExecutionEvidenceReference,
+    MissionCompletionEvaluation,
+    MissionCompletionEvidence,
+    MissionCriterionEvaluation,
+    MissionCriterionEvaluationStatus,
+    RepositoryTruthReference,
+    mission_criterion_id,
+)
+
+
+class MissionCompletionEvaluationError(ValueError):
+    """Completion input is stale, malformed, or outside the approved Mission."""
+
+
+def _digest(value: object) -> str:
+    return "sha256:" + sha256(
+        json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+    ).hexdigest()
+
+
+def _truth_reference(document: Mapping[str, Any]) -> RepositoryTruthReference:
+    try:
+        values = tuple(document[item] for item in ("source_id", "revision", "locator", "content_digest"))
+        if any(not isinstance(item, str) or not item for item in values):
+            raise TypeError
+        return RepositoryTruthReference(*values)
+    except (KeyError, TypeError, ValueError) as error:
+        raise MissionCompletionEvaluationError("current Repository Truth provenance is incomplete") from error
+
+
+def _canonical_execution_references(
+    mission_id: str, evidence: Sequence[Mapping[str, Any]],
+) -> dict[str, CanonicalExecutionEvidenceReference]:
+    references: dict[str, CanonicalExecutionEvidenceReference] = {}
+    for document in evidence:
+        if document.get("outcome") != "complete":
+            continue
+        repository = document.get("repository_evidence")
+        if not isinstance(repository, Mapping) or repository.get("mission_id") != mission_id:
+            continue
+        try:
+            values = (
+                document["receipt_id"], repository["action_id"], document["report_id"],
+                repository["repository_revision"], repository["content_digest"],
+            )
+            if any(not isinstance(item, str) or not item for item in values):
+                raise TypeError
+            reference = CanonicalExecutionEvidenceReference(*values, candidate_revision=repository.get('candidate_revision'))
+        except (KeyError, TypeError, ValueError):
+            continue
+        if any(document.get(key) != repository.get(key) for key in ("correlation_id", "host_run_id", "report_id")):
+            continue
+        previous = references.get(reference.receipt_id)
+        if previous is not None and previous != reference:
+            raise MissionCompletionEvaluationError("execution receipt identity binds conflicting terminal evidence")
+        references[reference.receipt_id] = reference
+    return references
+
+
+def _host_control_observation_matches(observation, requirement, validity_policy: str) -> bool:
+    if (observation.schema_version != "1.1" or observation.result != "PASS"
+            or observation.reason != "APPROVED_HOST_CONTROL_EXECUTED_AND_PASSED"
+            or observation.content_digest != observation.repository_evidence_digest
+            or observation.observed_json is None):
+        return False
+    try:
+        record = json.loads(observation.observed_json)
+    except (TypeError, ValueError):
+        return False
+    return (isinstance(record, dict)
+            and record.get("validation_id") == requirement.validation_id
+            and record.get("control_identity") == requirement.control_identity
+            and record.get("control_definition_digest") == requirement.control_definition_digest
+            and record.get("validation_profile_version") == requirement.validation_profile_version
+            and record.get("profile_reference") == requirement.profile_reference
+            and record.get("category") == requirement.control_category
+            and (record.get("candidate_sha") == observation.repository_revision
+                 if validity_policy == "current_revision" else
+                 record.get("candidate_sha") in {observation.candidate_revision, observation.repository_revision})
+            and record.get("execution_status") == "EXECUTED"
+            and record.get("result") == "PASS" and record.get("exit_code") == 0
+            and (requirement.minimum_test_count == 0 or
+                 isinstance(record.get("test_count"), int)
+                 and not isinstance(record["test_count"], bool)
+                 and record["test_count"] >= requirement.minimum_test_count))
+
+
+class MissionCompletionEvaluator:
+    """Interpret approved predicates over Forge-observed facts; never provider PASS."""
+
+    def evaluate(self, mission, repository_truth, execution_evidence, evidence):
+        if not mission.acceptance_criteria:
+            raise MissionCompletionEvaluationError("approved Mission has no acceptance criteria")
+        mission_digest = _digest(mission.to_dict())
+        truth = _truth_reference(repository_truth)
+        identifiers = {mission_criterion_id(mission.id, criterion): criterion for criterion in mission.acceptance_criteria}
+        canonical = _canonical_execution_references(mission.id, execution_evidence)
+        contracts = {mission_criterion_id(mission.id, item.criterion): item
+                     for item in mission.criterion_assessment_contracts}
+        bindings = {} if evidence is None else {item.criterion_id: item for item in evidence.bindings}
+        if evidence is not None:
+            if evidence.mission_id != mission.id or evidence.mission_digest != mission_digest:
+                raise MissionCompletionEvaluationError("completion evidence does not bind the approved Mission")
+            if set(bindings) - set(identifiers):
+                raise MissionCompletionEvaluationError("completion evidence references an unknown Mission criterion")
+        evaluations = []
+        for criterion_id, criterion in identifiers.items():
+            contract, binding = contracts.get(criterion_id), bindings.get(criterion_id)
+            reason = None
+            if contract is None:
+                reason = "APPROVED_ASSESSMENT_CONTRACT_MISSING"
+            elif evidence is not None and evidence.schema_version != "2.0":
+                reason = "LEGACY_ASSOCIATIONS_ARE_NOT_SUBSTANTIVE_EVIDENCE"
+            elif binding is None:
+                reason = "MISSING_AUTHORITATIVE_OBSERVATION"
+            elif binding.contract_digest != contract.digest:
+                reason = "ASSESSMENT_CONTRACT_MISMATCH"
+            elif binding.repository_truth != truth:
+                reason = "STALE_REPOSITORY_TRUTH"
+            elif any(canonical.get(ref.receipt_id) != ref for ref in binding.execution_evidence):
+                reason = "NON_CANONICAL_EXECUTION_EVIDENCE"
+            references = () if binding is None else binding.execution_evidence
+            observations = () if binding is None else binding.observations
+            requirement_results = []
+            if reason is None:
+                reference_map = {ref.receipt_id: ref for ref in references}
+                seen = {}
+                for observation in observations:
+                    reference = reference_map.get(observation.receipt_id)
+                    if (reference is None or observation.mission_id != mission.id
+                            or observation.mission_digest != mission_digest
+                            or observation.criterion_id != criterion_id
+                            or observation.contract_digest != contract.digest
+                            or observation.action_id != reference.action_id
+                            or observation.report_id != reference.report_id
+                            or observation.repository_revision != reference.repository_revision
+                            or observation.candidate_revision != reference.candidate_revision
+                            or observation.repository_evidence_digest != reference.repository_evidence_digest):
+                        reason = "OBSERVATION_PROVENANCE_MISMATCH"
+                        break
+                    identity = (observation.receipt_id, observation.requirement_id)
+                    if identity in seen and seen[identity] != observation:
+                        raise MissionCompletionEvaluationError("conflicting immutable criterion observations")
+                    seen[identity] = observation
+                    if observation.requirement_id not in {req.requirement_id for req in contract.requirements}:
+                        raise MissionCompletionEvaluationError("observation references unknown criterion requirement")
+            if reason is None:
+                for requirement in contract.requirements:
+                    candidates = [obs for obs in observations if obs.requirement_id == requirement.requirement_id]
+                    if contract.validity_policy == "current_revision":
+                        candidates = [obs for obs in candidates if obs.repository_revision == truth.revision]
+                    source = mission.repository_evidence_source
+                    if requirement.kind == "host_control":
+                        if not requirement.control_definition_digest:
+                            result, why, matched = "UNSATISFIED", "UNSUPPORTED_AUTHORITATIVE_EVIDENCE_SOURCE", ()
+                        elif any(obs.source_kind != "host_control" or obs.source_identity != requirement.control_identity
+                                 or obs.artifact_path != "ep-terminal-artifact"
+                                 or obs.requirement_digest != requirement.digest or obs.json_pointer != ""
+                                 for obs in candidates):
+                            result, why, matched = "UNSATISFIED", "OBSERVATION_SOURCE_MISMATCH", ()
+                        elif not candidates:
+                            result, why, matched = "UNSATISFIED", "CURRENT_OBSERVATION_MISSING", ()
+                        else:
+                            if contract.validity_policy == "historical_delivery":
+                                passing = [obs for index, obs in enumerate(candidates)
+                                           if _host_control_observation_matches(obs, requirement, contract.validity_policy)
+                                           and not any(later.repository_revision == obs.repository_revision
+                                                       and not _host_control_observation_matches(later, requirement, contract.validity_policy)
+                                                       for later in candidates[index + 1:])]
+                                selected = passing[-1] if passing else candidates[-1]
+                            else:
+                                selected = candidates[-1]
+                            proven = _host_control_observation_matches(selected, requirement, contract.validity_policy)
+                            result = "PROVEN" if proven else "UNSATISFIED"
+                            why = "APPROVED_HOST_CONTROL_EXECUTED_AND_PASSED" if proven else selected.reason
+                            matched = (selected.id,)
+                    elif requirement.kind != "repository_json":
+                        result, why, matched = "UNSATISFIED", "UNSUPPORTED_AUTHORITATIVE_EVIDENCE_SOURCE", ()
+                    elif source is None:
+                        result, why, matched = "UNSATISFIED", "APPROVED_REPOSITORY_SOURCE_MISSING", ()
+                    elif any(obs.source_kind != requirement.kind or obs.source_identity != source.github_repository
+                             or obs.artifact_path != requirement.artifact_path
+                             or obs.requirement_digest != requirement.digest
+                             or obs.json_pointer != requirement.json_pointer for obs in candidates):
+                        result, why, matched = "UNSATISFIED", "OBSERVATION_SOURCE_MISMATCH", ()
+                    elif not candidates:
+                        result, why, matched = "UNSATISFIED", "CURRENT_OBSERVATION_MISSING", ()
+                    elif any(len({(obs.content_digest, obs.observed_json, obs.result)
+                                  for obs in candidates if obs.repository_revision == revision
+                                  and obs.result != 'UNAVAILABLE'}) > 1
+                             for revision in {obs.repository_revision for obs in candidates}):
+                        result, why, matched = "UNSATISFIED", "CONFLICTING_IMMUTABLE_ARTIFACT_OBSERVATIONS", ()
+                    else:
+                        # A historical-delivery assertion describes an accomplished event.
+                        # A new current-property failure is not a rewrite of that old event.
+                        passing = [obs for obs in candidates if obs.result == "PASS"
+                                   and obs.observed_json == requirement.expected_json
+                                   and obs.content_digest is not None]
+                        selected = passing[-1] if passing and contract.validity_policy == "historical_delivery" else candidates[-1]
+                        proven = (selected.result == "PASS" and selected.observed_json == requirement.expected_json
+                                  and selected.content_digest is not None)
+                        result = "PROVEN" if proven else "UNSATISFIED"
+                        why = "APPROVED_JSON_ASSERTION_MATCHED" if proven else selected.reason
+                        matched = (selected.id,)
+                    requirement_results.append({"requirement_id": requirement.requirement_id,
+                        "requirement_digest": requirement.digest, "status": result, "reason": why,
+                        "observation_ids": list(matched)})
+                reason = ("ALL_APPROVED_REQUIREMENTS_PROVEN" if all(item["status"] == "PROVEN" for item in requirement_results)
+                          else "REQUIRED_OBSERVATIONS_UNPROVEN")
+            status = (MissionCriterionEvaluationStatus.PROVEN if reason == "ALL_APPROVED_REQUIREMENTS_PROVEN"
+                      else MissionCriterionEvaluationStatus.UNSATISFIED)
+            evaluations.append(MissionCriterionEvaluation(
+                criterion_id, criterion, status, reason, references, truth,
+                None if contract is None else contract.digest, tuple(requirement_results), observations,
+            ))
+        return MissionCompletionEvaluation(
+            mission.id, mission_digest, tuple(evaluations), None if evidence is None else evidence.digest,
+            evidence=evidence,
+        )

forge_autonomy-2.7.26/forge/completion/repository_observer.py

@@ -0,0 +1,132 @@
+"""Bounded read-only observations at an approved immutable repository revision.
+
+Only structural facts explicitly approved by Architecture are assessed. This
+does not execute repository code or interpret artifacts as behavioral test PASS.
+"""
+from __future__ import annotations
+
+from hashlib import sha256
+import json
+from typing import Any
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote
+from urllib.request import Request, HTTPRedirectHandler, build_opener
+
+from forge.models.criterion_observation import CriterionObservation, canonical_digest
+from forge.models.mission_completion import mission_criterion_id
+
+
+class RepositoryObservationUnavailable(ValueError):
+    pass
+
+
+class _NoRedirect(HTTPRedirectHandler):
+    def redirect_request(self, *args, **kwargs):
+        raise RepositoryObservationUnavailable('REPOSITORY_SOURCE_REDIRECT_REJECTED')
+
+
+class GitHubRepositoryArtifactReader:
+    """Public HTTPS source only; no local checkout, token discovery or arbitrary URL."""
+
+    maximum_bytes = 1024 * 1024
+
+    def read(self, repository: str, revision: str, path: str) -> bytes:
+        from forge.models.criterion_assessment import ApprovedRepositoryEvidenceSource, CriterionEvidenceRequirement
+        ApprovedRepositoryEvidenceSource('validation', repository)
+        CriterionEvidenceRequirement('validation', kind='repository_json', artifact_path=path,
+                                     expected_json='null')
+        if len(revision) != 40 or any(c not in '0123456789abcdef' for c in revision):
+            raise RepositoryObservationUnavailable('IMMUTABLE_REPOSITORY_REVISION_REQUIRED')
+        url = 'https://raw.githubusercontent.com/' + repository + '/' + revision + '/' + quote(path, safe='/')
+        request = Request(url, headers={'Accept': 'application/json', 'User-Agent': 'Forge-criterion-observer/1.0'})
+        try:
+            with build_opener(_NoRedirect()).open(request, timeout=15) as response:
+                data = response.read(self.maximum_bytes + 1)
+        except HTTPError as error:
+            code = 'REPOSITORY_ARTIFACT_ABSENT' if error.code == 404 else 'REPOSITORY_SOURCE_UNAVAILABLE'
+            raise RepositoryObservationUnavailable(code) from error
+        except (URLError, TimeoutError, OSError) as error:
+            raise RepositoryObservationUnavailable('REPOSITORY_SOURCE_UNAVAILABLE') from error
+        if len(data) > self.maximum_bytes:
+            raise RepositoryObservationUnavailable('REPOSITORY_ARTIFACT_SIZE_LIMIT')
+        return data
+
+
+def _json(data: bytes) -> Any:
+    def pairs(values):
+        result = {}
+        for key, value in values:
+            if key in result:
+                raise ValueError('duplicate JSON key')
+            result[key] = value
+        return result
+    def invalid_constant(_value):
+        raise ValueError('non-finite JSON number')
+    return json.loads(data.decode('utf-8'), object_pairs_hook=pairs, parse_constant=invalid_constant)
+
+
+def _pointer(value: Any, pointer: str) -> Any:
+    if pointer == '':
+        return value
+    for part in pointer[1:].split('/'):
+        key = part.replace('~1', '/').replace('~0', '~')
+        if isinstance(value, list):
+            if not key.isascii() or not key.isdigit() or (key != '0' and key.startswith('0')):
+                raise KeyError(key)
+            value = value[int(key)]
+        elif isinstance(value, dict):
+            value = value[key]
+        else:
+            raise KeyError(key)
+    return value
+
+
+class RepositoryCriterionObserver:
+    """Collect facts from the approved source for the exact accepted delivery."""
+
+    def __init__(self, reader=None):
+        self.reader = reader or GitHubRepositoryArtifactReader()
+
+    def observe(self, mission, reference, repository_id: str) -> tuple[CriterionObservation, ...]:
+        source = mission.repository_evidence_source
+        if source is None:
+            return ()
+        if source.repository_id != repository_id:
+            raise ValueError('approved Repository Evidence source differs from the installed repository')
+        observations = []
+        cache: dict[str, bytes | RepositoryObservationUnavailable] = {}
+        for contract in mission.criterion_assessment_contracts:
+            for requirement in contract.requirements:
+                if requirement.kind != 'repository_json':
+                    continue
+                path = requirement.artifact_path
+                if path not in cache:
+                    try:
+                        cache[path] = self.reader.read(source.github_repository, reference.repository_revision, path)
+                    except RepositoryObservationUnavailable as error:
+                        cache[path] = error
+                data = cache[path]
+                observed_json, content_digest = None, None
+                if isinstance(data, RepositoryObservationUnavailable):
+                    result, reason = 'UNAVAILABLE', str(data)
+                else:
+                    content_digest = 'sha256:' + sha256(data).hexdigest()
+                    try:
+                        value = _pointer(_json(data), requirement.json_pointer)
+                        observed_json = json.dumps(value, sort_keys=True, separators=(',', ':'),
+                                                   ensure_ascii=False, allow_nan=False)
+                        result = 'PASS' if observed_json == requirement.expected_json else 'FAIL'
+                        reason = 'APPROVED_JSON_ASSERTION_MATCHED' if result == 'PASS' else 'JSON_ASSERTION_MISMATCH'
+                    except (KeyError, IndexError):
+                        result, reason = 'FAIL', 'JSON_POINTER_ABSENT'
+                    except (ValueError, UnicodeError, RecursionError):
+                        result, reason = 'FAIL', 'INVALID_JSON_ARTIFACT'
+                observations.append(CriterionObservation(
+                    mission.id, canonical_digest(mission.to_dict()), mission_criterion_id(mission.id, contract.criterion),
+                    contract.digest, requirement.requirement_id, reference.receipt_id, reference.action_id,
+                    reference.report_id, reference.repository_revision, reference.repository_evidence_digest,
+                    'repository_json', source.github_repository, path, content_digest, observed_json, result, reason,
+                    requirement_digest=requirement.digest, json_pointer=requirement.json_pointer,
+                    candidate_revision=reference.candidate_revision,
+                ))
+        return tuple(observations)