@event4u/agent-config 6.1.0 → 7.0.1

package/dist/agent-src/templates/scripts/work_engine/hooks/builtin/chat_history_append.py

@@ -1,43 +0,0 @@
-"""``ChatHistoryAppendHook`` — phase-boundary persistence.
-
-Fires on ``after_step``. Appends a ``--type phase`` entry whenever a
-step closed with ``Outcome.SUCCESS``. Failures bubble up as
-:class:`HookError` so the runner converts them to warnings — append
-errors must not break the main flow.
-"""
-from __future__ import annotations
-
-import json
-from typing import Any
-
-from ..context import HookContext
-from ..events import HookEvent
-from ..exceptions import HookError
-from ..registry import HookRegistry
-from ._chat_history_base import EXIT_OK, _ChatHistoryHookBase
-
-
-class ChatHistoryAppendHook(_ChatHistoryHookBase):
-    """Append a phase-boundary entry after every successful step."""
-
-    def register(self, registry: HookRegistry) -> None:
-        registry.register(HookEvent.AFTER_STEP, self._on_after_step)
-
-    def _on_after_step(self, ctx: HookContext) -> None:
-        from ...delivery_state import Outcome  # local: avoid import cycle.
-
-        result = ctx.result
-        if result is None or getattr(result, "outcome", None) != Outcome.SUCCESS:
-            return
-        payload: dict[str, Any] = {"step": ctx.step_name or "<unknown>"}
-        proc = self._invoke(
-            "append",
-            "--type", "phase", "--json", json.dumps(payload),
-        )
-        if proc.returncode != EXIT_OK:
-            raise HookError(
-                f"chat-history append failed (exit {proc.returncode})"
-            )
-
-
-__all__ = ["ChatHistoryAppendHook"]

package/dist/agent-src/templates/scripts/work_engine/hooks/builtin/chat_history_halt_append.py

@@ -1,41 +0,0 @@
-"""``ChatHistoryHaltAppendHook`` — capture halt surfaces in the log.
-
-Fires on ``on_halt``. Records a ``--type decision`` entry with the
-step name and any pending questions so a fresh chat can resume from
-the persisted log alone.
-"""
-from __future__ import annotations
-
-import json
-
-from ..context import HookContext
-from ..events import HookEvent
-from ..exceptions import HookError
-from ..registry import HookRegistry
-from ._chat_history_base import EXIT_OK, _ChatHistoryHookBase
-
-
-class ChatHistoryHaltAppendHook(_ChatHistoryHookBase):
-    """Append a decision entry whenever a step halts."""
-
-    def register(self, registry: HookRegistry) -> None:
-        registry.register(HookEvent.ON_HALT, self._on_halt)
-
-    def _on_halt(self, ctx: HookContext) -> None:
-        questions: list[str] = []
-        if ctx.result is not None:
-            questions = list(getattr(ctx.result, "questions", []) or [])
-        if not questions and ctx.delivery is not None:
-            questions = list(getattr(ctx.delivery, "questions", []) or [])
-        payload = {"step": ctx.step_name or "<unknown>", "questions": questions}
-        proc = self._invoke(
-            "append",
-            "--type", "decision", "--json", json.dumps(payload),
-        )
-        if proc.returncode != EXIT_OK:
-            raise HookError(
-                f"chat-history halt-append failed (exit {proc.returncode})"
-            )
-
-
-__all__ = ["ChatHistoryHaltAppendHook"]

package/dist/agent-src/templates/scripts/work_engine/hooks/builtin/decision_gate.py

