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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forge-autonomy
-Version: 2.7.26
+Version: 2.7.28
 Summary: Forge mission planning, producer contracts, and evidence interpretation runtime.
 Author: Forge maintainers
 License-Expression: Apache-2.0
@@ -134,6 +134,17 @@ 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.
 
+The later [MISSION-0017 vertical release and installation completion](docs/operations/MISSION_0017_VERTICAL_RELEASE_INSTALLATION_COMPLETION.md)
+records the isolated two-Action qualification, protected Forge and EP product
+delivery, exact published artifacts, scoped CENTRAL installation and the
+remaining Mission-3 policy boundary. It does not authorize a production reset
+or Mission start.
+
+The subsequent [repository-bound autonomous assurance delivery](docs/operations/REPOSITORY_BOUND_AUTONOMOUS_ASSURANCE_COMPLETION.md)
+records EP's versioned owner profile, isolated protected delivery qualification,
+release and CENTRAL target configuration. It keeps Mission 3 and the
+clean-CENTRAL procedure separate.
+
 ## Mission 3 acceptance preflight
 
 The [18 September 2026 Mission 3 preflight report](docs/operations/MISSION_3_PREFLIGHT_ACCEPTANCE_2026_09_18.md)

forge_autonomy-2.7.26/PKG-INFO → forge_autonomy-2.7.28/README.md

@@ -1,20 +1,3 @@
-Metadata-Version: 2.4
-Name: forge-autonomy
-Version: 2.7.26
-Summary: Forge mission planning, producer contracts, and evidence interpretation runtime.
-Author: Forge maintainers
-License-Expression: Apache-2.0
-Project-URL: Homepage, https://github.com/pcvantol/forge
-Project-URL: Repository, https://github.com/pcvantol/forge
-Project-URL: Issues, https://github.com/pcvantol/forge/issues
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-
 # Forge
 
 ## Python distribution
@@ -134,6 +117,17 @@ 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.
 
+The later [MISSION-0017 vertical release and installation completion](docs/operations/MISSION_0017_VERTICAL_RELEASE_INSTALLATION_COMPLETION.md)
+records the isolated two-Action qualification, protected Forge and EP product
+delivery, exact published artifacts, scoped CENTRAL installation and the
+remaining Mission-3 policy boundary. It does not authorize a production reset
+or Mission start.
+
+The subsequent [repository-bound autonomous assurance delivery](docs/operations/REPOSITORY_BOUND_AUTONOMOUS_ASSURANCE_COMPLETION.md)
+records EP's versioned owner profile, isolated protected delivery qualification,
+release and CENTRAL target configuration. It keeps Mission 3 and the
+clean-CENTRAL procedure separate.
+
 ## Mission 3 acceptance preflight
 
 The [18 September 2026 Mission 3 preflight report](docs/operations/MISSION_3_PREFLIGHT_ACCEPTANCE_2026_09_18.md)

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

@@ -181,6 +181,10 @@ def main(argv: list[str] | None = None) -> int:
         default=120.0,
         help="bounded interactive setup timeout in seconds (maximum: 120)",
     )
+    operations_api = subparsers.add_parser("operations-api", help="serve authenticated read-only runtime projections")
+    operations_api.add_argument("--credential-file", required=True)
+    operations_api.add_argument("--host", default="127.0.0.1")
+    operations_api.add_argument("--port", type=int, default=8765)
     args = parser.parse_args(argv)
     if args.command == "mission":
         from . import mission_cli
@@ -338,6 +342,14 @@ def main(argv: list[str] | None = None) -> int:
                 print(json.dumps(service.preflight(), sort_keys=True))
         except (PeerConfigurationError, ValueError) as error:
             return _failure(f"execution-host {args.execution_host_command}", error)
+    elif args.command == "operations-api":
+        if args.data_root is None:
+            return _failure("operations-api", ValueError("--data-root is required for operations-api"))
+        try:
+            from .operations_read_api import serve
+            serve(args.data_root, args.credential_file, host=args.host, port=args.port)
+        except (OSError, ValueError) as error:
+            return _failure("operations-api", error)
     return 0
 
 

forge_autonomy-2.7.28/forge/api/operations-read-openapi-v1.json

