subactor-shell 0.2.2__py3-none-any.whl

subactor_shell/operations.py

@@ -0,0 +1,287 @@
+"""Bounded operational HTTP commands exposed by Subactor Shell."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlsplit, urlunsplit
+
+import httpx
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
+from .control_env import apply_control_environment
+from .terminal import canonical_ticket_links, terminal_hyperlinks_enabled
+
+
+_TERMINAL_TICKET_STATES = frozenset({"done", "completed", "closed", "rejected", "cancelled"})
+_WRITE_METHODS = frozenset({"POST", "PUT", "PATCH", "DELETE"})
+_URI = re.compile(r"^[a-z][a-z0-9+.-]*://[^\s]+$", re.IGNORECASE)
+_ENDPOINTS = """# Subactor Control API
+GET  /health
+GET  /api/system/dashboard
+GET  /api/plans
+GET  /api/integrations
+GET  /api/delegation/manager
+GET  /api/llm/status
+POST /api/delegation/dispatch
+POST /api/processes/run
+
+# Canonical shell
+subactor health
+subactor status
+subactor tickets --open
+subactor plans remote
+subactor uri <uri-process> [json-payload]
+subactor get /api/system/dashboard
+subactor post /api/delegation/dispatch '{}' --confirm EXECUTE
+subactor api GET|POST|PUT|PATCH|DELETE <path> [json-body]
+"""
+
+
+class OperationsError(RuntimeError):
+    """Safe user-facing operational command failure."""
+
+
+def _validated_origin(value: str, label: str) -> str:
+    parsed = urlsplit(value.strip())
+    if parsed.scheme not in {"http", "https"} or not parsed.hostname:
+        raise OperationsError(f"{label} musi być adresem http(s)")
+    if parsed.username or parsed.password or parsed.query or parsed.fragment:
+        raise OperationsError(f"{label} nie może zawierać credentials, query ani fragmentu")
+    path = parsed.path.rstrip("/")
+    return urlunsplit((parsed.scheme, parsed.netloc, path, "", ""))
+
+
+def _read_token(values: Mapping[str, str]) -> str:
+    token = values.get("SUBACTOR_ADMIN_TOKEN", "").strip()
+    token_file = values.get("SUBACTOR_ADMIN_TOKEN_FILE", "").strip()
+    if token or not token_file:
+        return token
+    path = Path(token_file).expanduser()
+    try:
+        if path.stat().st_size > 16_384:
+            raise OperationsError("Plik tokenu jest zbyt duży")
+        return path.read_text(encoding="utf-8").strip()
+    except OSError as exc:
+        raise OperationsError("Nie można odczytać pliku tokenu") from exc
+
+
+@dataclass(frozen=True)
+class OperationSettings:
+    control_url: str
+    planfile_url: str
+    token: str
+    timeout_seconds: float = 20.0
+
+    @classmethod
+    def from_environment(cls, env: Mapping[str, str] | None = None) -> "OperationSettings":
+        if env is None:
+            apply_control_environment()
+            values = os.environ
+        else:
+            values = env
+        control_url = _validated_origin(
+            values.get("SUBACTOR_CONTROL_URL", "http://127.0.0.1:8091"), "SUBACTOR_CONTROL_URL"
+        )
+        planfile_url = _validated_origin(
+            values.get("SUBACTOR_PLANFILE_URL", values.get("PLANFILE_URL", "http://127.0.0.1:8765")),
+            "SUBACTOR_PLANFILE_URL",
+        )
+        return cls(control_url, planfile_url, _read_token(values))
+
+
+class OperationsClient:
+    def __init__(self, settings: OperationSettings, *, transport: httpx.BaseTransport | None = None) -> None:
+        self.settings = settings
+        self._transport = transport
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: Any = None,
+        service: str = "control",
+        authenticated: bool = True,
+    ) -> tuple[Any, str]:
+        verb = method.upper()
+        if verb not in {"GET", "POST", "PUT", "PATCH", "DELETE"}:
+            raise OperationsError(f"Niedozwolona metoda HTTP: {verb}")
+        if not path.startswith("/") or path.startswith("//") or "\n" in path or "\r" in path:
+            raise OperationsError("Ścieżka API musi być względna wobec skonfigurowanej usługi")
+        if authenticated and not self.settings.token:
+            raise OperationsError(
+                "Brak SUBACTOR_ADMIN_TOKEN lub SUBACTOR_ADMIN_TOKEN_FILE; operacja nie została wysłana"
+            )
+        base = self.settings.planfile_url if service == "planfile" else self.settings.control_url
+        headers = {"Accept": "application/json"}
+        if authenticated:
+            headers["Authorization"] = f"Bearer {self.settings.token}"
+        try:
+            with httpx.Client(timeout=self.settings.timeout_seconds, transport=self._transport) as client:
+                response = client.request(verb, f"{base}{path}", json=body, headers=headers)
+        except httpx.HTTPError as exc:
+            raise OperationsError(f"Usługa {service} jest niedostępna ({exc.__class__.__name__})") from exc
+        if response.status_code >= 400:
+            code = "request_failed"
+            try:
+                problem = response.json()
+                if isinstance(problem, dict):
+                    code = str(problem.get("code") or problem.get("type") or code)[:160]
+            except ValueError:
+                pass
+            raise OperationsError(f"{service} odrzucił żądanie: HTTP {response.status_code} ({code})")
+        try:
+            return response.json(), response.text
+        except ValueError:
+            return response.text, response.text
+
+
+def _ticket_open(ticket: Mapping[str, Any]) -> bool:
+    return str(ticket.get("status", "")).lower() not in _TERMINAL_TICKET_STATES
+
+
+def _ticket_urgent(ticket: Mapping[str, Any]) -> bool:
+    priority = str(ticket.get("priority", "")).lower()
+    labels = {str(value).lower() for value in ticket.get("labels", []) if isinstance(value, str)}
+    name = str(ticket.get("name") or ticket.get("title") or "").upper()
+    return priority in {"urgent", "critical", "high"} or "urgent" in labels or name.startswith(("PILNE", "URGENT"))
+
+
+def filter_tickets(rows: Sequence[Mapping[str, Any]], args: Any) -> list[Mapping[str, Any]]:
+    result = list(rows)
+    if args.open or args.urgent:
+        result = [item for item in result if _ticket_open(item)]
+    if args.urgent:
+        result = [item for item in result if _ticket_urgent(item)]
+    filters = {
+        "queue": args.queue,
+        "state": args.state,
+        "priority": args.priority,
+        "project": args.project,
+    }
+    for field, expected in filters.items():
+        if not expected:
+            continue
+        needle = expected.lower()
+        if field in {"queue", "state"}:
+            result = [item for item in result if needle in str(item.get("execution", {}).get(field, "")).lower()]
+        else:
+            result = [item for item in result if needle in str(item.get(field, "")).lower()]
+    if args.text:
+        needle = args.text.lower()
+        result = [item for item in result if needle in json.dumps(item, ensure_ascii=False).lower()]
+    return sorted(
+        result,
+        key=lambda item: (_ticket_urgent(item), str(item.get("updated_at") or item.get("created_at") or "")),
+        reverse=True,
+    )
+
+
+def _json_payload(raw: str | None) -> Any:
+    if raw is None:
+        return None
+    if len(raw) > 131_072:
+        raise OperationsError("Payload JSON jest zbyt duży")
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as exc:
+        raise OperationsError("Payload musi być poprawnym JSON") from exc
+
+
+def _require_execute(confirmation: str, operation: str) -> None:
+    if confirmation != "EXECUTE":
+        raise OperationsError(f"{operation} wymaga --confirm EXECUTE")
+
+
+def _print_json(console: Console, payload: Any) -> None:
+    console.print_json(json.dumps(payload, ensure_ascii=False))
+
+
+def _print_tickets(console: Console, rows: Sequence[Mapping[str, Any]], control_url: str) -> None:
+    table = Table("Ticket", "Priorytet", "Status", "Kolejka", "Stan", "Nazwa")
+    hyperlinks = terminal_hyperlinks_enabled(is_terminal=console.is_terminal)
+    for item in rows[:50]:
+        ticket = str(item.get("id", "?"))
+        links = canonical_ticket_links(ticket, control_url, limit=1)
+        ticket_text = Text(ticket)
+        if links and hyperlinks:
+            ticket_text.stylize(f"link {links[0][1]}")
+        execution = item.get("execution") if isinstance(item.get("execution"), dict) else {}
+        table.add_row(
+            ticket_text,
+            str(item.get("priority", "normal")),
+            str(item.get("status", "?")),
+            str(execution.get("queue", "?")),
+            str(execution.get("state", "?")),
+            str(item.get("name") or item.get("title") or "")[:80],
+        )
+    console.print(f"{len(rows)} ticket(s)")
+    console.print(table)
+
+
+def run_operational_command(args: Any, console: Console, client: OperationsClient) -> int:
+    command = args.command
+    if command == "health":
+        payload, text = client.request("GET", "/health", authenticated=False)
+        _print_json(console, payload) if not isinstance(payload, str) else console.print(text, markup=False)
+        return 0
+    if command == "status":
+        payload, _ = client.request("GET", "/api/system/dashboard")
+        _print_json(console, payload)
+        return 0
+    if command == "tickets":
+        payload, _ = client.request("GET", "/tickets?sprint=all", service="planfile")
+        rows = payload if isinstance(payload, list) else payload.get("tickets", [])
+        filtered = filter_tickets([item for item in rows if isinstance(item, dict)], args)
+        _print_json(console, filtered) if args.json else _print_tickets(console, filtered, client.settings.control_url)
+        return 0
+    if command == "plans":
+        payload, _ = client.request("GET", "/api/plans?view=summary")
+        plans = payload.get("plans", []) if isinstance(payload, dict) else []
+        if args.status:
+            plans = [item for item in plans if str(item.get("status", "")) == args.status]
+        _print_json(console, plans)
+        return 0
+    if command == "dispatch":
+        _require_execute(args.confirm, "dispatch")
+        payload, _ = client.request("POST", "/api/delegation/dispatch", body={})
+        _print_json(console, payload)
+        return 0
+    if command == "uri":
+        if not _URI.fullmatch(args.uri):
+            raise OperationsError("Nieprawidłowy URI procesu")
+        body = _json_payload(args.payload) or {}
+        if not isinstance(body, dict):
+            raise OperationsError("Payload URI musi być obiektem JSON")
+        if body.get("apply") is True:
+            _require_execute(args.confirm, "URI apply")
+        elif "/command/" in args.uri and "apply" not in body:
+            body["apply"] = False
+        payload, _ = client.request(
+            "POST",
+            "/api/processes/run",
+            body={"uri": args.uri, "payload": body, "reason": f"Canonical Subactor shell: {args.uri}"},
+        )
+        _print_json(console, payload)
+        return 0
+    if command in {"api", "get", "post"}:
+        method = args.method.upper() if command == "api" else command.upper()
+        path = args.path
+        raw_body = getattr(args, "payload", None)
+        if method in _WRITE_METHODS:
+            _require_execute(args.confirm, f"HTTP {method}")
+        payload, text = client.request(method, path, body=_json_payload(raw_body))
+        _print_json(console, payload) if not isinstance(payload, str) else console.print(text, markup=False)
+        return 0
+    if command == "endpoints":
+        console.print(_ENDPOINTS, markup=False)
+        return 0
+    raise OperationsError(f"Nieobsługiwana komenda operacyjna: {command}")

subactor_shell/orchestration.py

@@ -0,0 +1,324 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from .catalog import IntentCatalog
+from .compiler import CompileError, ExecutionPlan, PlanCompiler, compute_plan_hash
+from .config import AppConfig
+from .connectors import (
+    ConnectorError,
+    ConnectorExecutor,
+    ConnectorRegistry,
+    ExecutionReceipt,
+)
+from .models import Session
+from .policy import PolicyEngine
+from .providers import ProviderBundle
+from .routing import Router, RoutingDecision
+from .secret_refs import SecretResolver
+from .store import Store
+
+
+class OrchestrationError(RuntimeError):
+    pass
+
+
+ProviderBuilder = Callable[[Any, SecretResolver], ProviderBundle]
+
+
+@dataclass(slots=True)
+class OrchestrationOutcome:
+    decision: RoutingDecision
+    direct_text: str = ""
+    provider: str = ""
+    model: str = ""
+    route_context: dict[str, Any] | None = None
+    plan: ExecutionPlan | None = None
+    receipt: ExecutionReceipt | None = None
+
+
+class OrchestrationService:
+    def __init__(
+        self,
+        config: AppConfig,
+        store: Store,
+        resolver: SecretResolver,
+        provider_builder: ProviderBuilder,
+    ):
+        self.config = config
+        self.store = store
+        self.resolver = resolver
+        self.provider_builder = provider_builder
+        self.catalog = IntentCatalog.load(config.intent_catalog_paths())
+        self.registry = ConnectorRegistry(config)
+        self.router = Router(
+            config,
+            store,
+            resolver,
+            provider_builder,
+            self.catalog,
+        )
+        self.compiler = PlanCompiler()
+        self.policy = PolicyEngine(
+            allow_destructive=bool(config.orchestration.get("allow_destructive", False))
+        )
+        self.executor = ConnectorExecutor(config, store, resolver, self.registry)
+        self.mode = str(config.orchestration.get("mode", "active")).strip().lower()
+
+    async def prepare(
+        self,
+        session: Session,
+        text: str,
+        *,
+        cancel_event=None,
+    ) -> OrchestrationOutcome:
+        decision = await self.router.route(session, text, cancel_event=cancel_event)
+        for record in decision.parser_usage:
+            try:
+                profile = self.config.provider(record.provider)
+                pricing = {
+                    "input_cost_per_million": profile.input_cost_per_million,
+                    "cached_input_cost_per_million": profile.cached_input_cost_per_million,
+                    "output_cost_per_million": profile.output_cost_per_million,
+                }
+            except (KeyError, ValueError):
+                pricing = {}
+            self.store.record_provider_usage(
+                session.id,
+                provider=record.provider,
+                model=record.model,
+                purpose=record.purpose,
+                usage=record.usage,
+                metadata={"latency_ms": record.latency_ms},
+                **pricing,
+            )
+        self.store.record_routing_decision(
+            session.id,
+            route=decision.route,
+            reason=decision.reason,
+            intent_id=decision.intent_id,
+            confidence=decision.confidence,
+            provider=decision.provider,
+            model=decision.model,
+            candidates=[item.to_dict() for item in decision.candidates],
+            metadata={
+                "parser_errors": decision.parser_errors,
+                "cache_hit": decision.cache_hit,
+                "orchestration_mode": self.mode,
+            },
+        )
+
+        if self.mode == "shadow":
+            return OrchestrationOutcome(
+                decision=decision,
+                provider=self.router.large_provider or session.provider,
+                model=self.router.large_model or session.model,
+                route_context=decision.route_context() | {"shadow_mode": True},
+            )
+
+        if not decision.intent:
+            return OrchestrationOutcome(
+                decision=decision,
+                provider=decision.provider or session.provider,
+                model=decision.model or session.model,
+                route_context=decision.route_context(),
+            )
+
+        definition = self.catalog.get(decision.intent.intent_id)
+        if not definition:
+            return self._fallback(session, decision, "Intent nie istnieje już w katalogu")
+        if decision.intent.unresolved:
+            missing = ", ".join(decision.intent.unresolved)
+            return OrchestrationOutcome(
+                decision=decision,
+                direct_text=(
+                    f"Rozpoznałem intent `{decision.intent.intent_id}`, ale brakuje pól: {missing}. "
+                    "Doprecyzuj je w kolejnej wiadomości."
+                ),
+            )
+        if str(definition.execution.get("kind", "chat")) == "chat":
+            return self._fallback(session, decision, "Intent wymaga odpowiedzi konwersacyjnej")
+
+        try:
+            plan = self.compiler.compile(
+                session_id=session.id,
+                intent=decision.intent,
+                definition=definition,
+                state_fingerprint=self.current_state_fingerprint(),
+                catalog_fingerprint=self.catalog.fingerprint,
+            )
+        except CompileError as exc:
+            return OrchestrationOutcome(
+                decision=decision,
+                direct_text=f"Nie udało się skompilować IntentIR: {exc}",
+            )
+
+        connector_error = self._preflight_connectors(plan)
+        policy = self.policy.evaluate(plan)
+        if connector_error:
+            plan.status = "blocked"
+            self.store.save_execution_plan(plan.to_dict())
+            return OrchestrationOutcome(
+                decision=decision,
+                plan=plan,
+                direct_text=(
+                    self.format_plan(plan)
+                    + "\n\nPlan jest zablokowany: "
+                    + connector_error
+                    + ". Skonfiguruj nazwany connector/operation; bridge nie uruchomi arbitralnego shella."
+                ),
+            )
+        if not policy.allowed:
+            plan.status = "blocked"
+            self.store.save_execution_plan(plan.to_dict())
+            return OrchestrationOutcome(
+                decision=decision,
+                plan=plan,
+                direct_text=self.format_plan(plan) + f"\n\nPlan zablokowany przez politykę: {policy.reason}",
+            )
+
+        if policy.auto_execute:
+            plan.status = "running"
+            self.store.save_execution_plan(plan.to_dict())
+            receipt = await self.executor.execute(plan, approved=False)
+            self.store.save_execution_receipt(receipt.to_dict())
+            plan.status = "executed" if receipt.ok else "failed"
+            self.store.update_plan_status(plan.id, plan.status)
+            self.store.record_router_feedback(
+                session.id,
+                intent_id=plan.intent_id,
+                route=decision.route,
+                success=receipt.ok,
+                metadata={"plan_id": plan.id, "receipt_id": receipt.id},
+            )
+            return OrchestrationOutcome(
+                decision=decision,
+                plan=plan,
+                receipt=receipt,
+                direct_text=self.format_receipt(receipt),
+            )
+
+        plan.status = "pending_approval" if policy.requires_approval else "planned"
+        self.store.save_execution_plan(plan.to_dict())
+        suffix = (
+            f"\n\nAby wykonać plan, użyj `/apply {plan.id}` i wpisz dokładnie `EXECUTE`."
+            if policy.requires_approval
+            else f"\n\nPlan zapisano. Możesz użyć `/apply {plan.id}`."
+        )
+        return OrchestrationOutcome(
+            decision=decision,
+            plan=plan,
+            direct_text=self.format_plan(plan) + suffix,
+        )
+
+    async def apply_plan(self, plan_id: str, *, confirmation: str = "") -> ExecutionReceipt:
+        payload = self.store.get_execution_plan(plan_id)
+        if not payload:
+            raise OrchestrationError(f"Nie ma planu {plan_id}")
+        plan = ExecutionPlan.from_dict(payload)
+        if plan.status not in {"planned", "pending_approval", "failed"}:
+            raise OrchestrationError(f"Plan ma status {plan.status} i nie może zostać zastosowany")
+        if plan.plan_hash != compute_plan_hash(plan):
+            raise OrchestrationError("Plan hash nie zgadza się z zapisaną treścią planu")
+        if plan.effect != "read" and confirmation != "EXECUTE":
+            raise OrchestrationError("Operacja zmienia stan; wymagane jest dokładne potwierdzenie EXECUTE")
+        current = self.current_state_fingerprint()
+        if current != plan.state_fingerprint:
+            raise OrchestrationError(
+                "Lokalny stan/katalog/connector registry zmienił się od utworzenia planu; utwórz nowy plan"
+            )
+        connector_error = self._preflight_connectors(plan)
+        if connector_error:
+            raise OrchestrationError(connector_error)
+        policy = self.policy.evaluate(plan)
+        if not policy.allowed:
+            raise OrchestrationError(policy.reason)
+        self.store.update_plan_status(plan.id, "running")
+        receipt = await self.executor.execute(plan, approved=True)
+        self.store.save_execution_receipt(receipt.to_dict())
+        self.store.update_plan_status(plan.id, "executed" if receipt.ok else "failed")
+        self.store.record_router_feedback(
+            plan.session_id,
+            intent_id=plan.intent_id,
+            route="approved_plan",
+            success=receipt.ok,
+            metadata={"plan_id": plan.id, "receipt_id": receipt.id},
+        )
+        return receipt
+
+    def current_state_fingerprint(self) -> str:
+        encoded = ":".join(
+            [self.store.state_fingerprint(), self.catalog.fingerprint, self.registry.fingerprint]
+        )
+        return hashlib.sha256(encoded.encode("ascii")).hexdigest()
+
+    def _preflight_connectors(self, plan: ExecutionPlan) -> str:
+        try:
+            for step in plan.steps:
+                self.registry.validate_step(step)
+        except ConnectorError as exc:
+            return str(exc)
+        return ""
+
+    def _fallback(
+        self, session: Session, decision: RoutingDecision, reason: str
+    ) -> OrchestrationOutcome:
+        provider = decision.provider or self.router.large_provider or session.provider
+        model = decision.model or self.router.large_model
+        if not model:
+            try:
+                model = self.config.provider(provider).model
+            except (KeyError, ValueError):
+                model = session.model
+        context = decision.route_context()
+        context["fallback_reason"] = reason
+        return OrchestrationOutcome(
+            decision=decision,
+            provider=provider,
+            model=model,
+            route_context=context,
+        )
+
+    @staticmethod
+    def format_plan(plan: ExecutionPlan) -> str:
+        lines = [
+            f"Plan `{plan.id}`",
+            f"intent: `{plan.intent_id}`",
+            f"effect: `{plan.effect}` · status: `{plan.status}`",
+            f"hash: `{plan.plan_hash}`",
+            "kroki:",
+        ]
+        for index, step in enumerate(plan.steps, start=1):
+            args = json.dumps(step.args, ensure_ascii=False, separators=(",", ":"))
+            if len(args) > 500:
+                args = args[:500] + "…"
+            lines.append(f"{index}. `{step.connector}:{step.operation}` ({step.effect}) args={args}")
+        return "\n".join(lines)
+
+    @staticmethod
+    def format_receipt(receipt: ExecutionReceipt) -> str:
+        # Builtin help is more useful as plain text than as nested JSON.
+        if len(receipt.steps) == 1 and receipt.steps[0].get("ok"):
+            result = receipt.steps[0].get("result")
+            if isinstance(result, dict) and isinstance(result.get("message"), str):
+                return result["message"] + f"\n\nReceipt `{receipt.id}`"
+        lines = [
+            f"Receipt `{receipt.id}` · plan `{receipt.plan_id}`",
+            f"wynik: `{'ok' if receipt.ok else 'failed'}`",
+            receipt.summary,
+        ]
+        for step in receipt.steps:
+            state = "ok" if step.get("ok") else "failed"
+            lines.append(f"- `{step.get('connector')}:{step.get('operation')}`: {state}")
+            result = step.get("result")
+            if isinstance(result, dict) and result:
+                encoded = json.dumps(result, ensure_ascii=False, default=str)
+                if len(encoded) > 1500:
+                    encoded = encoded[:1500] + "…"
+                lines.append(f"  {encoded}")
+            if step.get("error"):
+                lines.append(f"  {str(step['error'])[:1000]}")
+        return "\n".join(lines)

subactor_shell/policy.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+
+from .compiler import ExecutionPlan
+
+
+@dataclass(slots=True)
+class PolicyDecision:
+    allowed: bool
+    reason: str
+    requires_approval: bool = False
+    auto_execute: bool = False
+
+
+class PolicyEngine:
+    def __init__(self, *, allow_destructive: bool = False):
+        self.allow_destructive = allow_destructive
+
+    def evaluate(self, plan: ExecutionPlan) -> PolicyDecision:
+        encoded = json.dumps(plan.to_dict(), ensure_ascii=False).casefold()
+        if "{{secret:" in encoded or "vault://" in encoded or "env://" in encoded or "file://" in encoded:
+            return PolicyDecision(
+                False,
+                "Plan nie może przenosić wartości ani referencji sekretów; connector może użyć wyłącznie lokalnego env_ref z konfiguracji",
+            )
+        if plan.effect == "destructive" and not self.allow_destructive:
+            return PolicyDecision(False, "Operacje destructive są wyłączone przez politykę")
+        if plan.effect == "read":
+            if plan.mode == "execute":
+                return PolicyDecision(True, "Odczyt może zostać wykonany lokalnie", auto_execute=True)
+            return PolicyDecision(True, "Użytkownik zażądał tylko planu odczytu")
+        return PolicyDecision(
+            True,
+            "Operacja zmienia stan i wymaga jawnego grantu apply",
+            requires_approval=True,
+        )