@@ -1,162 +0,0 @@
-"""``DecisionGateHook`` — refuse to advance when an opt-in gate fires.
-
-Bridges :mod:`work_engine.scoring.decision_engine` into the dispatcher
-hook bus. Reads the gate config from
-:class:`work_engine.hooks.settings.HookSettings.decision_engine` and
-fires on ``AFTER_STEP`` only for the phase each gate owns.
-
-Gate-conflict resolution and the non-TTY timeout protocol live in
-``docs/contracts/decision-engine-gates.md``. The hook only consumes
-them; it never re-implements gate logic.
-
-Three actions, mapped 1:1 from :func:`evaluate_gates`:
-
-- ``stop``        → raise :class:`HookHalt` with a numbered-option
-                    surface. Dispatcher returns ``BLOCKED``.
-- ``warn``        → raise :class:`HookError` so the runner logs the
-                    reason and the step proceeds.
-- ``ask_timeout`` → non-interactive context; apply
-                    ``on_block_fallback`` and re-resolve to ``stop``
-                    or ``warn``. ``block_reason=ask_timeout`` is
-                    surfaced verbatim so the trace records it.
-- ``ask``         → interactive context; for the CLI integration this
-                    collapses to ``stop`` with the prompt surface,
-                    matching how every other ``HookHalt`` is rendered.
-                    The interactive resumption path is owned by the
-                    CLI, not by the hook.
-
-Default-off: when ``settings.decision_engine`` is ``None`` or every
-gate is ``off`` the hook short-circuits without examining state.
-"""
-from __future__ import annotations
-
-from typing import Any
-
-from ...scoring.decision_engine import (
-    DecisionEngineSettings,
-    GateDecision,
-    evaluate_gates,
-)
-from ...scoring.decision_trace import (
-    derive_confidence_band,
-    derive_risk_class,
-    summarise_memory,
-    summarise_verify,
-)
-from ..context import HookContext
-from ..events import HookEvent
-from ..exceptions import HookError, HookHalt
-from ..registry import HookRegistry
-
-_BLOCK_REASON_PREFIX = "decision_gate"
-
-
-class DecisionGateHook:
-    """Evaluate decision-engine gates on every ``AFTER_STEP``.
-
-    Parameters
-    ----------
-    settings:
-        Resolved :class:`DecisionEngineSettings`. The hook stores it as
-        a frozen reference; tests pass a fresh instance per scenario.
-    """
-
-    def __init__(self, settings: DecisionEngineSettings) -> None:
-        self._settings = settings
-
-    def register(self, registry: HookRegistry) -> None:
-        """Register the gate callback on ``AFTER_STEP``."""
-        registry.register(HookEvent.AFTER_STEP, self._evaluate)
-
-    # -- lifecycle callback ------------------------------------------
-
-    def _evaluate(self, ctx: HookContext) -> None:
-        if not self._settings.any_gate_active:
-            return
-        phase = ctx.step_name
-        if not phase:
-            return
-        delivery = ctx.delivery
-        memory = summarise_memory(getattr(delivery, "memory", None))
-        verify = summarise_verify(getattr(delivery, "verify", None))
-        ambiguity = bool(getattr(delivery, "questions", None))
-        decision = evaluate_gates(
-            self._settings,
-            phase=phase,
-            confidence_band=derive_confidence_band(
-                memory_hits=memory["hits"],
-                verify_claims=verify["claims"],
-                verify_first_try_passes=verify["first_try_passes"],
-                ambiguity_flag=ambiguity,
-            ),
-            risk_class=derive_risk_class(
-                getattr(delivery, "changes", None),
-            ),
-            memory_hits=memory["hits"],
-        )
-        if decision is None:
-            return
-        self._apply(decision)
-
-    # -- action dispatch ----------------------------------------------
-
-    def _apply(self, decision: GateDecision) -> None:
-        action = decision.action
-        if action == "warn":
-            raise HookError(self._format_reason(decision))
-        if action == "ask_timeout":
-            fallback = self._settings.on_block_fallback
-            if fallback == "warn":
-                raise HookError(self._format_reason(decision, suffix="ask_timeout"))
-            raise HookHalt(
-                f"{_BLOCK_REASON_PREFIX}:{decision.gate_id}:ask_timeout",
-                surface=self._surface(decision, suffix="ask_timeout"),
-            )
-        raise HookHalt(
-            f"{_BLOCK_REASON_PREFIX}:{decision.gate_id}",
-            surface=self._surface(decision),
-        )
-
-    # -- formatting helpers -------------------------------------------
-
-    @staticmethod
-    def _format_reason(decision: GateDecision, *, suffix: str = "") -> str:
-        tag = f"{_BLOCK_REASON_PREFIX}:{decision.gate_id}"
-        if suffix:
-            tag = f"{tag}:{suffix}"
-        return f"{tag} — {decision.reason}"
-
-    @staticmethod
-    def _surface(
-        decision: GateDecision, *, suffix: str = "",
-    ) -> list[str]:
-        header = f"Decision-engine gate fired: {decision.gate_id} (phase={decision.phase})"
-        if suffix:
-            header = f"{header} [{suffix}]"
-        return [
-            header,
-            f"Reason: {decision.reason}",
-            "1) Address the gate condition and resume.",
-            "2) Lower the gate in `.agent-settings.yml` "
-            "(`decision_engine` block) and resume.",
-            "3) Abort the run.",
-        ]
-
-
-def build_decision_gate_hook(
-    settings: Any,
-) -> DecisionGateHook | None:
-    """Construct the hook from a :class:`DecisionEngineSettings`-like
-    object. Returns ``None`` when the config is absent or every gate is
-    ``off``; the bootstrap layer then skips registration entirely.
-    """
-    if settings is None:
-        return None
-    if not isinstance(settings, DecisionEngineSettings):
-        return None
-    if not settings.any_gate_active:
-        return None
-    return DecisionGateHook(settings)
-
-
-__all__ = ["DecisionGateHook", "build_decision_gate_hook"]