@@ -0,0 +1,416 @@
+{
+  "components": {
+    "schemas": {
+      "ErrorResponse": {
+        "additionalProperties": false,
+        "properties": {
+          "api_version": {
+            "const": "1"
+          },
+          "error": {
+            "additionalProperties": false,
+            "properties": {
+              "code": {
+                "minLength": 1,
+                "type": "string"
+              },
+              "message": {
+                "minLength": 1,
+                "type": "string"
+              }
+            },
+            "required": [
+              "code",
+              "message"
+            ],
+            "type": "object"
+          },
+          "read_only": {
+            "const": true
+          }
+        },
+        "required": [
+          "api_version",
+          "error",
+          "read_only"
+        ],
+        "type": "object"
+      },
+      "MissionResponse": {
+        "additionalProperties": false,
+        "properties": {
+          "api_version": {
+            "const": "1"
+          },
+          "availability": {
+            "const": "AVAILABLE"
+          },
+          "freshness": {
+            "enum": [
+              "CURRENT",
+              "STALE",
+              "UNKNOWN"
+            ]
+          },
+          "mission": {
+            "additionalProperties": true,
+            "properties": {
+              "action_ids": {
+                "items": {
+                  "type": "string"
+                },
+                "type": "array"
+              },
+              "actions": {
+                "items": {
+                  "additionalProperties": false,
+                  "properties": {
+                    "dependencies": {
+                      "items": {
+                        "type": "string"
+                      },
+                      "type": "array"
+                    },
+                    "expected_evidence": {
+                      "items": {
+                        "type": "string"
+                      },
+                      "type": "array"
+                    },
+                    "id": {
+                      "type": "string"
+                    },
+                    "intent_id": {
+                      "type": "string"
+                    },
+                    "intent_revision": {
+                      "type": "string"
+                    },
+                    "objective": {
+                      "type": "string"
+                    },
+                    "order": {
+                      "minimum": 1,
+                      "type": "integer"
+                    },
+                    "schema_version": {
+                      "type": "string"
+                    },
+                    "status": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "schema_version",
+                    "order",
+                    "id",
+                    "intent_id",
+                    "intent_revision",
+                    "dependencies",
+                    "status",
+                    "objective",
+                    "expected_evidence"
+                  ],
+                  "type": "object"
+                },
+                "type": "array"
+              },
+              "criteria": {
+                "items": {
+                  "type": "string"
+                },
+                "type": "array"
+              },
+              "evidence_lineage": {
+                "additionalProperties": false,
+                "properties": {
+                  "criterion_assessment": {
+                    "type": [
+                      "object",
+                      "null"
+                    ]
+                  },
+                  "criterion_assessment_history": {
+                    "items": {
+                      "type": [
+                        "object",
+                        "null"
+                      ]
+                    },
+                    "type": "array"
+                  },
+                  "execution_attempts": {
+                    "items": {
+                      "type": [
+                        "object",
+                        "null"
+                      ]
+                    },
+                    "type": "array"
+                  },
+                  "execution_evidence": {
+                    "type": [
+                      "object",
+                      "null"
+                    ]
+                  },
+                  "repository_truth": {
+                    "type": [
+                      "object",
+                      "null"
+                    ]
+                  }
+                },
+                "required": [
+                  "execution_evidence",
+                  "execution_attempts",
+                  "repository_truth",
+                  "criterion_assessment",
+                  "criterion_assessment_history"
+                ],
+                "type": "object"
+              },
+              "mission_id": {
+                "minLength": 1,
+                "type": "string"
+              },
+              "revision": {
+                "minimum": 1,
+                "type": "integer"
+              },
+              "status": {
+                "minLength": 1,
+                "type": "string"
+              }
+            },
+            "required": [
+              "mission_id",
+              "status",
+              "revision",
+              "action_ids",
+              "criteria",
+              "actions",
+              "evidence_lineage"
+            ],
+            "type": "object"
+          },
+          "read_only": {
+            "const": true
+          },
+          "source_observed_at": {
+            "format": "date-time",
+            "type": [
+              "string",
+              "null"
+            ]
+          }
+        },
+        "required": [
+          "api_version",
+          "availability",
+          "freshness",
+          "source_observed_at",
+          "read_only",
+          "mission"
+        ],
+        "type": "object"
+      },
+      "StatusResponse": {
+        "additionalProperties": false,
+        "properties": {
+          "api_version": {
+            "const": "1"
+          },
+          "availability": {
+            "enum": [
+              "AVAILABLE",
+              "UNAVAILABLE"
+            ]
+          },
+          "freshness": {
+            "enum": [
+              "CURRENT",
+              "STALE",
+              "UNKNOWN",
+              "UNAVAILABLE"
+            ]
+          },
+          "read_only": {
+            "const": true
+          },
+          "runtime": {
+            "additionalProperties": true,
+            "required": [
+              "product_version",
+              "data_root",
+              "initialized",
+              "runtime_status",
+              "execution_host_peer"
+            ],
+            "type": "object"
+          },
+          "source_observed_at": {
+            "format": "date-time",
+            "type": [
+              "string",
+              "null"
+            ]
+          }
+        },
+        "required": [
+          "api_version",
+          "availability",
+          "freshness",
+          "source_observed_at",
+          "read_only",
+          "runtime"
+        ],
+        "type": "object"
+      }
+    },
+    "securitySchemes": {
+      "bearerAuth": {
+        "scheme": "bearer",
+        "type": "http"
+      }
+    }
+  },
+  "info": {
+    "title": "Forge Operations Read API",
+    "version": "1.0.0"
+  },
+  "openapi": "3.1.0",
+  "paths": {
+    "/v1/missions/{mission_id}": {
+      "get": {
+        "description": "Read one authoritative installed Mission projection without changing it.",
+        "parameters": [
+          {
+            "in": "path",
+            "name": "mission_id",
+            "required": true,
+            "schema": {
+              "maxLength": 128,
+              "minLength": 1,
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/MissionResponse"
+                }
+              }
+            },
+            "description": "Mission projection is available"
+          },
+          "400": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "Mission reference is invalid"
+          },
+          "401": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "Bearer authentication is missing or invalid"
+          },
+          "404": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "Mission is missing"
+          },
+          "409": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "Mission identity is ambiguous or inconsistent"
+          },
+          "503": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "Mission projection is unavailable"
+          }
+        },
+        "security": [
+          {
+            "bearerAuth": []
+          }
+        ]
+      }
+    },
+    "/v1/status": {
+      "get": {
+        "description": "Read the authoritative installed Forge runtime status projection.",
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/StatusResponse"
+                }
+              }
+            },
+            "description": "Status projection is available"
+          },
+          "401": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "Bearer authentication is missing or invalid"
+          },
+          "503": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "Installed runtime projection is unavailable"
+          }
+        },
+        "security": [
+          {
+            "bearerAuth": []
+          }
+        ]
+      }
+    }
+  },
+  "servers": [
+    {
+      "url": "http://127.0.0.1:8765"
+    }
+  ]
+}

