Spaces:
Paused
Paused
| """Coordinator between dry-run proposals and controlled structural mutation.""" | |
| from __future__ import annotations | |
| from collections.abc import Callable | |
| from dataclasses import dataclass | |
| from threading import RLock | |
| from typing import TYPE_CHECKING | |
| from .approval import ProposalApprovalPolicy | |
| if TYPE_CHECKING: | |
| from src.dashboard.models import JSONValue | |
| from .policy import ( | |
| LegacyStructuralProposal, | |
| PolicyReport, | |
| StructuralAction, | |
| StructuralProposal, | |
| ) | |
| ProposalExecutor = Callable[[LegacyStructuralProposal], int] | |
| class ProposalDecision: | |
| proposal_id: str | |
| accepted: bool | |
| reason: str | |
| class SelfOrganizationSnapshot: | |
| """Public coordinator telemetry for the dashboard.""" | |
| enabled: bool | |
| dry_run: bool | |
| proposals_seen: int | |
| proposals_executed: int | |
| mutations_applied: int | |
| last_proposal: LegacyStructuralProposal | None | |
| def to_json(self) -> dict[str, JSONValue]: | |
| return { | |
| "enabled": self.enabled, | |
| "dry_run": self.dry_run, | |
| "proposals_seen": self.proposals_seen, | |
| "proposals_executed": self.proposals_executed, | |
| "mutations_applied": self.mutations_applied, | |
| "last_proposal": ( | |
| self.last_proposal.to_json() if self.last_proposal is not None else None | |
| ), | |
| } | |
| class SelfOrganizationCoordinator: | |
| """Store latest proposals and require explicit operator approval.""" | |
| def __init__( | |
| self, | |
| executor: ProposalExecutor | None = None, | |
| *, | |
| enabled: bool = True, | |
| dry_run: bool = True, | |
| ) -> None: | |
| self._lock = RLock() | |
| self._latest: PolicyReport | None = None | |
| self._decisions: list[ProposalDecision] = [] | |
| self._executor = executor | |
| self._enabled = enabled | |
| self._dry_run = dry_run | |
| self._proposals_seen = 0 | |
| self._proposals_executed = 0 | |
| self._mutations_applied = 0 | |
| self._last_proposal: LegacyStructuralProposal | None = None | |
| def configure( | |
| self, | |
| *, | |
| enabled: bool | None = None, | |
| dry_run: bool | None = None, | |
| ) -> None: | |
| """Change execution gates without replacing the policy.""" | |
| with self._lock: | |
| if enabled is not None: | |
| self._enabled = enabled | |
| if dry_run is not None: | |
| self._dry_run = dry_run | |
| def submit(self, proposal: LegacyStructuralProposal) -> SelfOrganizationSnapshot: | |
| """Account and optionally execute a legacy structural proposal.""" | |
| with self._lock: | |
| self._proposals_seen += 1 | |
| self._last_proposal = proposal | |
| if ( | |
| not self._enabled | |
| or self._dry_run | |
| or proposal.action is StructuralAction.NONE | |
| ): | |
| return self._snapshot_unlocked() | |
| if self._executor is None: | |
| raise RuntimeError( | |
| "Self-organization execution is enabled without an executor." | |
| ) | |
| applied = self._executor(proposal) | |
| if applied < 0: | |
| raise ValueError("proposal executor returned a negative mutation count") | |
| self._proposals_executed += 1 | |
| self._mutations_applied += applied | |
| return self._snapshot_unlocked() | |
| def snapshot(self) -> SelfOrganizationSnapshot: | |
| """Return immutable dashboard telemetry.""" | |
| with self._lock: | |
| return self._snapshot_unlocked() | |
| def _snapshot_unlocked(self) -> SelfOrganizationSnapshot: | |
| return SelfOrganizationSnapshot( | |
| enabled=self._enabled, | |
| dry_run=self._dry_run, | |
| proposals_seen=self._proposals_seen, | |
| proposals_executed=self._proposals_executed, | |
| mutations_applied=self._mutations_applied, | |
| last_proposal=self._last_proposal, | |
| ) | |
| def publish(self, report: PolicyReport) -> None: | |
| with self._lock: | |
| self._latest = report | |
| def latest(self) -> PolicyReport | None: | |
| with self._lock: | |
| return self._latest | |
| def find(self, proposal_id: str) -> StructuralProposal | None: | |
| report = self.latest() | |
| if report is None: | |
| return None | |
| return next((p for p in report.proposals if p.proposal_id == proposal_id), None) | |
| def record_decision( | |
| self, proposal_id: str, accepted: bool, reason: str | |
| ) -> ProposalDecision: | |
| decision = ProposalDecision(proposal_id, accepted, reason) | |
| with self._lock: | |
| self._decisions.append(decision) | |
| return decision | |
| def approve(self, proposal_id: str, reason: str = "operator approval") -> bool: | |
| """Record approval only when the proposal is currently published.""" | |
| if self.find(proposal_id) is None: | |
| return False | |
| self.record_decision(proposal_id, True, reason) | |
| return True | |
| def reject(self, proposal_id: str, reason: str = "operator rejection") -> bool: | |
| """Record rejection only when the proposal is currently published.""" | |
| if self.find(proposal_id) is None: | |
| return False | |
| self.record_decision(proposal_id, False, reason) | |
| return True | |
| def auto_process( | |
| self, | |
| policy: ProposalApprovalPolicy, | |
| *, | |
| safety_ok: bool, | |
| cooldown_ok: bool, | |
| kind_allowed: bool, | |
| ) -> tuple[ProposalDecision, ...]: | |
| """Evaluate current proposals without applying structural mutations.""" | |
| report = self.latest() | |
| if report is None: | |
| return () | |
| decisions: list[ProposalDecision] = [] | |
| for proposal in report.proposals: | |
| approval = policy.evaluate( | |
| proposal, | |
| safety_ok=safety_ok, | |
| cooldown_ok=cooldown_ok, | |
| kind_allowed=kind_allowed, | |
| ) | |
| decisions.append( | |
| self.record_decision( | |
| proposal.proposal_id, | |
| approval.approved, | |
| approval.reason, | |
| ) | |
| ) | |
| return tuple(decisions) | |
| def decisions(self) -> tuple[ProposalDecision, ...]: | |
| with self._lock: | |
| return tuple(self._decisions) | |