plan-manager-client-dev 0.2.186__py3-none-any.whl

plan_manager_client/facade_runtime_mixin/facade.py

@@ -0,0 +1,380 @@
+"""Module for split package."""
+
+from __future__ import annotations
+from typing import Any
+from .overlay_part import RuntimeOverlayPart
+from .authoring_part import ABSENT, RuntimeAuthoringPart
+
+class RuntimeCommandsMixin:
+    """One method per plan_manager command in the runtime work-item family.
+
+    Assumes it is mixed into a class that also inherits
+    plan_manager_client.dispatch._CommandDispatchMixin, which supplies the
+    coroutine async def _call(self, command: str, params: dict[str, Any] | None = None) -> Any
+    used by every method below."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.runtimeOverlayPart = RuntimeOverlayPart(self)
+        self.runtimeAuthoringPart = RuntimeAuthoringPart(self)
+
+    async def todo_create(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_create(**params)
+
+    async def todo_get(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_get(**params)
+
+    async def todo_list(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_list(**params)
+
+    async def todo_update(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_update(**params)
+
+    async def todo_reanchor(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_reanchor(**params)
+
+    async def todo_resolve(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_resolve(**params)
+
+    async def todo_close(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_close(**params)
+
+    async def todo_reopen(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_reopen(**params)
+
+    async def todo_delete(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_delete(**params)
+
+    async def todo_link_add(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_link_add(**params)
+
+    async def todo_link_remove(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_link_remove(**params)
+
+    async def todo_link_get(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_link_get(**params)
+
+    async def todo_link_list(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_link_list(**params)
+
+    async def todo_link_delete(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_link_delete(**params)
+
+    async def todo_queue(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.todo_queue(**params)
+
+    async def wish_create(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.wish_create(**params)
+
+    async def wish_get(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.wish_get(**params)
+
+    async def wish_list(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.wish_list(**params)
+
+    async def wish_update(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.wish_update(**params)
+
+    async def wish_reanchor(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.wish_reanchor(**params)
+
+    async def wish_delete(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.wish_delete(**params)
+
+    async def calendar_entry_create(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.calendar_entry_create(**params)
+
+    async def calendar_entry_get(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.calendar_entry_get(**params)
+
+    async def calendar_entry_list(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.calendar_entry_list(**params)
+
+    async def calendar_entry_update(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.calendar_entry_update(**params)
+
+    async def calendar_entry_reanchor(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.calendar_entry_reanchor(**params)
+
+    async def calendar_entry_delete(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.calendar_entry_delete(**params)
+
+    async def runtime_link_add(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.runtime_link_add(**params)
+
+    async def runtime_link_list(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.runtime_link_list(**params)
+
+    async def runtime_link_remove(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.runtime_link_remove(**params)
+
+    async def runtime_link_get(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.runtime_link_get(**params)
+
+    async def runtime_link_delete(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.runtime_link_delete(**params)
+
+    async def runtime_overlay_export(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.runtime_overlay_export(**params)
+
+    async def runtime_overlay_import(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.runtime_overlay_import(**params)
+
+    async def comment_add(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.comment_add(**params)
+
+    async def comment_get(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.comment_get(**params)
+
+    async def comment_list(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.comment_list(**params)
+
+    async def comment_supersede(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.comment_supersede(**params)
+
+    async def comment_resolve(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.comment_resolve(**params)
+
+    async def comment_update(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.comment_update(**params)
+
+    async def comment_reanchor(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.comment_reanchor(**params)
+
+    async def comment_delete(self, **params: Any) -> Any:
+        return await self.runtimeOverlayPart.comment_delete(**params)
+
+    async def authoring_usage_get(self, step: str, include_descendants: bool, plan: str | None = None) -> Any:
+        return await self.runtimeAuthoringPart.authoring_usage_get(
+            step, include_descendants, plan=plan
+        )
+
+    async def model_binding_set(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.model_binding_set(**params)
+
+    async def model_binding_get(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.model_binding_get(**params)
+
+    async def model_binding_list(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.model_binding_list(**params)
+
+    async def model_binding_update(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.model_binding_update(**params)
+
+    async def model_binding_remove(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.model_binding_remove(**params)
+
+    async def model_binding_resolve(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.model_binding_resolve(**params)
+
+    async def authoring_session_create(
+        self,
+        plan: str,
+        common_prompt_document_id: str | None = None,
+        executor_prompt_document_ids: dict[str, str] | None = None,
+    ) -> Any:
+        return await self.runtimeAuthoringPart.authoring_session_create(
+            plan, common_prompt_document_id, executor_prompt_document_ids
+        )
+
+    async def authoring_session_get(self, session_id: Any = ABSENT, **unknown: Any) -> Any:
+        return await self.runtimeAuthoringPart.authoring_session_get(session_id, **unknown)
+
+    async def authoring_session_list(self, plan: Any = ABSENT, include_deleted: Any = ABSENT, limit: Any = ABSENT, offset: Any = ABSENT, **unknown: Any) -> Any:
+        return await self.runtimeAuthoringPart.authoring_session_list(plan, include_deleted, limit, offset, **unknown)
+
+    async def authoring_session_update(
+        self,
+        session_id: Any = ABSENT,
+        changed_by: Any = ABSENT,
+        common_prompt_document_id: Any = ABSENT,
+        executor_prompt_document_ids: Any = ABSENT,
+        **unknown: Any,
+    ) -> Any:
+        return await self.runtimeAuthoringPart.authoring_session_update(
+            session_id, changed_by, common_prompt_document_id, executor_prompt_document_ids, **unknown
+        )
+
+    async def authoring_session_delete(
+        self,
+        session_id: Any = ABSENT,
+        changed_by: Any = ABSENT,
+        hard: bool = False,
+        recursive: bool = False,
+        dry_run: bool = False,
+        drop_dialogue: Any = ABSENT,
+        **unknown: Any,
+    ) -> Any:
+        return await self.runtimeAuthoringPart.authoring_session_delete(
+            session_id, changed_by, hard=hard, recursive=recursive, dry_run=dry_run, drop_dialogue=drop_dialogue, **unknown
+        )
+
+    async def authoring_job_start(
+        self,
+        plan: str,
+        step: str,
+        session_id: str,
+        orchestrator_model_id: str | None = None,
+    ) -> Any:
+        return await self.runtimeAuthoringPart.authoring_job_start(
+            plan, step, session_id, orchestrator_model_id
+        )
+
+    async def authoring_job_status(
+        self, plan: str, step: str, session_id: str
+    ) -> Any:
+        return await self.runtimeAuthoringPart.authoring_job_status(
+            plan, step, session_id
+        )
+
+    async def authoring_job_resume(
+        self,
+        plan: str,
+        step: str,
+        session_id: str,
+        answer: str,
+        orchestrator_model_id: str | None = None,
+    ) -> Any:
+        return await self.runtimeAuthoringPart.authoring_job_resume(
+            plan, step, session_id, answer, orchestrator_model_id
+        )
+
+    async def authoring_job_stop(self, plan: str, step: str, session_id: str) -> Any:
+        return await self.runtimeAuthoringPart.authoring_job_stop(
+            plan, step, session_id
+        )
+
+    async def authoring_job_delete(self, job_id: Any = ABSENT, hard: bool = False, recursive: bool = False, **unknown: Any) -> Any:
+        return await self.runtimeAuthoringPart.authoring_job_delete(job_id, hard=hard, recursive=recursive, **unknown)
+
+    async def authoring_job_get(self, job_id: Any = ABSENT, **unknown: Any) -> Any:
+        return await self.runtimeAuthoringPart.authoring_job_get(job_id, **unknown)
+
+    async def authoring_job_update(self, job_id: Any = ABSENT, changed_by: Any = ABSENT, state: str | None = None, result: dict[str, Any] | None = None, question: str | None = None, answer: str | None = None, error_reason: str | None = None, **unknown: Any) -> Any:
+        return await self.runtimeAuthoringPart.authoring_job_update(job_id, changed_by, state=state, result=result, question=question, answer=answer, error_reason=error_reason, **unknown)
+
+    async def authoring_child_list(self, step: str, plan: str | None = None) -> Any:
+        return await self.runtimeAuthoringPart.authoring_child_list(step, plan=plan)
+
+    async def authoring_context_read(self, section: Any = ABSENT, ids: Any = ABSENT, offset: Any = ABSENT, limit: Any = ABSENT, **unknown: Any) -> Any:
+        return await self.runtimeAuthoringPart.authoring_context_read(section, ids, offset, limit, **unknown)
+
+    async def authoring_child_write(self, children: Any = ABSENT, **unknown: Any) -> Any:
+        return await self.runtimeAuthoringPart.authoring_child_write(children, **unknown)
+
+    async def authoring_child_start(self, steps: Any = ABSENT, restart: Any = ABSENT, **unknown: Any) -> Any:
+        return await self.runtimeAuthoringPart.authoring_child_start(steps, restart, **unknown)
+
+    async def authoring_child_status(self, steps: Any = ABSENT, **unknown: Any) -> Any:
+        return await self.runtimeAuthoringPart.authoring_child_status(steps, **unknown)
+
+    async def authoring_child_wait(self, until: Any = ABSENT, timeout_seconds: Any = ABSENT, **unknown: Any) -> Any:
+        return await self.runtimeAuthoringPart.authoring_child_wait(until, timeout_seconds, **unknown)
+
+    async def authoring_child_answer(self, answers: Any = ABSENT, **unknown: Any) -> Any:
+        return await self.runtimeAuthoringPart.authoring_child_answer(answers, **unknown)
+
+    async def authoring_step_create(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.authoring_step_create(**params)
+
+    async def authoring_step_update(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.authoring_step_update(**params)
+
+    async def authoring_step_delete(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.authoring_step_delete(**params)
+
+    async def authoring_step_submit(self, step_payload: dict[str, Any]) -> Any:
+        return await self.runtimeAuthoringPart.authoring_step_submit(step_payload)
+
+    async def authoring_escalate(self, question: str) -> Any:
+        return await self.runtimeAuthoringPart.authoring_escalate(question)
+
+    async def execution_attempt_create(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.execution_attempt_create(**params)
+
+    async def execution_attempt_report(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.execution_attempt_report(**params)
+
+    async def execution_attempt_get(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.execution_attempt_get(**params)
+
+    async def execution_attempt_list(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.execution_attempt_list(**params)
+
+    async def execution_attempt_supersede(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.execution_attempt_supersede(**params)
+
+    async def execution_attempt_delete(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.execution_attempt_delete(**params)
+
+    async def review_result_create(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.review_result_create(**params)
+
+    async def review_result_get(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.review_result_get(**params)
+
+    async def review_result_list(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.review_result_list(**params)
+
+    async def review_result_supersede(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.review_result_supersede(**params)
+
+    async def review_result_delete(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.review_result_delete(**params)
+
+    async def escalation_create(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.escalation_create(**params)
+
+    async def escalation_get(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.escalation_get(**params)
+
+    async def escalation_list(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.escalation_list(**params)
+
+    async def escalation_resolve(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.escalation_resolve(**params)
+
+    async def escalation_reanchor(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.escalation_reanchor(**params)
+
+    async def escalation_delete(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.escalation_delete(**params)
+
+    async def escalation_update(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.escalation_update(**params)
+
+    async def escalation_policy_create(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.escalation_policy_create(**params)
+
+    async def escalation_policy_get(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.escalation_policy_get(**params)
+
+    async def escalation_policy_list(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.escalation_policy_list(**params)
+
+    async def escalation_policy_update(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.escalation_policy_update(**params)
+
+    async def escalation_policy_delete(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.escalation_policy_delete(**params)
+
+    async def escalation_policy_get_active(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.escalation_policy_get_active(**params)
+
+    async def answer_envelope_create(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.answer_envelope_create(**params)
+
+    async def answer_envelope_get(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.answer_envelope_get(**params)
+
+    async def answer_envelope_list(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.answer_envelope_list(**params)
+
+    async def answer_envelope_update(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.answer_envelope_update(**params)
+
+    async def answer_envelope_delete(self, **params: Any) -> Any:
+        return await self.runtimeAuthoringPart.answer_envelope_delete(**params)
+
+
+

plan_manager_client/facade_runtime_mixin/overlay_part.py

@@ -0,0 +1,192 @@
+"""Module for split package."""
+
+from __future__ import annotations
+from typing import Any
+
+class RuntimeOverlayPart:
+    """One method per plan_manager command in the runtime work-item family.
+
+    Assumes it is mixed into a class that also inherits
+    plan_manager_client.dispatch._CommandDispatchMixin, which supplies the
+    coroutine async def _call(self, command: str, params: dict[str, Any] | None = None) -> Any
+    used by every method below."""
+
+    def __init__(self, owner):
+        self._owner = owner
+
+    def __getattr__(self, name):
+        """Resolve names this part does not define on the owning facade."""
+        if name == "_owner":
+            raise AttributeError(name)
+        return getattr(self._owner, name)
+
+    async def todo_create(self, **params: Any) -> Any:
+        """Create a new TODO work item with a primary anchor."""
+        return await self._call("todo_create", params)
+
+    async def todo_get(self, **params: Any) -> Any:
+        """Fetch a single TODO work item by identifier."""
+        return await self._call("todo_get", params)
+
+    async def todo_list(self, **params: Any) -> Any:
+        """List TODO work items with uniform filtering and pagination."""
+        return await self._call("todo_list", params)
+
+    async def todo_update(self, **params: Any) -> Any:
+        """Update mutable fields of an existing TODO work item."""
+        return await self._call("todo_update", params)
+
+    async def todo_reanchor(self, **params: Any) -> Any:
+        """Move a TODO item's primary anchor to a new target, with an audit record."""
+        return await self._call("todo_reanchor", params)
+
+    async def todo_resolve(self, **params: Any) -> Any:
+        """Mark a TODO work item resolved."""
+        return await self._call("todo_resolve", params)
+
+    async def todo_close(self, **params: Any) -> Any:
+        """Mark a TODO work item closed."""
+        return await self._call("todo_close", params)
+
+    async def todo_reopen(self, **params: Any) -> Any:
+        """Reopen a TODO work item from a terminal state."""
+        return await self._call("todo_reopen", params)
+
+    async def todo_delete(self, **params: Any) -> Any:
+        """Delete a TODO work item: soft by default, hard=true gated by the inbound-reference integrity check, dry_run previews."""
+        return await self._call("todo_delete", params)
+
+    async def todo_link_add(self, **params: Any) -> Any:
+        """Create a typed link between two TODO work items."""
+        return await self._call("todo_link_add", params)
+
+    async def todo_link_remove(self, **params: Any) -> Any:
+        """Remove (soft-delete) a typed link between two TODO work items."""
+        return await self._call("todo_link_remove", params)
+
+    async def todo_link_get(self, **params: Any) -> Any:
+        """Read one todo link by its id (parameters passed through; the server validates them)."""
+        return await self._call("todo_link_get", params)
+
+    async def todo_link_list(self, **params: Any) -> Any:
+        """List todo links with filters and pagination (parameters passed through; the server validates them)."""
+        return await self._call("todo_link_list", params)
+
+    async def todo_link_delete(self, **params: Any) -> Any:
+        """Delete a todo link: mark by default, hard=true removes a marked link, dry_run previews (parameters passed through; the server validates them)."""
+        return await self._call("todo_link_delete", params)
+
+    async def todo_queue(self, **params: Any) -> Any:
+        """Surface a paginated page of the TODO-derived portion of the unified runtime work queue."""
+        return await self._call("todo_queue", params)
+
+    async def wish_create(self, **params: Any) -> Any:
+        """Create a new runtime wish item."""
+        return await self._call("wish_create", params)
+
+    async def wish_get(self, **params: Any) -> Any:
+        """Fetch a single runtime wish item by identifier."""
+        return await self._call("wish_get", params)
+
+    async def wish_list(self, **params: Any) -> Any:
+        """List runtime wish items with filtering and pagination."""
+        return await self._call("wish_list", params)
+
+    async def wish_update(self, **params: Any) -> Any:
+        """Update mutable fields of a runtime wish item."""
+        return await self._call("wish_update", params)
+
+    async def wish_reanchor(self, **params: Any) -> Any:
+        """Move a wish item's primary anchor to a new target, with an audit record."""
+        return await self._call("wish_reanchor", params)
+
+    async def wish_delete(self, **params: Any) -> Any:
+        """Delete a runtime wish item: soft by default, hard=true gated by the inbound-reference integrity check, dry_run previews."""
+        return await self._call("wish_delete", params)
+
+    async def calendar_entry_create(self, **params: Any) -> Any:
+        """Create a calendar-based work entry spanning one or more calendar days."""
+        return await self._call("calendar_entry_create", params)
+
+    async def calendar_entry_get(self, **params: Any) -> Any:
+        """Fetch one calendar-based work entry by identifier."""
+        return await self._call("calendar_entry_get", params)
+
+    async def calendar_entry_list(self, **params: Any) -> Any:
+        """List calendar-based work entries with filtering and pagination."""
+        return await self._call("calendar_entry_list", params)
+
+    async def calendar_entry_update(self, **params: Any) -> Any:
+        """Update mutable fields of a calendar-based work entry."""
+        return await self._call("calendar_entry_update", params)
+
+    async def calendar_entry_reanchor(self, **params: Any) -> Any:
+        """Move a calendar entry's primary anchor to a new target, with an audit record."""
+        return await self._call("calendar_entry_reanchor", params)
+
+    async def calendar_entry_delete(self, **params: Any) -> Any:
+        """Delete a calendar-based work entry: soft by default, hard=true available, dry_run previews."""
+        return await self._call("calendar_entry_delete", params)
+
+    async def runtime_link_add(self, **params: Any) -> Any:
+        """Create a typed link between two runtime records, each independently a bug or a todo."""
+        return await self._call("runtime_link_add", params)
+
+    async def runtime_link_list(self, **params: Any) -> Any:
+        """List generic runtime links, optionally filtered to one endpoint record, with uniform pagination."""
+        return await self._call("runtime_link_list", params)
+
+    async def runtime_link_remove(self, **params: Any) -> Any:
+        """Remove (soft-delete) a generic runtime link, with an optional dry-run preview."""
+        return await self._call("runtime_link_remove", params)
+
+    async def runtime_link_get(self, **params: Any) -> Any:
+        """Read one runtime link by its id (parameters passed through; the server validates them)."""
+        return await self._call("runtime_link_get", params)
+
+    async def runtime_link_delete(self, **params: Any) -> Any:
+        """Delete a runtime link: mark by default, hard=true removes a marked link, dry_run previews (parameters passed through; the server validates them)."""
+        return await self._call("runtime_link_delete", params)
+
+    async def runtime_overlay_export(self, **params: Any) -> Any:
+        """Export the runtime overlay of one plan to overlay.json in the plan export folder (parameters passed through)."""
+        return await self._call("runtime_overlay_export", params)
+
+    async def runtime_overlay_import(self, **params: Any) -> Any:
+        """Import a runtime overlay file into its plan, all or nothing; dry_run validates and counts only (parameters passed through)."""
+        return await self._call("runtime_overlay_import", params)
+
+    async def comment_add(self, **params: Any) -> Any:
+        """Create a new runtime comment attached to a comment anchor."""
+        return await self._call("comment_add", params)
+
+    async def comment_get(self, **params: Any) -> Any:
+        """Retrieve a single runtime comment by identifier."""
+        return await self._call("comment_get", params)
+
+    async def comment_list(self, **params: Any) -> Any:
+        """List runtime comments with uniform filtering and pagination."""
+        return await self._call("comment_list", params)
+
+    async def comment_supersede(self, **params: Any) -> Any:
+        """Create a new runtime comment that supersedes an existing one, preserving history."""
+        return await self._call("comment_supersede", params)
+
+    async def comment_resolve(self, **params: Any) -> Any:
+        """Mark an existing runtime comment as resolved."""
+        return await self._call("comment_resolve", params)
+
+    async def comment_update(self, **params: Any) -> Any:
+        """Change the body, kind, visibility or author of a runtime comment in place (parameters passed through; the server validates them)."""
+        return await self._call("comment_update", params)
+
+    async def comment_reanchor(self, **params: Any) -> Any:
+        """Move a runtime comment's primary anchor to a new target, with an audit record."""
+        return await self._call("comment_reanchor", params)
+
+    async def comment_delete(self, **params: Any) -> Any:
+        """Delete a runtime comment: soft by default, hard=true gated by the inbound-reference integrity check, dry_run previews."""
+        return await self._call("comment_delete", params)
+
+
+