forge_autonomy-2.7.28/forge/api/operations-read-postman-v1.json

@@ -0,0 +1,60 @@
+{
+  "auth": {
+    "bearer": [{"key": "token", "type": "string", "value": "{{bearerCredential}}"}],
+    "type": "bearer"
+  },
+  "info": {
+    "name": "Forge Operations Read API V1",
+    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+  },
+  "item": [
+    {
+      "name": "Installed status",
+      "request": {"method": "GET", "url": "{{baseUrl}}/v1/status"},
+      "response": [{"code": 200, "name": "Available"}, {"code": 503, "name": "Unavailable"}]
+    },
+    {
+      "auth": {"type": "noauth"},
+      "name": "Installed status requires authentication",
+      "request": {"method": "GET", "url": "{{baseUrl}}/v1/status"},
+      "response": [{"code": 401, "name": "Authentication required"}]
+    },
+    {
+      "name": "Mission detail",
+      "request": {"method": "GET", "url": "{{baseUrl}}/v1/missions/{{missionId}}"},
+      "response": [{"code": 200, "name": "Available"}]
+    },
+    {
+      "auth": {"type": "noauth"},
+      "name": "Mission detail requires authentication",
+      "request": {"method": "GET", "url": "{{baseUrl}}/v1/missions/{{missionId}}"},
+      "response": [{"code": 401, "name": "Authentication required"}]
+    },
+    {
+      "name": "Mission reference invalid",
+      "request": {"method": "GET", "url": "{{baseUrl}}/v1/missions/%20"},
+      "response": [{"code": 400, "name": "Invalid"}]
+    },
+    {
+      "name": "Mission missing",
+      "request": {"method": "GET", "url": "{{baseUrl}}/v1/missions/MISSION-MISSING"},
+      "response": [{"code": 404, "name": "Missing"}]
+    },
+    {
+      "name": "Mission ambiguous",
+      "request": {"method": "GET", "url": "{{baseUrl}}/v1/missions/{{ambiguousMissionId}}"},
+      "response": [{"code": 409, "name": "Ambiguous"}]
+    },
+    {
+      "name": "Mission unavailable",
+      "request": {"method": "GET", "url": "{{baseUrl}}/v1/missions/{{missionId}}"},
+      "response": [{"code": 503, "name": "Unavailable"}]
+    }
+  ],
+  "variable": [
+    {"key": "baseUrl", "value": "http://127.0.0.1:8765"},
+    {"key": "bearerCredential", "value": ""},
+    {"key": "missionId", "value": "MISSION-0004"},
+    {"key": "ambiguousMissionId", "value": "MISSION-AMBIGUOUS"}
+  ]
+}

{forge_autonomy-2.7.26 → forge_autonomy-2.7.28}/forge/execution/loop.py

@@ -123,6 +123,7 @@ class ExecutionLoop:
         workspace_id: str,
         repository_id: str,
         repository_identity: str | None = None,
+        origin_identity: str | None = None,
         clock: Callable[[], str],
         correlation_id_factory: Callable[[], str],
         execution_policy: ExecutionPolicy | None = None,
