aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/packs/logistics/__init__.py

@@ -0,0 +1,171 @@
+"""Logistics — waybills, containers, carriers.
+
+What makes this pack safe to have switched on is that every identifier it
+recognises is *verifiable*, not merely shaped right.  A bare run of twelve
+digits appears in invoices, timestamps, phone numbers and order IDs; a
+container number carries a check digit that can be recomputed, and a UPS or SF
+tracking number carries a prefix that nothing else uses.
+
+So the resolver reports both kinds and scores them differently: verified
+identifiers activate the pack, shape-only matches are reported below the
+activation threshold so the CLI can offer "did you mean this waybill?" without
+answering a code question with a shipment lookup on its own initiative.  That
+asymmetry is the contract's rule applied to a domain whose identifiers are
+almost all digits.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Sequence
+
+from aria_code.packs.base import BaseDomainPack, EntityMatch, PackActivation
+
+PACK_NAME = "logistics"
+
+LOGISTICS_TOOLS = (
+    "analyze_logistics_data",
+    "plan_inventory_policy",
+    "score_carriers",
+)
+
+_VERIFIED = 0.95
+_SHAPE_ONLY = 0.3
+
+# Carrier prefixes that no other identifier uses.
+_CARRIER_PATTERNS: tuple[tuple[str, re.Pattern], ...] = (
+    # UPS: 1Z + 6-char shipper + 2-char service + 8-digit sequence.
+    ("ups", re.compile(r"\b(1Z[0-9A-Z]{16})\b", re.I)),
+    # SF Express domestic waybill.
+    ("sf", re.compile(r"\b(SF\d{12,15})\b", re.I)),
+    # DHL express, 'JD' + 20 digits (also used on some waybill labels).
+    ("dhl", re.compile(r"\b(JD\d{18,20})\b")),
+)
+
+# ISO 6346 container: 4 letters (owner + category) + 6 digits + check digit.
+_CONTAINER = re.compile(r"\b([A-Z]{4}\d{7})\b")
+
+# Bare numeric runs — the shape most domestic waybills take, and also the shape
+# of an order id, an invoice number and a unix timestamp in milliseconds.
+_BARE_DIGITS = re.compile(r"(?<!\d)(\d{10,15})(?!\d)")
+
+# ISO 6346 letter values: A=10, then ascending, skipping every multiple of 11.
+def _iso6346_letter_values() -> dict[str, int]:
+    values: dict[str, int] = {}
+    value = 10
+    for index in range(26):
+        while value % 11 == 0:
+            value += 1
+        values[chr(ord("A") + index)] = value
+        value += 1
+    return values
+
+
+_LETTER_VALUES = _iso6346_letter_values()
+
+
+def is_valid_container(code: str) -> bool:
+    """True when *code* satisfies the ISO 6346 check digit.
+
+    This is what separates a container number from four capitals followed by
+    seven digits, which is also the shape of plenty of part numbers and
+    internal SKUs. Recomputing the check digit turns a guess into a
+    resolution — the distinction the pack contract is built on.
+    """
+    text = (code or "").strip().upper()
+    if len(text) != 11 or not text[:4].isalpha() or not text[4:].isdigit():
+        return False
+    total = 0
+    for position, char in enumerate(text[:10]):
+        value = _LETTER_VALUES[char] if char.isalpha() else int(char)
+        total += value * (2 ** position)
+    return (total % 11) % 10 == int(text[10])
+
+
+class LogisticsPack(BaseDomainPack):
+    """Recognises shipment identifiers and owns the freight workflows."""
+
+    name = PACK_NAME
+
+    def resolve_entities(self, message: str) -> Sequence[EntityMatch]:
+        text = message or ""
+        if not text.strip():
+            return ()
+
+        seen: set[str] = set()
+        claimed: list[tuple[int, int]] = []
+        entities: list[EntityMatch] = []
+
+        def _add(value: str, kind: str, surface: str, span: tuple[int, int], confidence: float) -> None:
+            if value in seen:
+                return
+            seen.add(value)
+            claimed.append(span)
+            entities.append(EntityMatch(
+                pack=PACK_NAME, kind=kind, value=value,
+                surface=surface, position=span[0], confidence=confidence,
+            ))
+
+        for carrier, pattern in _CARRIER_PATTERNS:
+            for match in pattern.finditer(text):
+                _add(match.group(1).upper(), f"waybill:{carrier}",
+                     match.group(1), match.span(1), _VERIFIED)
+
+        for match in _CONTAINER.finditer(text):
+            code = match.group(1)
+            _add(code, "container", code, match.span(1),
+                 _VERIFIED if is_valid_container(code) else _SHAPE_ONLY)
+
+        # Bare digit runs last, and only outside what a verified identifier
+        # already claimed: the digits inside `1Z999AA10123456784` are not a
+        # second, weaker waybill, and reporting them as one would let the UI
+        # offer a "did you mean" for a number the user never wrote.
+        for match in _BARE_DIGITS.finditer(text):
+            start, end = match.span(1)
+            if any(start >= c_start and end <= c_end for c_start, c_end in claimed):
+                continue
+            _add(match.group(1), "waybill", match.group(1), match.span(1), _SHAPE_ONLY)
+
+        return tuple(entities)
+
+    def tool_names(self) -> Sequence[str]:
+        return LOGISTICS_TOOLS
+
+    def prompt_fragment(self, activation: PackActivation) -> str:
+        kinds = sorted({e.kind for e in activation.entities})
+        ids = ", ".join(sorted({e.value for e in activation.entities}))
+        return (
+            f"物流标识已识别（{', '.join(kinds)}）：{ids}。\n"
+            "用工具取回的运单/箱单数据回答，不要凭记忆编造承运商、时效或费率；"
+            "标注数据来源与时间戳。金额与账期以对账结果为准。"
+        )
+
+    def acceptance_commands(self, activation: PackActivation) -> Sequence[str]:
+        # Looked up through the module rather than a name bound at import, so
+        # what this workspace declares is read when the turn runs — a .ariarc
+        # edited mid-session takes effect on the next message, not the next
+        # process.
+        from aria_code.packs import rules
+
+        return rules.acceptance_commands_for(PACK_NAME)
+
+
+LOGISTICS_PACK = LogisticsPack()
+
+
+def register() -> LogisticsPack:
+    """Register the logistics pack.  Idempotent."""
+    from aria_code.packs.registry import register_pack
+
+    register_pack(LOGISTICS_PACK)
+    return LOGISTICS_PACK
+
+
+__all__ = [
+    "LOGISTICS_PACK",
+    "LOGISTICS_TOOLS",
+    "PACK_NAME",
+    "LogisticsPack",
+    "is_valid_container",
+    "register",
+]

aria_code/packs/payments/__init__.py

@@ -0,0 +1,139 @@
+"""Payments — Stripe objects.
+
+The cleanest case the pack contract has.  Stripe object ids carry a typed
+prefix (``ch_`` charge, ``pi_`` payment intent, ``cus_`` customer, ``sub_``
+subscription…) followed by a long opaque suffix, so recognising one is a
+resolution rather than a guess: nothing else in an English or Chinese sentence
+looks like ``pi_3PqR8s2eZvKYlo2C0aBcDeFg``.
+
+That precision is what lets this pack stay registered permanently at no cost.
+It cannot fire on domain vocabulary — the words "payment", "refund" and
+"订阅" never activate it — so a payments deployment adds nothing to the latency
+or the failure surface of a session about anything else.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Sequence
+
+from aria_code.packs.base import BaseDomainPack, EntityMatch, PackActivation
+
+PACK_NAME = "payments"
+
+PAYMENT_TOOLS = (
+    "analyze_stripe_data",
+)
+
+_RESOLVED = 0.95
+
+# prefix → what the object is. Kept explicit rather than matching a generic
+# `\w+_[A-Za-z0-9]{14,}` because an unknown prefix is far more likely to be
+# someone's own snake_case identifier than a Stripe object.
+_OBJECT_PREFIXES: dict[str, str] = {
+    "ch": "charge",
+    "pi": "payment_intent",
+    "cus": "customer",
+    "sub": "subscription",
+    "in": "invoice",
+    "il": "invoice_item",
+    "price": "price",
+    "prod": "product",
+    "acct": "account",
+    "evt": "event",
+    "re": "refund",
+    "txn": "balance_transaction",
+    "po": "payout",
+    "seti": "setup_intent",
+    "pm": "payment_method",
+    "cs": "checkout_session",
+    "dp": "dispute",
+    "sk": "secret_key",
+    "rk": "restricted_key",
+}
+
+# Stripe ids are prefix + '_' + at least 14 base62 characters, optionally with
+# a `test_` segment in live-vs-test form (`sk_test_…`, `ch_test_…`).
+_OBJECT_ID = re.compile(
+    r"\b(" + "|".join(sorted(_OBJECT_PREFIXES, key=len, reverse=True)) + r")_"
+    r"(?:test_|live_)?([A-Za-z0-9]{14,})\b"
+)
+
+
+class PaymentsPack(BaseDomainPack):
+    """Recognises Stripe object ids and owns the payments workflows."""
+
+    name = PACK_NAME
+
+    def resolve_entities(self, message: str) -> Sequence[EntityMatch]:
+        text = message or ""
+        if "_" not in text:
+            # Every id this pack knows contains an underscore, so this one
+            # check skips the regex entirely for the overwhelming majority of
+            # messages — the resolver runs on every message, for every pack.
+            return ()
+
+        seen: set[str] = set()
+        entities: list[EntityMatch] = []
+        for match in _OBJECT_ID.finditer(text):
+            value = match.group(0)
+            if value in seen:
+                continue
+            seen.add(value)
+            entities.append(EntityMatch(
+                pack=PACK_NAME,
+                kind=_OBJECT_PREFIXES[match.group(1)],
+                value=value,
+                surface=value,
+                position=match.start(),
+                confidence=_RESOLVED,
+            ))
+        return tuple(entities)
+
+    def tool_names(self) -> Sequence[str]:
+        return PAYMENT_TOOLS
+
+    def prompt_fragment(self, activation: PackActivation) -> str:
+        kinds = ", ".join(sorted({e.kind for e in activation.entities}))
+        has_key = any(e.kind.endswith("_key") for e in activation.entities)
+        text = (
+            f"Stripe 对象已识别（{kinds}）。\n"
+            "用工具取回的账务数据回答，不要凭记忆推断金额、状态或结算周期；"
+            "涉及退款、扣款、订阅变更等写操作时，先说明将要发生什么并等待确认。"
+        )
+        if has_key:
+            # The one case where the right move is to stop rather than help.
+            text += (
+                "\n⚠ 消息中疑似包含 Stripe 密钥。不要复述它、不要写入文件、"
+                "不要用它发起请求；提醒用户立即在 Stripe 后台轮换该密钥。"
+            )
+        return text
+
+    def acceptance_commands(self, activation: PackActivation) -> Sequence[str]:
+        # Looked up through the module rather than a name bound at import, so
+        # what this workspace declares is read when the turn runs — a .ariarc
+        # edited mid-session takes effect on the next message, not the next
+        # process.
+        from aria_code.packs import rules
+
+        return rules.acceptance_commands_for(PACK_NAME)
+
+
+PAYMENTS_PACK = PaymentsPack()
+
+
+def register() -> PaymentsPack:
+    """Register the payments pack.  Idempotent."""
+    from aria_code.packs.registry import register_pack
+
+    register_pack(PAYMENTS_PACK)
+    return PAYMENTS_PACK
+
+
+__all__ = [
+    "PACK_NAME",
+    "PAYMENTS_PACK",
+    "PAYMENT_TOOLS",
+    "PaymentsPack",
+    "register",
+]