package/dist/agent-src/templates/scripts/work_engine/hooks/builtin/decision_trace.py

@@ -1,163 +0,0 @@
-"""``DecisionTraceHook`` — emit a decision-trace JSON per phase.
-
-Implements the v1 envelope from ``docs/contracts/decision-trace-v1.md``.
-Default-off; opt-in via ``.agent-settings.yml``
-``decision_engine.surface_traces: true`` (mirrored into
-``hooks.decision_trace.enabled`` by :mod:`work_engine.hooks.settings`).
-
-The hook is purely observational — it never mutates ``DeliveryState``,
-never raises terminal errors. Stream / disk failures surface as
-:class:`HookError` (non-fatal per the three-tier contract).
-
-Trace layout (matches the contract):
-
-* ``schema_version: 1``
-* ``work_id`` — derived from the state-file directory name when the
-  caller follows the ``agents/runtime/state/work/<id>/state.json`` convention,
-  else from the state-file stem.
-* ``phase`` — engine ``step_name`` (refine/memory/.../report).
-* ``started_at`` / ``ended_at`` — ISO-8601 UTC timestamps captured on
-  ``BEFORE_STEP`` and ``AFTER_STEP``.
-* ``confidence_band`` / ``risk_class`` — heuristics defined in
-  :mod:`work_engine.scoring.decision_trace`.
-* ``rules`` — empty by default; the engine layer populates rule
-  applications when concerns wire into the trace bus (later phase).
-* ``memory`` — counts and ids snapshotted from ``state.memory``.
-* ``verify`` — claims/first-try-passes derived from ``state.verify``.
-"""
-from __future__ import annotations
-
-import json
-import time
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-from ...scoring.decision_trace import (
-    derive_confidence_band,
-    derive_risk_class,
-    summarise_memory,
-    summarise_verify,
-)
-from ..context import HookContext
-from ..events import HookEvent
-from ..exceptions import HookError
-from ..registry import HookRegistry
-
-SCHEMA_VERSION = 1
-_MAX_MEMORY_IDS = 32
-
-
-class DecisionTraceHook:
-    """Emit one decision-trace JSON file per dispatcher step.
-
-    Parameters
-    ----------
-    output_dir:
-        Optional override for the trace destination. When ``None`` the
-        hook writes alongside the WorkState file: if the state file
-        sits under ``agents/runtime/state/work/<id>/state.json`` the trace
-        lands at ``agents/runtime/state/work/<id>/decision-trace-<phase>.json``;
-        otherwise the trace lands next to the state file as
-        ``<stem>.decision-trace-<phase>.json``.
-    """
-
-    def __init__(self, output_dir: Path | None = None) -> None:
-        self._output_dir = output_dir
-        self._state_file: Path | None = None
-        self._step_started: dict[str, float] = {}
-
-    def register(self, registry: HookRegistry) -> None:
-        """Register the trace callbacks on the lifecycle events used."""
-        registry.register(HookEvent.BEFORE_LOAD, self._capture_state_file)
-        registry.register(HookEvent.AFTER_LOAD, self._capture_state_file)
-        registry.register(HookEvent.BEFORE_STEP, self._mark_step_start)
-        registry.register(HookEvent.AFTER_STEP, self._emit_trace)
-
-    # -- lifecycle callbacks ------------------------------------------
-
-    def _capture_state_file(self, ctx: HookContext) -> None:
-        if ctx.state_file is not None:
-            self._state_file = Path(ctx.state_file)
-
-    def _mark_step_start(self, ctx: HookContext) -> None:
-        if ctx.step_name:
-            self._step_started[ctx.step_name] = time.time()
-
-    def _emit_trace(self, ctx: HookContext) -> None:
-        if not ctx.step_name:
-            return
-        started = self._step_started.pop(ctx.step_name, time.time())
-        envelope = self._build_envelope(ctx, started)
-        target = self._target_path(ctx.step_name)
-        try:
-            target.parent.mkdir(parents=True, exist_ok=True)
-            target.write_text(
-                json.dumps(envelope, indent=2, sort_keys=False) + "\n",
-                encoding="utf-8",
-            )
-        except OSError as exc:
-            raise HookError(f"decision-trace write failed: {exc}") from exc
-
-    # -- envelope construction ----------------------------------------
-
-    def _build_envelope(
-        self, ctx: HookContext, started: float,
-    ) -> dict[str, Any]:
-        delivery = ctx.delivery
-        memory = summarise_memory(
-            getattr(delivery, "memory", None),
-            limit=_MAX_MEMORY_IDS,
-        )
-        verify = summarise_verify(getattr(delivery, "verify", None))
-        ambiguity = bool(getattr(delivery, "questions", None))
-        return {
-            "schema_version": SCHEMA_VERSION,
-            "work_id": self._work_id(),
-            "phase": ctx.step_name,
-            "started_at": _iso_utc(started),
-            "ended_at": _iso_utc(time.time()),
-            "confidence_band": derive_confidence_band(
-                memory_hits=memory["hits"],
-                verify_claims=verify["claims"],
-                verify_first_try_passes=verify["first_try_passes"],
-                ambiguity_flag=ambiguity,
-            ),
-            "risk_class": derive_risk_class(
-                getattr(delivery, "changes", None),
-            ),
-            "rules": [],
-            "memory": memory,
-            "verify": verify,
-        }
-
-    # -- path helpers --------------------------------------------------
-
-    def _work_id(self) -> str:
-        if self._state_file is None:
-            return "unknown"
-        parent = self._state_file.parent
-        if parent.name and parent.parent.name == "work":
-            return parent.name
-        return self._state_file.stem
-
-    def _target_path(self, phase: str) -> Path:
-        filename = f"decision-trace-{phase}.json"
-        if self._output_dir is not None:
-            return self._output_dir / filename
-        if self._state_file is None:
-            return Path(filename)
-        parent = self._state_file.parent
-        if parent.name and parent.parent.name == "work":
-            return parent / filename
-        return parent / f"{self._state_file.stem}.{filename}"
-
-
-def _iso_utc(epoch: float) -> str:
-    return (
-        datetime.fromtimestamp(epoch, tz=timezone.utc)
-        .strftime("%Y-%m-%dT%H:%M:%SZ")
-    )
-
-
-__all__ = ["DecisionTraceHook", "SCHEMA_VERSION"]

