forge-autonomy 2.3.1__py3-none-any.whl

forge/business/ingress.py

@@ -0,0 +1,186 @@
+"""Forge-owned Business Governance Ingress for canonical recommendations.
+
+This composition service deliberately accepts only records in the canonical
+RecommendationLifecycleStore.  It has no Engineering Platform dependency and
+delegates identity allocation to RuntimeDatabase and downstream work to the
+existing MissionRuntimeScheduler.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from hashlib import sha256
+from typing import Protocol
+
+from forge.governance import GovernanceRole, ResolvedGovernanceProfile
+from forge.lifecycle import (
+    LifecycleError,
+    MissionCandidate,
+    RecommendationLifecycleStore,
+    RecommendationStatus,
+)
+from forge.mission_scheduler import MissionRuntimeScheduler, SchedulerResult
+from forge.runtime import RuntimeDatabase
+
+
+@dataclass(frozen=True)
+class BusinessGovernanceIngressResult:
+    recommendation_id: str
+    result: str
+    business_decision_id: str | None
+    business_approval_status: str | None
+    architecture_state: str
+    mission_candidate_id: str | None
+    mission_id: str | None
+    mission_runtime_state: str | None
+    scheduler_state: str | None
+    decision_evidence_references: tuple[str, ...]
+
+
+class SchedulerHandoff(Protocol):
+    """The scheduler's existing handoff surface; ingress owns no submission."""
+
+    def evaluate(self, mission_id: str) -> SchedulerResult: ...
+
+
+class BusinessGovernanceIngress:
+    """Approve and reconcile one existing recommendation through canonical state."""
+
+    def __init__(self, lifecycle: RecommendationLifecycleStore, runtime: RuntimeDatabase,
+                 governance: ResolvedGovernanceProfile, *, scheduler: SchedulerHandoff | None = None) -> None:
+        self._lifecycle = lifecycle
+        self._runtime = runtime
+        self._governance = governance
+        self._scheduler = scheduler
+
+    def approve_recommendation(self, recommendation_id: str, *, actor: str | None,
+                               occurred_at: str, rationale: str) -> BusinessGovernanceIngressResult:
+        if not actor:
+            return self._result(recommendation_id, "AUTHORIZATION_REQUIRED", architecture_state="NOT_REACHED")
+        allowed = self._governance.role_assignments.get(GovernanceRole.BUSINESS_OWNER, ())
+        if actor not in allowed:
+            return self._result(recommendation_id, "FORBIDDEN", architecture_state="NOT_REACHED")
+        try:
+            recommendation = self._lifecycle.resolve_recommendation(recommendation_id)
+        except LifecycleError as error:
+            result = "AMBIGUOUS" if "ambiguous" in str(error) else "NOT_FOUND"
+            return self._result(recommendation_id, result, architecture_state="NOT_REACHED")
+        recommendation_id = recommendation.id
+        if recommendation.status is RecommendationStatus.RECOMMENDED:
+            recommendation = self._lifecycle.transition(
+                recommendation_id, RecommendationStatus.BUSINESS_APPROVED, actor=actor,
+                occurred_at=occurred_at, rationale=rationale,
+                references=(recommendation.decision_evidence_reference,),
+            )
+        elif recommendation.status not in {
+            RecommendationStatus.BUSINESS_APPROVED, RecommendationStatus.ARCHITECTURE_APPROVED,
+            RecommendationStatus.MISSION_ALLOCATED,
+        }:
+            return self._result(recommendation_id, "INVALID_LIFECYCLE_STATE",
+                                architecture_state=recommendation.status.value)
+        if recommendation.status is RecommendationStatus.BUSINESS_APPROVED:
+            return self._current(recommendation_id, "WAITING_ARCHITECTURE_APPROVAL",
+                                 architecture_state="WAITING_ARCHITECTURE_APPROVAL")
+        return self._reconcile_approved(recommendation_id, occurred_at)
+
+    def _reconcile_approved(self, recommendation_id: str, occurred_at: str) -> BusinessGovernanceIngressResult:
+        allocation = self._lifecycle.allocation_for_recommendation(recommendation_id)
+        candidate = self._lifecycle.candidate_for_recommendation(recommendation_id)
+        if allocation is None:
+            if candidate is None:
+                recommendation = self._lifecycle.get_recommendation(recommendation_id)
+                candidate = MissionCandidate(
+                    id="candidate:" + sha256(recommendation_id.encode()).hexdigest()[:20],
+                    recommendation_id=recommendation_id, title=recommendation.title,
+                    objective=recommendation.engineering_summary,
+                    scope=(recommendation.business_summary,),
+                    acceptance_criteria=(recommendation.engineering_value,),
+                    architecture_constraints=(recommendation.architectural_value,),
+                    dependencies=recommendation.dependencies,
+                )
+                self._lifecycle.create_candidate(candidate)
+            allocation = self._lifecycle.allocate(
+                candidate.id, actor="forge", occurred_at=occurred_at,
+                rationale="Canonical Business and Architecture approvals permit Mission allocation.",
+                allocate_mission_id=lambda source, timestamp: self._runtime.allocate_next_mission_id(
+                    source=f"recommendation:{source}", allocated_at=timestamp),
+            )
+        self._initialize_runtime(allocation.mission_id, recommendation_id, candidate.id, occurred_at, allocation)
+        scheduler_state = "SCHEDULER_ELIGIBLE"
+        if self._scheduler is not None:
+            scheduler_state = self._scheduler.evaluate(allocation.mission_id).state
+        return self._current(recommendation_id, "APPROVED_AND_ACTIVATED",
+                             architecture_state="ARCHITECTURE_APPROVED", scheduler_state=scheduler_state)
+
+    def _initialize_runtime(self, mission_id: str, recommendation_id: str, candidate_id: str,
+                            occurred_at: str, allocation: object) -> None:
+        try:
+            self._runtime.get_document("mission_state", mission_id)
+            runtime_exists = True
+        except Exception:
+            runtime_exists = False
+            # Runtime Decision Evidence has a foreign-key relationship to its
+            # Mission.  Reserve only the canonical operational record first;
+            # the complete initialized graph is written below.
+            self._runtime.save_mission_state({
+                "mission_id": mission_id, "lifecycle": "ALLOCATED", "status": "ALLOCATED",
+                "progress": {"percent_complete": 0}, "resume": {"phase": "governance_activation"},
+                "execution_policy": {"mode": "mission_review", "execution_authorized": False},
+            })
+        if not self._runtime.has_document("decision_evidence", f"{mission_id}-governance-activation-1"):
+            self._runtime.record_decision_evidence({
+                "id": f"{mission_id}-governance-activation-1", "decision_type": "mission_planning",
+                "timestamp": occurred_at, "mission_context": {"artifact_id": mission_id},
+                "repository_context": {"artifact_id": "forge-governance"},
+                "reasoning_summary": "Allocated canonical Mission is activated from immutable governance evidence.",
+                "evidence_references": [{"artifact_id": item} for item in (
+                    recommendation_id, candidate_id, allocation.business_decision_evidence_id,
+                    allocation.architecture_decision_evidence_id, allocation.allocation_decision_evidence_id)],
+                "alternatives_considered": [{"id": "wait", "reason": "Both required approvals are already recorded."}],
+                "chosen_alternative": "activate", "confidence": {"score": 100, "mission_state": {"artifact_id": mission_id}},
+                "execution_receipt_references": [],
+            })
+        if not runtime_exists:
+            intent_id, action_id = f"{mission_id}-intent-1", f"{mission_id}-action-1"
+            intent = {"id": intent_id, "title": "Approved Mission activation", "objective": "Execute the approved bounded Mission.", "status": "APPROVED"}
+            action = {"id": action_id, "intent_id": intent_id, "objective": "Start the approved Mission according to its canonical scope.", "status": "READY", "dependencies": []}
+            self._runtime.save_mission_state({
+                "mission_id": mission_id, "mission_title": self._lifecycle.get_recommendation(recommendation_id).title,
+                "mission_recommendation_status": "MISSION_ALLOCATED", "business_summary": self._lifecycle.get_recommendation(recommendation_id).business_summary,
+                "engineering_summary": self._lifecycle.get_recommendation(recommendation_id).engineering_summary,
+                "lifecycle": "ACTIVE", "status": "ACTIVE", "progress": {"percent_complete": 0},
+                "resume": {"phase": "autonomous_scheduler"}, "execution_policy": {"mode": "mission_review", "execution_authorized": True},
+                "governance": {"business_approval": "approved", "architecture_approval": "approved"},
+                "engineering_intents": [intent], "engineering_actions": [action],
+                "current_engineering_intent": intent, "current_engineering_action": action,
+                "runtime_prompts": [{"id": f"scheduler-prompt:{action_id}:1", "action_id": action_id, "intent_id": intent_id, "status": "READY_FOR_ENGINEERING_PLATFORM"}],
+                "decision_evidence_ids": [f"{mission_id}-governance-activation-1"], "execution_receipt_references": [],
+            })
+            self._runtime.record_mission_lifecycle(mission_id, "allocated", occurred_at)
+            self._runtime.record_mission_lifecycle(mission_id, "active", occurred_at)
+            self._runtime.save_dispatcher_state(status="ACTIVE", mission_sequence=(mission_id,), active_mission_id=mission_id)
+            self._runtime.save_planning_state({"planner_version": "business-governance-ingress-1", "current_queue": [mission_id],
+                "pending_engineering_actions": [action_id], "blocked_engineering_actions": [],
+                "execution_policy": {"mode": "mission_review", "execution_authorized": True},
+                "planner_runtime_metadata": {"scheduler_state": "READY"}})
+            self._runtime.runtime_evidence().mission_runtime_projection(mission_id)
+
+    def _current(self, recommendation_id: str, result: str, *, architecture_state: str,
+                 scheduler_state: str | None = None) -> BusinessGovernanceIngressResult:
+        recommendation = self._lifecycle.get_recommendation(recommendation_id)
+        history = self._lifecycle.history(recommendation_id)
+        decisions = tuple(item.id for item in history)
+        business = next((item.id for item in history if item.kind == "business_decision"), None)
+        candidate = self._lifecycle.candidate_for_recommendation(recommendation_id)
+        allocation = self._lifecycle.allocation_for_recommendation(recommendation_id)
+        runtime_state = None
+        if allocation is not None:
+            runtime_state = self._runtime.get_document("mission_state", allocation.mission_id).get("lifecycle")
+        return BusinessGovernanceIngressResult(recommendation_id, result, business,
+            "APPROVED" if business else None, architecture_state, None if candidate is None else candidate.id,
+            None if allocation is None else allocation.mission_id, runtime_state, scheduler_state, decisions)
+
+    @staticmethod
+    def _result(recommendation_id: str, result: str, *, architecture_state: str) -> BusinessGovernanceIngressResult:
+        return BusinessGovernanceIngressResult(recommendation_id, result, None, None, architecture_state,
+                                               None, None, None, None, ())