@@ -142,6 +143,7 @@ class ExecutionLoop:
         self._planning_input, self._prompt_factory, self._repository_truth = planning_input, prompt_factory, repository_truth
         self._host_id, self._workspace_id, self._repository_id = host_id, workspace_id, repository_id
         self._repository_identity = repository_identity or repository_id
+        self._origin_identity = origin_identity
         self._clock, self._correlation_id_factory = clock, correlation_id_factory
         self._execution_policy = execution_policy or execution_policy_for_profile(governance_profile)
         self._capability_registry = capability_registry
@@ -366,6 +368,8 @@ class ExecutionLoop:
                                 derivation: Mapping[str, Any] | None) -> MissionExecutionState:
         if not self._keep_running():
             return state
+        if derivation is not None:
+            plan, derivation = self._immediate_action_plan(plan, derivation, ())
         actions = tuple(action for intent in plan.intents for action in intent.actions)
         if not actions:
             raise ExecutionLoopError("approved Mission planning produced no executable Engineering Actions")
@@ -488,11 +492,41 @@ class ExecutionLoop:
             "validated_before_materialization": True,
             "materialized_plan_id": result.plan.id,
             "materialized_plan_digest": result.plan.input_digest,
-            "materialized_action_ids": [proposal.logical_action_id for proposal in proposals],
+            "materialized_action_ids": [],
             "proposals": list(proposal_documents),
             "completed_action_ids_at_derivation": list(planning_input.mission_state.completed_action_ids),
         }
 
+    @staticmethod
+    def _immediate_action_plan(
+        plan: MissionPlan, derivation: Mapping[str, Any], completed_ids: tuple[str, ...],
+    ) -> tuple[MissionPlan, Mapping[str, Any]]:
+        """Keep one executable Action; retain other hypotheses only as audit forecast.
+
+        Selection is deterministic for replay of a persisted provider result.
+        A forecast has no Action identity in Mission State and is reconsidered
+        against new Repository Truth and evidence by the next invocation.
+        """
+        completed = set(completed_ids)
+        candidates = sorted(
+            (action for intent in plan.intents for action in intent.actions
+             if action.status is EngineeringActionStatus.READY
+             and set(action.dependencies) <= completed),
+            key=lambda action: (action.order, action.id),
+        )
+        if not candidates:
+            raise ExecutionLoopError("NO_IMMEDIATE_ACTION_AFTER_VALIDATED_FORECAST")
+        chosen = candidates[0]
+        intents = tuple(replace(intent, actions=(chosen,)) for intent in plan.intents
+                        if any(action.id == chosen.id for action in intent.actions))
+        forecast = [item["logical_action_id"] for item in derivation.get("proposals", ())
+                    if item["logical_action_id"] != chosen.id]
+        return replace(plan, intents=intents), {
+            **derivation,
+            "materialized_action_ids": [chosen.id],
+            "forecast_proposal_ids": forecast,
+        }
+
     def _delegate_if_required(self, state: MissionExecutionState) -> MissionExecutionState:
         if self._capability_registry is None:
             return state
@@ -570,6 +604,7 @@ class ExecutionLoop:
         return BootstrapMissionRunner(self._states, BootstrapMissionScheduler(), self._host, self._prompt_factory,
                                       host_id=self._host_id, workspace_id=self._workspace_id, repository_id=self._repository_id,
                                       repository_identity=self._repository_identity,
+                                      origin_identity=self._origin_identity,
                                       clock=self._clock, correlation_id_factory=self._correlation_id_factory,
                                       completion_context=completion, replan_after_evidence=self._replan_after_evidence,
                                       evidence_progression_gate=self._pause_after_evidence,
@@ -639,12 +674,19 @@ class ExecutionLoop:
         if not self._keep_running():
             return state
         assert derivation is not None
+        plan, derivation = self._immediate_action_plan(
+            plan, derivation, tuple(action.id for action in actions
+                                    if action.status is EngineeringActionStatus.COMPLETE),
+        )
         previous_fingerprints = {
             item["work_fingerprint"] for record in state.planning_history
             for item in record.get("proposals", ())
-            if isinstance(item, Mapping) and isinstance(item.get("work_fingerprint"), str)
+            if isinstance(item, Mapping)
+            and item.get("logical_action_id") in record.get("materialized_action_ids", ())
+            and isinstance(item.get("work_fingerprint"), str)
         }
-        if any(item["work_fingerprint"] in previous_fingerprints for item in derivation["proposals"]):
+        if any(item["work_fingerprint"] in previous_fingerprints for item in derivation["proposals"]
+               if item["logical_action_id"] in derivation["materialized_action_ids"]):
             raise ExecutionLoopError("DUPLICATE_SUCCESSOR_WORK")
         existing_ids = {action.id for action in actions}
         proposed = tuple(action for intent in plan.intents for action in intent.actions)