package/dist/agent-src/templates/scripts/work_engine/hooks/builtin/directive_set_guard.py

@@ -1,53 +0,0 @@
-"""``DirectiveSetGuardHook`` — catch CLI / state directive-set drift.
-
-Fires on :data:`HookEvent.BEFORE_DISPATCH`. Compares the resolved
-``set_name`` (the directive bundle the CLI just loaded) against the
-``directive_set`` field on the persisted ``WorkState``. Mismatch →
-:class:`HookError` (non-fatal: the runner warns), so a flow that
-silently re-dispatches under a different set surfaces the drift before
-any step runs.
-
-The guard is read-only. It does not rewrite ``state.directive_set``;
-fixing the drift is the user's call (typically a ``/mode`` switch or a
-fresh state file).
-"""
-from __future__ import annotations
-
-from ..context import HookContext
-from ..events import HookEvent
-from ..exceptions import HookError
-from ..registry import HookRegistry
-
-
-class DirectiveSetGuardHook:
-    """Asserts ``set_name`` matches ``state.directive_set`` on dispatch."""
-
-    def register(self, registry: HookRegistry) -> None:
-        """Register on :data:`HookEvent.BEFORE_DISPATCH`."""
-        registry.register(HookEvent.BEFORE_DISPATCH, self._guard)
-
-    def _guard(self, ctx: HookContext) -> None:
-        set_name = ctx.set_name
-        work = ctx.work
-        if set_name is None or work is None:
-            # ``before_dispatch`` always carries both refs per the
-            # context surface; missing means a hook-bug, not drift.
-            raise HookError(
-                "directive-set guard: missing set_name or work on "
-                f"before_dispatch (set_name={set_name!r}, work={work!r})",
-            )
-
-        persisted = getattr(work, "directive_set", None)
-        if persisted is None:
-            # Legacy v0 envelopes have no ``directive_set`` field;
-            # the guard is a no-op for those — nothing to compare.
-            return
-
-        if persisted != set_name:
-            raise HookError(
-                "directive-set drift: CLI resolved "
-                f"{set_name!r} but state carries {persisted!r}",
-            )
-
-
-__all__ = ["DirectiveSetGuardHook"]