forge/business/presentation.py

@@ -0,0 +1,74 @@
+"""Minimal deterministic view models for the human-facing Business Workspace."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from forge.models.mission_recommendation import MissionRecommendation
+from forge.models.decision_evidence import DecisionEvidence
+from forge.lifecycle import LifecycleDecisionEvidence, MissionRecommendation as LifecycleMissionRecommendation
+
+
+def render_mission_recommendation(recommendation: MissionRecommendation) -> dict[str, Any]:
+    """Render advisory details without changing recommendation or Portfolio state."""
+    return {
+        "id": recommendation.id,
+        "title": recommendation.title,
+        "rationale": recommendation.rationale,
+        "business_value": recommendation.business_value,
+        "expected_engineering_value": recommendation.expected_engineering_value,
+        "risk_if_deferred": recommendation.risk_if_deferred,
+        "estimated_engineering_effort": recommendation.estimated_effort.value,
+        "confidence": recommendation.confidence.to_dict(),
+        "required_disciplines": [item.value for item in recommendation.required_disciplines],
+        "missing_disciplines": [item.value for item in recommendation.missing_disciplines],
+        "dependencies": recommendation.dependencies.to_dict(),
+        "origin": recommendation.origin.value,
+        "repository_evidence": [item.to_dict() for item in recommendation.repository_evidence],
+        "recommendation_source": recommendation.recommendation_source,
+        "decision_evidence_references": list(recommendation.decision_evidence_references),
+        "architecture_review_reference": recommendation.architecture_review_id,
+        "advisory": True,
+    }
+
+
+def render_business_decision_evidence(evidence: DecisionEvidence) -> dict[str, Any]:
+    """Expose recommendation rationale without granting or automating approval."""
+    return {"id": evidence.id, "decision_type": evidence.decision_type.value, "decision": evidence.decision,
+            "reasoning_summary": evidence.reasoning_summary, "alternatives": [item.to_dict() for item in evidence.alternatives_considered],
+            "chosen_alternative": evidence.chosen_alternative, "confidence": evidence.confidence.to_dict(),
+            "approval_state": evidence.approval_state.value, "advisory": True}
+
+
+def render_persisted_mission_recommendation(recommendation: LifecycleMissionRecommendation,
+                                            *, selection_decision_evidence_id: str | None = None) -> dict[str, Any]:
+    """Render lifecycle-owned recommendation fields required for Business review."""
+    return {
+        "id": recommendation.id, "recommendation_set_id": recommendation.recommendation_set_id,
+        "rank": recommendation.rank, "title": recommendation.title,
+        "mission_origin": recommendation.mission_origin, "business_value": recommendation.business_value,
+        "architectural_value": recommendation.architectural_value, "engineering_value": recommendation.engineering_value,
+        "confidence": recommendation.confidence, "dependencies": list(recommendation.dependencies),
+        "risk_if_deferred": recommendation.risk_if_deferred, "rationale": recommendation.business_summary,
+        "decision_evidence_reference": selection_decision_evidence_id or recommendation.decision_evidence_reference,
+        "recommendation_status": recommendation.status.value, "approval_status": "NOT_YET_APPROVED",
+        "advisory": True,
+    }
+
+
+def render_persisted_recommendation_set(recommendations: tuple[LifecycleMissionRecommendation, ...],
+                                        decision_evidence: LifecycleDecisionEvidence) -> tuple[dict[str, Any], ...]:
+    """Render a complete current set for Business review without inferring Mission state."""
+    if not recommendations or decision_evidence.decision_type != "MISSION_RECOMMENDATION":
+        raise ValueError("a recommendation selection Decision Evidence record is required")
+    if decision_evidence.selected_recommendation_id != recommendations[0].id:
+        raise ValueError("selection Decision Evidence must identify rank one")
+    if decision_evidence.ranked_alternatives != tuple(item.id for item in recommendations):
+        raise ValueError("selection Decision Evidence must preserve the ranked alternatives")
+    rendered = tuple(
+        render_persisted_mission_recommendation(item, selection_decision_evidence_id=decision_evidence.id)
+        for item in recommendations
+    )
+    if sum(item["recommendation_status"] == "RECOMMENDED" for item in rendered) != 1:
+        raise ValueError("Business Workspace requires exactly one recommended recommendation")
+    return rendered

forge/business/workspace.py

@@ -0,0 +1,141 @@
+"""Local, auditable Business Workspace storage and business-only transitions."""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+from dataclasses import dataclass, replace
+from pathlib import Path
+
+from forge.models.mission_candidate import MissionCandidate, MissionCandidateStatus
+
+
+class BusinessWorkspaceError(ValueError):
+    pass
+
+
+@dataclass(frozen=True)
+class MissionCandidateHistoryEntry:
+    revision: int
+    event: str
+    actor: str
+    occurred_at: str
+    rationale: str
+
+
+class BusinessWorkspace:
+    """Legacy local workspace storage for offline/tests; not production authority.
+
+    Supported Forge governance mutations use :meth:`for_runtime`, which is
+    bound to the resolved Runtime Instance and canonical evidence repository.
+    """
+
+    @classmethod
+    def for_runtime(cls, database: object, repository: object, context: object) -> object:
+        """Return the canonical runtime-bound Business approval service.
+
+        No filesystem path is accepted on this supported production route.
+        """
+        from forge.governance_authority import CanonicalBusinessWorkspace
+        if getattr(repository, "database", None) is not database:
+            raise BusinessWorkspaceError("Business governance repository must use the resolved Runtime Instance")
+        return CanonicalBusinessWorkspace(repository, context)
+
+    def __init__(self, path: Path) -> None:
+        self._connection = sqlite3.connect(path)
+        self._connection.row_factory = sqlite3.Row
+        self._connection.executescript("""
+            CREATE TABLE IF NOT EXISTS mission_candidate (
+              candidate_id TEXT PRIMARY KEY, revision INTEGER NOT NULL, status TEXT NOT NULL, document TEXT NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS mission_candidate_history (
+              candidate_id TEXT NOT NULL, revision INTEGER NOT NULL, event TEXT NOT NULL, actor TEXT NOT NULL,
+              occurred_at TEXT NOT NULL, rationale TEXT NOT NULL, PRIMARY KEY(candidate_id, revision),
+              FOREIGN KEY(candidate_id) REFERENCES mission_candidate(candidate_id)
+            );
+            CREATE TRIGGER IF NOT EXISTS mission_candidate_history_no_update BEFORE UPDATE ON mission_candidate_history
+            BEGIN SELECT RAISE(ABORT, 'mission candidate history is append-only'); END;
+            CREATE TRIGGER IF NOT EXISTS mission_candidate_history_no_delete BEFORE DELETE ON mission_candidate_history
+            BEGIN SELECT RAISE(ABORT, 'mission candidate history is append-only'); END;
+        """)
+        self._connection.commit()
+
+    def close(self) -> None:
+        self._connection.close()
+
+    def __enter__(self) -> "BusinessWorkspace":
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+    def create(self, candidate: MissionCandidate, *, actor: str, occurred_at: str) -> MissionCandidate:
+        if candidate.status is not MissionCandidateStatus.BUSINESS_REVIEW:
+            raise BusinessWorkspaceError("new candidates must enter business_review")
+        self._write(candidate, 1, "created", actor, occurred_at, candidate.business_rationale, insert=True)
+        return self.get(candidate.id)
+
+    def get(self, candidate_id: str) -> MissionCandidate:
+        row = self._connection.execute("SELECT document FROM mission_candidate WHERE candidate_id = ?", (candidate_id,)).fetchone()
+        if row is None:
+            raise BusinessWorkspaceError(f"unknown mission candidate: {candidate_id}")
+        return MissionCandidate.from_dict(json.loads(row["document"]))
+
+    def list(self, *, status: MissionCandidateStatus | None = None) -> tuple[MissionCandidate, ...]:
+        query = "SELECT document FROM mission_candidate" + (" WHERE status = ?" if status else "") + " ORDER BY candidate_id"
+        rows = self._connection.execute(query, () if status is None else (status.value,)).fetchall()
+        return tuple(MissionCandidate.from_dict(json.loads(row["document"])) for row in rows)
+
+    def refine(self, candidate_id: str, *, actor: str, occurred_at: str, rationale: str, **changes: object) -> MissionCandidate:
+        candidate, revision = self._current(candidate_id)
+        if candidate.status is not MissionCandidateStatus.BUSINESS_REVIEW:
+            raise BusinessWorkspaceError("only candidates in business_review may be refined")
+        allowed = {"title", "summary", "business_objective", "business_value", "priority", "business_rationale", "maturity", "dependencies", "required_disciplines"}
+        if not changes or set(changes) - allowed:
+            raise BusinessWorkspaceError("business refinement may update only business candidate fields")
+        refined = replace(candidate, **changes)
+        self._write(refined, revision + 1, "refined", actor, occurred_at, rationale)
+        return self.get(candidate_id)
+
+    def approve_for_architecture(self, candidate_id: str, *, actor: str, occurred_at: str, rationale: str) -> MissionCandidate:
+        return self._transition(candidate_id, MissionCandidateStatus.APPROVED_FOR_ARCHITECTURE, "approved_for_architecture", actor, occurred_at, rationale)
+
+    def reject(self, candidate_id: str, *, actor: str, occurred_at: str, rationale: str) -> MissionCandidate:
+        return self._transition(candidate_id, MissionCandidateStatus.REJECTED, "rejected", actor, occurred_at, rationale)
+
+    def archive(self, candidate_id: str, *, actor: str, occurred_at: str, rationale: str) -> MissionCandidate:
+        return self._transition(candidate_id, MissionCandidateStatus.ARCHIVED, "archived", actor, occurred_at, rationale)
+
+    def history(self, candidate_id: str) -> tuple[MissionCandidateHistoryEntry, ...]:
+        self.get(candidate_id)
+        rows = self._connection.execute("SELECT revision, event, actor, occurred_at, rationale FROM mission_candidate_history WHERE candidate_id = ? ORDER BY revision", (candidate_id,)).fetchall()
+        return tuple(MissionCandidateHistoryEntry(**dict(row)) for row in rows)
+
+    def _transition(self, candidate_id: str, target: MissionCandidateStatus, event: str, actor: str, occurred_at: str, rationale: str) -> MissionCandidate:
+        candidate, revision = self._current(candidate_id)
+        if candidate.status is not MissionCandidateStatus.BUSINESS_REVIEW:
+            raise BusinessWorkspaceError(f"mission candidate transition {candidate.status.value} -> {target.value} is not permitted")
+        if not all((actor, occurred_at, rationale)):
+            raise BusinessWorkspaceError("business decision requires actor, time, and rationale")
+        self._write(replace(candidate, status=target), revision + 1, event, actor, occurred_at, rationale)
+        return self.get(candidate_id)
+
+    def _current(self, candidate_id: str) -> tuple[MissionCandidate, int]:
+        row = self._connection.execute("SELECT revision, document FROM mission_candidate WHERE candidate_id = ?", (candidate_id,)).fetchone()
+        if row is None:
+            raise BusinessWorkspaceError(f"unknown mission candidate: {candidate_id}")
+        return MissionCandidate.from_dict(json.loads(row["document"])), row["revision"]
+
+    def _write(self, candidate: MissionCandidate, revision: int, event: str, actor: str, occurred_at: str, rationale: str, *, insert: bool = False) -> None:
+        if not all((actor, occurred_at, rationale)):
+            raise BusinessWorkspaceError("business change requires actor, time, and rationale")
+        document = json.dumps(candidate.to_dict(), sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+        try:
+            with self._connection:
+                if insert:
+                    self._connection.execute("INSERT INTO mission_candidate VALUES (?, ?, ?, ?)", (candidate.id, revision, candidate.status.value, document))
+                else:
+                    self._connection.execute("UPDATE mission_candidate SET revision = ?, status = ?, document = ? WHERE candidate_id = ?", (revision, candidate.status.value, document, candidate.id))
+                self._connection.execute("INSERT INTO mission_candidate_history VALUES (?, ?, ?, ?, ?, ?)", (candidate.id, revision, event, actor, occurred_at, rationale))
+        except sqlite3.IntegrityError as error:
+            raise BusinessWorkspaceError(f"mission candidate already exists: {candidate.id}") from error

forge/canary.py

@@ -0,0 +1,134 @@
+"""Deterministic End-to-End Bootstrap Mission Canary qualification scenario."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from forge.intake import MissionIntake
+from forge.models import (
+    CodexCliRuntimePromptRequest, EngineeringAction, EngineeringIntent,
+    EngineeringActionStatus, ExecutionHostCompatibility, IntentApproval,
+    IntentCategory, IntentReference, IntentStatus, IntentTraceability,
+    RepositoryState,
+)
+from forge.models.execution_host import ExecutionEvidenceOutcome
+from forge.models.mission import EngineeringMission, MissionIntentMembership, MissionScope, MissionStatus
+from forge.prompts import CodexCliRuntimePromptRenderer
+from forge.runtime import BootstrapMissionRunner, RuntimeDatabase
+from forge.scheduler import BootstrapMissionScheduler
+from forge.scheduler.adapter import (
+    BootstrapExecutionHostAdapter, EngineeringPlatformInboxReceipt, EngineeringPlatformReport,
+    EngineeringPlatformReportOutcome, ExecutionHostConfiguration,
+)
+from forge.state import MissionExecutionStatus, MissionStateStore
+
+
+CANARY_MISSION_ID = "forge-bootstrap-mission-canary"
+CANARY_INTENT_ID = "forge-bootstrap-mission-canary-intent"
+CANARY_ACTION_ID = "forge-bootstrap-mission-canary-action"
+CANARY_CORRELATION_ID = "forge-bootstrap-mission-canary-correlation"
+CANARY_HOST_RUN_ID = "forge-bootstrap-mission-canary-host-run"
+
+
+def _reference(name: str) -> IntentReference:
+    return IntentReference(name, "1", f"local://{name}")
+
+
+@dataclass(frozen=True)
+class CanaryQualificationReport:
+    answer: str
+    mission_id: str
+    intent_id: str
+    action_id: str
+    runtime_prompt_id: str
+    execution_host_run_id: str
+    correlation_id: str
+    evidence_kinds: tuple[str, ...]
+    admission_levels: tuple[str, ...]
+
+
+class _Configuration:
+    def resolve(self, host_id: str) -> ExecutionHostConfiguration:
+        return ExecutionHostConfiguration(host_id, "2.4", ("GENESIS",), ("codex_cli", "local_git"),
+                                          "engineering-platform>=1.5.0", "canary://engineering-platform-1.5")
+
+
+class _Preflight:
+    def __init__(self) -> None:
+        self.levels: list[str] = []
+
+    def admit(self, compatibility: ExecutionHostCompatibility, configuration: ExecutionHostConfiguration) -> None:
+        if compatibility.execution_host_contract_version != configuration.host_contract_version:
+            raise ValueError("Execution Host Preflight Level 1 failed")
+        self.levels.append("execution_host_level_1")
+        if compatibility.execution_mode not in configuration.supported_execution_modes:
+            raise ValueError("Workspace Preflight Level 2 failed")
+        self.levels.append("workspace_level_2")
+        if not set(compatibility.required_capabilities).issubset(configuration.supported_capabilities):
+            raise ValueError("Capability Preflight Level 3 failed")
+        self.levels.append("capability_level_3")
+
+
+class _Inbox:
+    def __init__(self) -> None:
+        self.request = None
+
+    def submit(self, request: object) -> EngineeringPlatformInboxReceipt:
+        self.request = request
+        return EngineeringPlatformInboxReceipt(CANARY_HOST_RUN_ID, "forge-bootstrap-mission-canary-receipt", "engineering-platform-1.5", "2026-08-03T23:30:00Z")
+
+    def receipt_for(self, correlation_id: str) -> EngineeringPlatformInboxReceipt | None:
+        return EngineeringPlatformInboxReceipt(CANARY_HOST_RUN_ID, "forge-bootstrap-mission-canary-receipt", "engineering-platform-1.5", "2026-08-03T23:30:00Z") if self.request and correlation_id == CANARY_CORRELATION_ID else None
+
+
+class _Reports:
+    def __init__(self, inbox: _Inbox) -> None: self._inbox = inbox
+
+    def report_for(self, run_id: str) -> EngineeringPlatformReport | None:
+        request = self._inbox.request
+        if run_id != CANARY_HOST_RUN_ID or request is None:
+            return None
+        return EngineeringPlatformReport(CANARY_HOST_RUN_ID, "forge-bootstrap-mission-canary-report",
+            EngineeringPlatformReportOutcome.COMPLETE, "canary-repository-revision", "sha256:" + "c" * 64,
+            ("validation:bootstrap-mission-canary",), ("evidence:engineering-platform-1.5",),
+            "2026-08-03T23:30:00Z", "2026-08-03T23:31:00Z", "forge-bootstrap-mission-canary-receipt",
+            request.execution_host_id, request.correlation_id, request.runtime_prompt_id, request.mission_id,
+            request.intent_id, request.intent_revision, request.action_id, execution_duration_ms=60_000)
+
+
+def run_bootstrap_mission_canary(state_path: Path) -> CanaryQualificationReport:
+    """Run the complete adapter pipeline once with deterministic host evidence."""
+    reference = _reference("canary-approval")
+    intent = EngineeringIntent(CANARY_INTENT_ID, "1", "Bootstrap Mission Canary Intent", "Qualify the pipeline.",
+        IntentCategory.IMPLEMENTATION, IntentTraceability((reference,), (reference,), (reference,), (reference,), (reference,)),
+        approval=IntentApproval("architecture", "2026-08-03T23:29:00Z", reference), status=IntentStatus.APPROVED)
+    mission = EngineeringMission(CANARY_MISSION_ID, "1", "Bootstrap Mission Canary", "Qualify one bounded Mission.",
+        MissionScope(("one deterministic execution",), ("continuous execution",)),
+        (MissionIntentMembership(1, intent.id, intent.revision),), status=MissionStatus.ACTIVE)
+    action = EngineeringAction(1, CANARY_ACTION_ID, intent.id, intent.revision, "Execute the one qualified canary Action.",
+        ("repository evidence",), status=EngineeringActionStatus.READY)
+    preflight, inbox = _Preflight(), _Inbox()
+    adapter = BootstrapExecutionHostAdapter(_Configuration(), preflight, inbox, _Reports(inbox))
+    with MissionStateStore(RuntimeDatabase(state_path.parent)) as store:
+        intake = MissionIntake(store, lambda: "2026-08-03T23:29:30Z")
+        intake.admit(mission, (intent,), (action,))
+        def render(_intent: object, active: EngineeringAction):
+            return CodexCliRuntimePromptRenderer().render(CodexCliRuntimePromptRequest(
+                mission, intent, active, RepositoryState("forge", "canary-repository-revision", "sha256:" + "c" * 64, "2026-08-03T23:29:30Z"),
+                ("one action only",), ("bootstrap canary validation",),
+                ExecutionHostCompatibility("2.4", "GENESIS", ("codex_cli", "local_git"), "engineering-platform>=1.5.0"),
+            ))
+        runner = BootstrapMissionRunner(store, BootstrapMissionScheduler(), adapter, render, host_id="engineering-platform-1.5",
+            workspace_id="forge", repository_id="forge", clock=lambda: "2026-08-03T23:29:30Z",
+            correlation_id_factory=lambda: CANARY_CORRELATION_ID)
+        # Intake owns state creation; the Runner advances that same durable state.
+        result = runner.run(CANARY_MISSION_ID)
+        if result.status is not MissionExecutionStatus.COMPLETED:
+            raise ValueError("Bootstrap Mission Canary did not complete")
+        request = result.execution_correlation["request"]
+        evidence = result.execution_evidence
+        assert evidence is not None
+        return CanaryQualificationReport("YES", mission.id, intent.id, action.id, request["runtime_prompt"]["id"],
+            result.execution_correlation["host_run_id"], request["correlation_id"],
+            ("execution_host", "engineering", "repository", "validation", "mission_completion"), tuple(preflight.levels))

forge/capabilities/__init__.py

@@ -0,0 +1,11 @@
+"""Capability registry and delegation framework."""
+
+from .delegation import (
+    CAPABILITY_REGISTRY_SCHEMA_VERSION, DELEGATION_SCHEMA_VERSION, CapabilityAssessment,
+    CapabilityAvailability, CapabilityExecutionMode, CapabilityOwner, CapabilityRegistration,
+    CapabilityRegistry, DelegationApprovalState, DelegationRequest, DelegationResultState,
+)
+
+__all__ = ["CAPABILITY_REGISTRY_SCHEMA_VERSION", "DELEGATION_SCHEMA_VERSION", "CapabilityAssessment",
+           "CapabilityAvailability", "CapabilityExecutionMode", "CapabilityOwner", "CapabilityRegistration",
+           "CapabilityRegistry", "DelegationApprovalState", "DelegationRequest", "DelegationResultState"]