aria_code/packs/realty/__init__.py

@@ -0,0 +1,190 @@
+"""Real estate — a city's housing market.
+
+This pack is the contract's hard case, and worth reading as one.  Its domain
+has no ``AAPL`` and no ``ch_3Pq…``: the thing a housing question is *about* is
+a city, and a city name on its own is a perfectly ordinary word.  "北京" appears
+in travel plans, in address parsing, in a comment about a datacenter region.
+
+So the entity this pack resolves is not the city.  It is **this city's housing
+market**, which takes two parts to name: a city from a real table, and a
+housing term in the same message.  A city alone resolves at a confidence below
+the activation threshold — reported, so the UI can ask, but never enough to
+answer a code question with a house-price index on its own initiative.
+
+That is the same rule finance applies to a bare uppercase run, arrived at from
+the opposite direction: finance has to *demote* a shape that looks like an
+identifier, and realty has to *combine* two things neither of which is one.
+"""
+
+from __future__ import annotations
+
+from typing import Sequence
+
+from aria_code.packs.base import BaseDomainPack, EntityMatch, PackActivation
+
+PACK_NAME = "realty"
+
+# Empty on purpose. get_house_price_index/get_re_investment exist as functions
+# in realty_data_tools but have no register_* wrapper, so they are not in
+# LOCAL_TOOLS. Naming them here told the model about a capability it does not
+# have, which costs a wasted round and a confusing "unknown tool" error.
+# The pack still contributes its handler and its prompt guidance.
+REALTY_TOOLS: tuple[str, ...] = ()
+
+_RESOLVED = 0.95
+_CITY_ONLY = 0.3
+
+# Terms that name a housing market by themselves, with no city attached.
+# "全国房价走势" is a real question about a real market, and refusing it would
+# lose behaviour the ungated chain used to provide.
+#
+# The line drawn here is narrower than the handler's keyword list on purpose.
+# "房价" and "楼市" name a market; "房产", "地产" and "物业" name a *topic*, and
+# they appear in the source of any property-management codebase — which is
+# exactly the kind of message that must not come back as a price index.
+_NATIONAL_MARKET_TERMS = (
+    "房价", "楼市", "楼价", "二手房", "新房",
+    "house price", "home price", "housing market", "property price",
+)
+
+
+def _tables() -> tuple[tuple[str, ...], tuple[str, ...], tuple[str, ...]]:
+    """City and keyword tables, borrowed rather than duplicated.
+
+    They live in ``market_detect`` because the legacy chain used them; a copy
+    here would drift, and the failure that drift produces (a city Aria stopped
+    recognising after someone edited one list) is silent.
+    """
+    try:
+        from aria_code.apps.cli.utils.market_detect import (
+            _CN_CITIES,
+            _INTL_CITIES,
+            _REALTY_QUERY_KEYWORDS,
+        )
+    except Exception:
+        return (), (), ()
+    return tuple(_CN_CITIES), tuple(_INTL_CITIES), tuple(_REALTY_QUERY_KEYWORDS)
+
+
+class RealtyPack(BaseDomainPack):
+    """Recognises a named city's housing market."""
+
+    name = PACK_NAME
+
+    def resolve_entities(self, message: str) -> Sequence[EntityMatch]:
+        text = message or ""
+        if not text.strip():
+            return ()
+
+        cn_cities, intl_cities, keywords = _tables()
+        if not cn_cities and not intl_cities:
+            return ()
+
+        lowered = text.lower()
+        has_housing_term = any(keyword in lowered for keyword in keywords)
+
+        found: list[tuple[str, int]] = []
+        for city in cn_cities:
+            position = text.find(city)
+            if position >= 0:
+                found.append((city, position))
+        for city in intl_cities:
+            position = lowered.find(city)
+            if position >= 0:
+                found.append((city, position))
+
+        if not found:
+            # No city named, but the message may still name the national
+            # market outright.
+            for term in _NATIONAL_MARKET_TERMS:
+                position = lowered.find(term)
+                if position >= 0:
+                    return (EntityMatch(
+                        pack=PACK_NAME, kind="housing_market", value="全国",
+                        surface=term, position=position, confidence=_RESOLVED,
+                    ),)
+            return ()
+
+        # Earliest mention first, and cap it: a message listing fifteen cities
+        # is a table, not a question about a housing market.
+        found.sort(key=lambda item: item[1])
+        confidence = _RESOLVED if has_housing_term else _CITY_ONLY
+
+        seen: set[str] = set()
+        entities: list[EntityMatch] = []
+        for city, position in found[:6]:
+            if city in seen:
+                continue
+            seen.add(city)
+            entities.append(EntityMatch(
+                pack=PACK_NAME, kind="housing_market", value=city,
+                surface=city, position=position, confidence=confidence,
+            ))
+        return tuple(entities)
+
+    def handlers(self) -> Sequence[object]:
+        """The realty handler, now reachable only when a market is named."""
+        try:
+            from aria_code.apps.cli.handlers.realty_handlers import handle_realty_query
+            from aria_code.apps.cli.utils.market_detect import (
+                _CN_CITIES,
+                _INTL_CITIES,
+                _is_realty_query,
+            )
+        except Exception:
+            return ()
+
+        def _handle(message: str) -> dict:
+            return handle_realty_query(
+                message,
+                is_realty_query=_is_realty_query,
+                cn_cities=_CN_CITIES,
+                intl_cities=_INTL_CITIES,
+            )
+
+        return (_handle,)
+
+    def tool_names(self) -> Sequence[str]:
+        return REALTY_TOOLS
+
+    def prompt_fragment(self, activation: PackActivation) -> str:
+        cities = ", ".join(sorted({e.value for e in activation.entities}))
+        # No tool instruction here: this pack exposes none. The price index is
+        # fetched by the deterministic handler above, so if the model is the one
+        # answering, it has no data source and must say so rather than produce
+        # a plausible number.
+        return (
+            f"房地产市场已识别：{cities}。\n"
+            "你没有房价数据工具。除非上文已给出取回的数据，否则不要给出具体房价、"
+            "涨跌幅或指数值——说明数据不可得，并建议用 /realty 命令获取；"
+            "标注统计口径（新房/二手房、环比/同比）与数据时间；输出不构成投资建议。"
+        )
+
+    def acceptance_commands(self, activation: PackActivation) -> Sequence[str]:
+        # Looked up through the module rather than a name bound at import, so
+        # what this workspace declares is read when the turn runs — a .ariarc
+        # edited mid-session takes effect on the next message, not the next
+        # process.
+        from aria_code.packs import rules
+
+        return rules.acceptance_commands_for(PACK_NAME)
+
+
+REALTY_PACK = RealtyPack()
+
+
+def register() -> RealtyPack:
+    """Register the realty pack.  Idempotent."""
+    from aria_code.packs.registry import register_pack
+
+    register_pack(REALTY_PACK)
+    return REALTY_PACK
+
+
+__all__ = [
+    "PACK_NAME",
+    "REALTY_PACK",
+    "REALTY_TOOLS",
+    "RealtyPack",
+    "register",
+]