package/dist/agent-src/templates/scripts/work_engine/hooks/builtin/halt_surface_audit.py

@@ -1,50 +0,0 @@
-"""``HaltSurfaceAuditHook`` — defense-in-depth around halt surfaces.
-
-The dispatcher already calls ``_validate_step_result`` to reject a
-``BLOCKED`` / ``PARTIAL`` outcome with no questions. This hook fires on
-``on_halt`` and re-asserts the same invariant from the hook side, so a
-hand-crafted handler that bypasses the validator (e.g. a future direct
-``state.questions`` mutation) still surfaces a clear failure.
-
-Pure observability: emits :class:`HookError` (non-fatal) when the
-surface is empty. The runner converts it to a ``warnings.warn`` so the
-violation is visible in test logs and CI.
-"""
-from __future__ import annotations
-
-from ..context import HookContext
-from ..events import HookEvent
-from ..exceptions import HookError
-from ..registry import HookRegistry
-
-
-class HaltSurfaceAuditHook:
-    """Asserts that every halt carries a non-empty user-facing surface."""
-
-    def register(self, registry: HookRegistry) -> None:
-        """Register on :data:`HookEvent.ON_HALT` only."""
-        registry.register(HookEvent.ON_HALT, self._audit)
-
-    def _audit(self, ctx: HookContext) -> None:
-        result = ctx.result
-        if result is None:
-            # Hook-driven halts go through ``_hook_halt_blocked`` and
-            # may not carry a ``StepResult`` — the surface lives on
-            # ``state.questions`` instead. Audit that fallback too.
-            questions = getattr(ctx.delivery, "questions", None)
-            if not questions:
-                raise HookError(
-                    f"halt at step {ctx.step_name!r} surfaced no questions "
-                    "(hook-driven halt with empty state.questions)",
-                )
-            return
-
-        questions = getattr(result, "questions", None)
-        if not questions:
-            raise HookError(
-                f"halt at step {ctx.step_name!r} surfaced no questions "
-                "(StepResult.questions empty); the user has nothing to act on",
-            )
-
-
-__all__ = ["HaltSurfaceAuditHook"]

package/dist/agent-src/templates/scripts/work_engine/hooks/builtin/memory_visibility.py

@@ -1,141 +0,0 @@
-"""``MemoryVisibilityHook`` — emit the visibility line on save.
-
-Implements the producer side of
-``docs/contracts/memory-visibility-v1.md``: derive ``asks/hits/ids``
-from ``state.memory`` and thread the rendered line into
-``state.report`` so the agent's reply naturally carries the memory
-visibility marker.
-
-Fires on ``before_save``: ``cli._sync_back`` runs between
-``after_dispatch`` and ``before_save`` and reassigns
-``work.report = delivery.report``. A line written on
-``after_dispatch`` would be overwritten before ``_save``; firing on
-``before_save`` lands after the sync.
-
-Default-off; opt-in via ``.agent-settings.yml``
-``hooks.memory_visibility.enabled: true`` (or implicitly when
-``memory.visibility`` is not ``off`` and the master switch is on).
-The hook is purely observational: failures surface as
-:class:`HookError` (non-fatal per the three-tier contract); the
-engine never crashes on a visibility-line write.
-"""
-from __future__ import annotations
-
-from typing import Any, Iterable
-
-from ...scoring.decision_trace import summarise_memory, summarise_verify
-from ...scoring.memory_visibility import (
-    DEFAULT_ASKED_TYPES,
-    compute_affected,
-    format_changed_decisions_block,
-    format_line,
-    should_emit,
-    summarise_visibility,
-)
-from ..context import HookContext
-from ..events import HookEvent
-from ..exceptions import HookError
-from ..registry import HookRegistry
-
-
-class MemoryVisibilityHook:
-    """Thread the ``🧠 Memory: <hits>/<asks> · ids=[…]`` line into the report.
-
-    Parameters
-    ----------
-    memory_cadence:
-        Cadence from ``memory.cadence`` in ``.agent-settings.yml``
-        (``auto`` / ``always`` / ``never``). ``auto`` suppresses the
-        line unless ``asks ≥ 3``; ``never`` suppresses it entirely;
-        ``always`` (default) emits whenever ``asks ≥ 1`` per the
-        contract's cadence table.
-    visibility_off:
-        When ``True``, the hook stays silent — used to mirror
-        ``memory.visibility: off`` in the consumer settings.
-    asked_types:
-        Optional override for the list of memory types treated as
-        ``asks`` in the visibility line. Defaults to the four types
-        the engine's memory step retrieves over.
-    """
-
-    def __init__(
-        self,
-        *,
-        memory_cadence: str = "always",
-        visibility_off: bool = False,
-        asked_types: Iterable[str] | None = None,
-    ) -> None:
-        self._memory_cadence = memory_cadence
-        self._visibility_off = visibility_off
-        self._asked_types = (
-            tuple(asked_types) if asked_types is not None else DEFAULT_ASKED_TYPES
-        )
-
-    def register(self, registry: HookRegistry) -> None:
-        """Register the visibility-line emitter on ``before_save``."""
-        registry.register(HookEvent.BEFORE_SAVE, self._on_before_save)
-
-    def _on_before_save(self, ctx: HookContext) -> None:
-        work = ctx.work
-        if work is None:
-            return
-        memory = getattr(work, "memory", None)
-        summary = summarise_visibility(memory, asked_types=self._asked_types)
-        if not should_emit(
-            summary,
-            memory_cadence=self._memory_cadence,
-            visibility_off=self._visibility_off,
-        ):
-            return
-        affected = self._derive_affected(work, memory)
-        line = format_line(summary, affected=affected)
-        if not line:
-            return
-        block = format_changed_decisions_block(
-            summary.get("ids") or [], affected,
-        )
-        existing = getattr(work, "report", "") or ""
-        rendered = line if block is None else f"{line}\n\n{block}"
-        if line in existing and (block is None or block in existing):
-            return
-        sep = "\n\n" if existing else ""
-        try:
-            work.report = f"{existing}{sep}{rendered}"
-        except AttributeError as exc:
-            raise HookError(
-                "memory-visibility: state.report not writable",
-            ) from exc
-
-    def _derive_affected(self, work: Any, memory: Any) -> list[str] | None:
-        """Compute the closed-list ``affected`` keys for this work step.
-
-        Reuses the decision-trace summarisers so the counterfactual
-        matches the trace hook's view of the same WorkState. Returns
-        ``None`` when memory was not consulted (hits == 0); callers
-        then omit the ``· affected: …`` segment per the contract.
-        """
-        memory_summary = summarise_memory(memory)
-        verify_summary = summarise_verify(getattr(work, "verify", None))
-        ambiguity = bool(getattr(work, "questions", None))
-        return compute_affected(
-            memory_hits=memory_summary["hits"],
-            verify_claims=verify_summary["claims"],
-            verify_first_try_passes=verify_summary["first_try_passes"],
-            ambiguity_flag=ambiguity,
-            changes=getattr(work, "changes", None),
-            applied_rules=getattr(work, "applied_rules", None),
-            test_plan=getattr(work, "test_plan", None),
-        )
-
-
-def derive_visibility(memory: Any) -> str | None:
-    """Convenience helper: render the line directly from a memory list.
-
-    Used by external callers (CLI ad-hoc smoke tests, the audit-as-
-    memory consumer) that have a ``memory`` list but no ``HookContext``.
-    Returns ``None`` when ``asks == 0``.
-    """
-    return format_line(summarise_visibility(memory))
-
-
-__all__ = ["MemoryVisibilityHook", "derive_visibility"]