aria_code/packs/registry.py

@@ -0,0 +1,202 @@
+"""Domain pack registration and entity-gated activation.
+
+Activation is the whole point of this module.  A pack is switched on for a
+message only when it resolves a concrete entity *from that message*, at or
+above a confidence threshold.  Three consequences follow, each of which fixes a
+failure this codebase actually shipped:
+
+  - **Domain vocabulary cannot activate a pack.**  "根据以上分析和建议开始完善"
+    contains 分析 but names nothing; no pack claims it, so no market handler,
+    no quote, no ticker.
+  - **Conversation history cannot activate a pack.**  Only the user's current
+    message is offered to resolvers.  An assistant reply that mentioned
+    "Cassandra/MongoDB" can no longer donate the ticker MDB to the next turn.
+  - **An inactive pack costs nothing.**  It contributes no handlers, no tools
+    and no prompt text, so adding a clinical or logistics pack does not slow
+    down or perturb a finance user, and vice versa.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Iterable, Sequence
+
+from aria_code.packs.base import (
+    DEFAULT_ACTIVATION_THRESHOLD,
+    DomainPack,
+    EntityMatch,
+    PackActivation,
+)
+
+logger = logging.getLogger(__name__)
+
+_REGISTRY: dict[str, DomainPack] = {}
+
+
+def register_pack(pack: DomainPack) -> None:
+    """Register *pack* under its name, replacing any earlier registration."""
+    name = getattr(pack, "name", "")
+    if not name:
+        raise ValueError("a domain pack must declare a non-empty name")
+    if not hasattr(pack, "resolve_entities"):
+        raise TypeError(f"pack {name!r} does not implement resolve_entities()")
+    _REGISTRY[name] = pack
+
+
+def unregister_pack(name: str) -> None:
+    _REGISTRY.pop(name, None)
+
+
+def registered_packs() -> tuple[DomainPack, ...]:
+    return tuple(_REGISTRY.values())
+
+
+def get_pack(name: str) -> DomainPack | None:
+    return _REGISTRY.get(name)
+
+
+def clear_registry() -> None:
+    """Drop every registration (tests)."""
+    _REGISTRY.clear()
+
+
+def _entities_from(pack: DomainPack, message: str) -> list[EntityMatch]:
+    """Ask one pack what it recognises, never letting it break the request.
+
+    A resolver runs on every message; a pack that raises, or that returns
+    something malformed, must degrade to "recognises nothing" rather than take
+    the CLI down with it.
+    """
+    try:
+        found = pack.resolve_entities(message) or ()
+    except Exception:
+        logger.debug("pack %r failed to resolve entities", getattr(pack, "name", "?"),
+                     exc_info=True)
+        return []
+    out: list[EntityMatch] = []
+    for entity in found:
+        if isinstance(entity, EntityMatch):
+            out.append(entity)
+    return out
+
+
+def activate_packs(
+    message: str,
+    *,
+    packs: Iterable[DomainPack] | None = None,
+    threshold: float = DEFAULT_ACTIVATION_THRESHOLD,
+) -> tuple[PackActivation, ...]:
+    """Return the packs that claim *message*, most confident first.
+
+    Only the current user message is considered.  Callers must not pass
+    conversation history here: inheriting an entity across turns is what
+    produced a stock quote in reply to "根据以上分析和建议开始完善".
+    """
+    if not (message or "").strip():
+        return ()
+
+    candidates = tuple(packs) if packs is not None else registered_packs()
+    activations: list[PackActivation] = []
+    for pack in candidates:
+        entities = [
+            e for e in _entities_from(pack, message) if e.confidence >= threshold
+        ]
+        if entities:
+            activations.append(
+                PackActivation(
+                    pack=getattr(pack, "name", ""),
+                    entities=tuple(entities),
+                )
+            )
+    activations.sort(key=lambda a: -a.confidence)
+    return tuple(activations)
+
+
+def active_handlers(activations: Sequence[PackActivation]) -> tuple[object, ...]:
+    """Deterministic handlers contributed by the active packs, in order."""
+    handlers: list[object] = []
+    for activation in activations:
+        pack = get_pack(activation.pack)
+        if pack is None:
+            continue
+        try:
+            handlers.extend(pack.handlers() or ())
+        except Exception:
+            logger.debug("pack %r failed to provide handlers", activation.pack,
+                         exc_info=True)
+    return tuple(handlers)
+
+
+def active_tool_names(activations: Sequence[PackActivation]) -> tuple[str, ...]:
+    """Tool names to expose to the model for this message."""
+    names: list[str] = []
+    for activation in activations:
+        pack = get_pack(activation.pack)
+        if pack is None:
+            continue
+        try:
+            for name in pack.tool_names() or ():
+                if name and name not in names:
+                    names.append(str(name))
+        except Exception:
+            logger.debug("pack %r failed to provide tool names", activation.pack,
+                         exc_info=True)
+    return tuple(names)
+
+
+def active_prompt_fragments(activations: Sequence[PackActivation]) -> tuple[str, ...]:
+    """Domain guidance to append to the system prompt for this message."""
+    fragments: list[str] = []
+    for activation in activations:
+        pack = get_pack(activation.pack)
+        if pack is None:
+            continue
+        try:
+            fragment = pack.prompt_fragment(activation) or ""
+        except Exception:
+            logger.debug("pack %r failed to provide a prompt fragment", activation.pack,
+                         exc_info=True)
+            continue
+        if fragment.strip():
+            fragments.append(fragment.strip())
+    return tuple(fragments)
+
+
+def active_acceptance_commands(activations: Sequence[PackActivation]) -> tuple[str, ...]:
+    """Verification commands contributed by the active packs, deduplicated.
+
+    Order follows activation confidence, so the pack that most clearly owns
+    the message gets its check run first — and the acceptance gate stops at
+    the first red, which makes that ordering the difference between a useful
+    failure and a confusing one.
+    """
+    commands: list[str] = []
+    for activation in activations:
+        pack = get_pack(activation.pack)
+        if pack is None:
+            continue
+        try:
+            found = pack.acceptance_commands(activation) or ()
+        except Exception:
+            logger.debug("pack %r failed to provide acceptance commands", activation.pack,
+                         exc_info=True)
+            continue
+        for command in found:
+            text = str(command or "").strip()
+            if text and text not in commands:
+                commands.append(text)
+    return tuple(commands)
+
+
+__all__ = [
+    "activate_packs",
+    "active_acceptance_commands",
+    "active_handlers",
+    "active_prompt_fragments",
+    "active_tool_names",
+    "clear_registry",
+    "get_pack",
+    "register_pack",
+    "registered_packs",
+    "unregister_pack",
+]