semora-coding 0.2.0__py3-none-any.whl

semora_coding/skills.py

@@ -0,0 +1,424 @@
+"""Source-neutral skill discovery and progressive disclosure.
+
+Sources list lightweight metadata and load full instructions only when the ``skill`` tool is
+invoked.  Filesystem discovery is one adapter, not a registry responsibility.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import builtins
+import os
+import re
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from html import escape
+from inspect import isawaitable
+from pathlib import Path
+from typing import Any, Protocol, runtime_checkable
+
+from semora.contracts import BaseMessage, DynamicTools, Tools
+
+__all__ = [
+    "DirectorySkillSource",
+    "Skill",
+    "SkillMetadata",
+    "SkillRegistry",
+    "SkillSource",
+    "SkillTools",
+]
+
+_NAME = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:-]*$")
+_DEFAULT_CATALOG_BUDGET = 8_000
+_DESCRIPTION_LIMIT = 250
+
+
+@dataclass(frozen=True, slots=True)
+class SkillMetadata:
+    """The model-visible part of a skill returned by source discovery."""
+
+    name: str
+    description: str
+    revision: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class Skill:
+    """Full instructions loaded on demand from an arbitrary source."""
+
+    name: str
+    description: str
+    body: str
+    origin: str | None = None
+    resource_base: str | None = None
+    allowed_tools: tuple[str, ...] = ()
+    paths: tuple[str, ...] = ()
+
+    def context(self, arguments: str = "") -> str:
+        """Render the full on-demand context injected after the tool result."""
+        body = self.body
+        prefix = ""
+        if self.resource_base is not None:
+            body = body.replace("${SEMORA_SKILL_ROOT}", self.resource_base)
+            body = body.replace("${SEMORA_SKILL_DIR}", self.resource_base)
+            prefix = f"Resource base for this skill: {self.resource_base}\n\n"
+        body = body.replace("${ARGUMENTS}", arguments).replace("$ARGUMENTS", arguments)
+        argument_block = f"\n\nArguments: {arguments}" if arguments else ""
+        return f"{prefix}{body}{argument_block}"
+
+
+@runtime_checkable
+class SkillSource(Protocol):
+    """Metadata-first store for directory, database, API, or package-backed skills."""
+
+    async def list(self) -> Sequence[SkillMetadata]:
+        """List discovery metadata without loading complete skill bodies."""
+        ...
+
+    async def load(self, name: str) -> Skill | None:
+        """Load one exact skill body, or return ``None`` if it disappeared."""
+        ...
+
+
+class DirectorySkillSource:
+    """Read directory-form ``SKILL.md`` files through the generic source contract."""
+
+    def __init__(self, root: str | Path) -> None:
+        """Resolve the root once; source callers remain responsible for user expansion."""
+        self.root = Path(root).resolve()
+        self._locations: dict[str, Path] | None = None
+
+    async def list(self) -> Sequence[SkillMetadata]:
+        """Read frontmatter only; instruction bodies remain unread until ``load``."""
+        metadata, locations = await asyncio.to_thread(self._discover)
+        self._locations = locations
+        return metadata
+
+    async def load(self, name: str) -> Skill | None:
+        """Read and parse one previously discovered skill file."""
+        if self._locations is None:
+            await self.list()
+        assert self._locations is not None
+        path = self._locations.get(name)
+        if path is None:
+            return None
+        try:
+            return await asyncio.to_thread(_parse_skill, path)
+        except (OSError, ValueError):
+            return None
+
+    def _discover(self) -> tuple[tuple[SkillMetadata, ...], dict[str, Path]]:
+        found: dict[str, SkillMetadata] = {}
+        locations: dict[str, Path] = {}
+        if not self.root.is_dir():
+            return (), locations
+        for root, directories, files in os.walk(self.root, followlinks=False):
+            directories[:] = sorted(
+                directory for directory in directories if not (Path(root) / directory).is_symlink()
+            )
+            if "SKILL.md" not in files:
+                continue
+            path = Path(root) / "SKILL.md"
+            if path.is_symlink():
+                continue
+            try:
+                metadata = _read_metadata(path)
+            except (OSError, ValueError):
+                continue
+            found[metadata.name] = metadata
+            locations[metadata.name] = path.resolve()
+        return tuple(found[name] for name in sorted(found)), locations
+
+
+class SkillRegistry:
+    """Merge ordered metadata sources; a later source overrides an earlier one by name."""
+
+    def __init__(
+        self,
+        sources: Sequence[SkillSource | str | Path],
+        *,
+        catalog_char_budget: int = _DEFAULT_CATALOG_BUDGET,
+    ) -> None:
+        """Configure source precedence and the maximum model-visible catalog size."""
+        if catalog_char_budget < 256:
+            raise ValueError("skill catalog budget must be at least 256 characters")
+        self._sources = tuple(_source(source) for source in sources)
+        self._catalog_char_budget = catalog_char_budget
+        self._metadata: dict[str, SkillMetadata] | None = None
+        self._owners: dict[str, SkillSource] = {}
+
+    async def refresh(self) -> tuple[SkillMetadata, ...]:
+        """Refresh metadata from every source without loading any instruction body."""
+        found: dict[str, SkillMetadata] = {}
+        owners: dict[str, SkillSource] = {}
+        for source in self._sources:
+            for metadata in await source.list():
+                _validate_metadata(metadata)
+                found[metadata.name] = metadata
+                owners[metadata.name] = source
+        self._metadata = found
+        self._owners = owners
+        return self.snapshot()
+
+    def clear(self) -> None:
+        """Forget discovery metadata so the next access refreshes every source."""
+        self._metadata = None
+        self._owners = {}
+
+    async def list(self) -> tuple[SkillMetadata, ...]:
+        """Return deterministic discovery metadata, refreshing once when needed."""
+        if self._metadata is None:
+            await self.refresh()
+        return self.snapshot()
+
+    def snapshot(self) -> tuple[SkillMetadata, ...]:
+        """Return already-fetched metadata without performing source I/O."""
+        if self._metadata is None:
+            return ()
+        return tuple(self._metadata[name] for name in sorted(self._metadata))
+
+    async def load(self, name: str) -> Skill | None:
+        """Load a full skill from the source that won metadata precedence."""
+        await self.list()
+        owner = self._owners.get(name)
+        if owner is None:
+            return None
+        skill = await owner.load(name)
+        if skill is None:
+            return None
+        if skill.name != name:
+            raise ValueError(f"skill source returned {skill.name!r} for {name!r}")
+        return skill
+
+    async def catalog(self) -> str:
+        """Fetch metadata and build a bounded discovery-only catalog."""
+        await self.list()
+        return self.catalog_snapshot()
+
+    def catalog_snapshot(self) -> str:
+        """Build a catalog from fetched metadata without source I/O."""
+        skills = self.snapshot()
+        if not skills:
+            return ""
+        head = "<available_skills>\n"
+        tail = "\n</available_skills>"
+        entries = [
+            f"  - {escape(skill.name)}: {escape(skill.description[:_DESCRIPTION_LIMIT])}"
+            for skill in skills
+        ]
+        full = head + "\n".join(entries) + tail
+        if len(full) <= self._catalog_char_budget:
+            return full
+
+        names = [f"  - {escape(skill.name)}" for skill in skills]
+        kept: list[str] = []
+        for entry in names:
+            remaining = len(skills) - len(kept) - 1
+            suffix = f"\n  ... {remaining} more" if remaining > 0 else ""
+            candidate = head + "\n".join([*kept, entry]) + suffix + tail
+            if len(candidate) > self._catalog_char_budget:
+                break
+            kept.append(entry)
+        omitted = len(skills) - len(kept)
+        suffix = f"\n  ... {omitted} more" if omitted else ""
+        return head + "\n".join(kept) + suffix + tail
+
+class SkillTools:
+    """Add an on-demand ``skill`` tool to another tool collection."""
+
+    def __init__(self, inner: Tools, registry: SkillRegistry) -> None:
+        """Compose the registry over an existing tool collection."""
+        if any(definition.get("name") == "skill" for definition in inner.list()):
+            raise ValueError("the wrapped tool collection already defines 'skill'")
+        self._inner = inner
+        self._registry = registry
+
+    async def execute(self, name: str, call_id: str, arguments: Any) -> dict[str, Any]:
+        """Load a skill or delegate an ordinary tool call."""
+        if name != "skill":
+            return await self._inner.execute(name, call_id, arguments)
+        if not isinstance(arguments, Mapping) or not isinstance(arguments.get("skill"), str):
+            return {"type": "error", "message": "skill requires a string 'skill' argument"}
+        skill_name = str(arguments["skill"]).removeprefix("/").strip()
+        skill = await self._registry.load(skill_name)
+        if skill is None:
+            return {"type": "error", "message": f"unknown skill: {skill_name}"}
+        raw_args = arguments.get("args", "")
+        if not isinstance(raw_args, str):
+            return {"type": "error", "message": "skill 'args' must be a string"}
+        metadata: dict[str, Any] = {
+            "kind": "skill",
+            "name": skill.name,
+            "allowed_tools": list(skill.allowed_tools),
+        }
+        if skill.origin is not None:
+            metadata["origin"] = skill.origin
+        return {
+            "type": "text",
+            "text": f"Loaded skill {skill.name}.",
+            "context_messages": [
+                {
+                    "content": skill.context(raw_args),
+                    "metadata": metadata,
+                }
+            ],
+        }
+
+    def get(self, name: str) -> dict[str, Any] | None:
+        """Return one currently available tool definition."""
+        if name == "skill":
+            return self._definition()
+        return self._inner.get(name)
+
+    def list(self) -> list[dict[str, Any]]:
+        """Expose ordinary tools plus the fetched skill discovery schema."""
+        return [*self._inner.list(), self._definition()]
+
+    async def prepare(self, messages: builtins.list[BaseMessage]) -> None:
+        """Fetch skill metadata and forward dynamic exposure reconstruction."""
+        await self._registry.list()
+        if isinstance(self._inner, DynamicTools):
+            prepared = self._inner.prepare(messages)
+            if isawaitable(prepared):
+                await prepared
+
+    def get_context(self) -> Any:
+        """Forward the workspace context when the wrapped collection supports it."""
+        get_context = getattr(self._inner, "get_context", None)
+        if get_context is None:
+            raise TypeError("wrapped tools do not expose a workspace context")
+        return get_context()
+
+    def with_context(self, context: Any) -> SkillTools:
+        """Rebind the wrapped collection without rebuilding the skill registry."""
+        with_context = getattr(self._inner, "with_context", None)
+        if with_context is None:
+            raise TypeError("wrapped tools cannot be rebound to a workspace context")
+        return SkillTools(with_context(context), self._registry)
+
+    def _definition(self) -> dict[str, Any]:
+        catalog = self._registry.catalog_snapshot()
+        return {
+            "name": "skill",
+            "description": (
+                "Load a matching skill before doing the task. The tool injects the full "
+                "instructions into the next model round; do not guess unlisted names.\n\n"
+                f"{catalog}"
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "skill": {"type": "string", "description": "Exact skill name"},
+                    "args": {"type": "string", "description": "Optional skill arguments"},
+                },
+                "required": ["skill"],
+                "additionalProperties": False,
+            },
+            "is_exclusive": True,
+        }
+
+
+def _source(source: SkillSource | str | Path) -> SkillSource:
+    if isinstance(source, str | Path):
+        return DirectorySkillSource(source)
+    return source
+
+
+def _validate_metadata(metadata: SkillMetadata) -> None:
+    if not _NAME.fullmatch(metadata.name):
+        raise ValueError(f"invalid skill name: {metadata.name!r}")
+
+
+def _read_metadata(path: Path) -> SkillMetadata:
+    lines: list[str] = []
+    with path.open(encoding="utf-8") as stream:
+        first = stream.readline()
+        if first.strip() != "---":
+            raise ValueError("SKILL.md has no YAML frontmatter")
+        for line in stream:
+            if line.strip() == "---":
+                break
+            lines.append(line.rstrip("\n"))
+        else:
+            raise ValueError("SKILL.md frontmatter is not closed")
+    frontmatter = _frontmatter_values(lines)
+    name = str(frontmatter.get("name") or path.parent.name).strip()
+    if not _NAME.fullmatch(name):
+        raise ValueError(f"invalid skill name: {name!r}")
+    return SkillMetadata(
+        name=name,
+        description=str(frontmatter.get("description") or "").strip(),
+        revision=str(path.stat().st_mtime_ns),
+    )
+
+
+def _parse_skill(path: Path) -> Skill:
+    content = path.read_text(encoding="utf-8")
+    frontmatter, body = _frontmatter(content)
+    name = str(frontmatter.get("name") or path.parent.name).strip()
+    if not _NAME.fullmatch(name):
+        raise ValueError(f"invalid skill name: {name!r}")
+    description = str(frontmatter.get("description") or "").strip()
+    return Skill(
+        name=name,
+        description=description,
+        body=body.strip(),
+        origin=path.resolve().as_uri(),
+        resource_base=str(path.resolve().parent),
+        allowed_tools=_string_tuple(frontmatter.get("allowed-tools")),
+        paths=_string_tuple(frontmatter.get("paths")),
+    )
+
+
+def _frontmatter(content: str) -> tuple[dict[str, Any], str]:
+    lines = content.splitlines()
+    if not lines or lines[0].strip() != "---":
+        raise ValueError("SKILL.md has no YAML frontmatter")
+    try:
+        end = next(index for index, line in enumerate(lines[1:], 1) if line.strip() == "---")
+    except StopIteration as error:
+        raise ValueError("SKILL.md frontmatter is not closed") from error
+    return _frontmatter_values(lines[1:end]), "\n".join(lines[end + 1 :])
+
+
+def _frontmatter_values(lines: Sequence[str]) -> dict[str, Any]:
+    values: dict[str, Any] = {}
+    current_list: str | None = None
+    for line in lines:
+        stripped = line.strip()
+        if current_list is not None and stripped.startswith("- "):
+            value = values[current_list]
+            assert isinstance(value, list)
+            value.append(_scalar(stripped[2:]))
+            continue
+        if ":" not in line:
+            current_list = None
+            continue
+        key, raw = line.split(":", 1)
+        key = key.strip()
+        raw = raw.strip()
+        if not raw:
+            values[key] = []
+            current_list = key
+            continue
+        current_list = None
+        values[key] = _scalar(raw)
+    return values
+
+
+def _scalar(value: str) -> Any:
+    value = value.strip().strip("\"'")
+    if value.startswith("[") and value.endswith("]"):
+        inner = value[1:-1].strip()
+        return [] if not inner else [_scalar(item) for item in inner.split(",")]
+    if value == "true":
+        return True
+    if value == "false":
+        return False
+    return value
+
+
+def _string_tuple(value: Any) -> tuple[str, ...]:
+    if not isinstance(value, list):
+        return ()
+    return tuple(str(item) for item in value)

semora_coding/tool_search.py

@@ -0,0 +1,224 @@
+"""Provider-neutral deferred tool exposure.
+
+The model initially receives complete schemas only for ordinary tools and ``tool_search``. Deferred
+tools are announced by name in that tool's description; selecting/searching one records a compact
+activation marker in the transcript, from which a fresh wrapper can reconstruct the active set.
+"""
+
+from __future__ import annotations
+
+import builtins
+import json
+import re
+from collections.abc import Mapping
+from inspect import isawaitable
+from typing import Any
+
+from langchain_core.messages import BaseMessage, ToolMessage
+from semora.contracts import DynamicTools, Tools
+
+__all__ = ["DeferredTools"]
+
+_TOOL_NAME = "tool_search"
+_ACTIVATED = re.compile(r"<activated_tools>(.*?)</activated_tools>", re.DOTALL)
+
+
+class DeferredTools:
+    """Hide selected tool schemas until ``tool_search`` activates them."""
+
+    def __init__(
+        self,
+        inner: Tools,
+        *,
+        deferred: set[str] | None = None,
+        initially_active: set[str] | None = None,
+        _discovered: set[str] | None = None,
+    ) -> None:
+        """Configure explicit deferrals and session-local activation state."""
+        if any(definition.get("name") == _TOOL_NAME for definition in inner.list()):
+            raise ValueError(f"the wrapped tool collection already defines {_TOOL_NAME!r}")
+        self._inner = inner
+        self._explicit = frozenset(deferred or ())
+        self._initially_active = frozenset(initially_active or ())
+        self._discovered = _discovered if _discovered is not None else set()
+
+    async def execute(self, name: str, call_id: str, arguments: Any) -> dict[str, Any]:
+        """Search for a schema or execute an already exposed tool."""
+        if name == _TOOL_NAME:
+            return self._search(arguments)
+        definition = self._definition(name)
+        if definition is None:
+            return {"type": "error", "message": f"tool is not available: {name}"}
+        if self._is_deferred(definition) and name not in self._active_names():
+            return {
+                "type": "error",
+                "message": f"tool {name!r} is deferred; load it with {_TOOL_NAME} first",
+            }
+        return await self._inner.execute(name, call_id, arguments)
+
+    def get(self, name: str) -> dict[str, Any] | None:
+        """Return a definition only when the model is allowed to call it."""
+        if name == _TOOL_NAME:
+            return self._search_definition() if self._deferred_definitions() else None
+        definition = self._definition(name)
+        if definition is None:
+            return None
+        if self._is_deferred(definition) and name not in self._active_names():
+            return None
+        return definition
+
+    def list(self) -> builtins.list[dict[str, Any]]:
+        """List non-deferred and previously discovered schemas."""
+        active = self._active_names()
+        definitions = [
+            definition
+            for definition in self._inner.list()
+            if not self._is_deferred(definition) or str(definition.get("name")) in active
+        ]
+        if self._deferred_definitions():
+            definitions.append(self._search_definition())
+        return definitions
+
+    async def prepare(self, messages: builtins.list[BaseMessage]) -> None:
+        """Recover activated names from durable tool results in the transcript."""
+        if isinstance(self._inner, DynamicTools):
+            prepared = self._inner.prepare(messages)
+            if isawaitable(prepared):
+                await prepared
+        available = {str(definition.get("name")) for definition in self._inner.list()}
+        for message in messages:
+            if not isinstance(message, ToolMessage) or not isinstance(message.content, str):
+                continue
+            for match in _ACTIVATED.finditer(message.content):
+                try:
+                    names = json.loads(match.group(1))
+                except json.JSONDecodeError:
+                    continue
+                if isinstance(names, list):
+                    self._discovered.update(
+                        name for name in names if isinstance(name, str) and name in available
+                    )
+
+    def reset(self) -> None:
+        """Clear session-local discoveries while retaining explicit initial tools."""
+        self._discovered.clear()
+
+    def get_context(self) -> Any:
+        """Forward the workspace context when the wrapped collection supports it."""
+        get_context = getattr(self._inner, "get_context", None)
+        if get_context is None:
+            raise TypeError("wrapped tools do not expose a workspace context")
+        return get_context()
+
+    def with_context(self, context: Any) -> DeferredTools:
+        """Rebind the wrapped tools and retain this conversation's discoveries."""
+        with_context = getattr(self._inner, "with_context", None)
+        if with_context is None:
+            raise TypeError("wrapped tools cannot be rebound to a workspace context")
+        return DeferredTools(
+            with_context(context),
+            deferred=set(self._explicit),
+            initially_active=set(self._initially_active),
+            _discovered=self._discovered,
+        )
+
+    def _search(self, arguments: Any) -> dict[str, Any]:
+        if not isinstance(arguments, Mapping) or not isinstance(arguments.get("query"), str):
+            return {"type": "error", "message": "tool_search requires a string 'query'"}
+        query = str(arguments["query"]).strip()
+        raw_limit = arguments.get("max_results", 5)
+        if not isinstance(raw_limit, int) or isinstance(raw_limit, bool):
+            return {"type": "error", "message": "tool_search 'max_results' must be an integer"}
+        maximum = min(max(raw_limit, 1), 20)
+        matches = self._matches(query, maximum)
+        self._discovered.update(matches)
+        encoded = json.dumps(matches, separators=(",", ":"), ensure_ascii=False)
+        visible = (
+            "Activated deferred tools:\n" + "\n".join(f"- {name}" for name in matches)
+            if matches
+            else "No matching deferred tools found."
+        )
+        return {"type": "text", "text": f"{visible}\n<activated_tools>{encoded}</activated_tools>"}
+
+    def _matches(self, query: str, maximum: int) -> builtins.list[str]:
+        definitions = self._deferred_definitions()
+        by_name = {str(definition.get("name")): definition for definition in definitions}
+        if query.lower().startswith("select:"):
+            requested = [item.strip() for item in query[7:].split(",") if item.strip()]
+            lowered = {name.lower(): name for name in by_name}
+            selected = dict.fromkeys(
+                lowered[item.lower()] for item in requested if item.lower() in lowered
+            )
+            return list(selected)[:maximum]
+
+        terms = [term.lower() for term in query.split() if term]
+        required = [term[1:] for term in terms if term.startswith("+") and len(term) > 1]
+        optional = [term for term in terms if not term.startswith("+")]
+        scored: builtins.list[tuple[int, str]] = []
+        for name, definition in by_name.items():
+            haystack = " ".join(
+                (
+                    name,
+                    str(definition.get("description", "")),
+                    str(definition.get("search_hint", "")),
+                )
+            ).lower()
+            if required and not all(term in haystack for term in required):
+                continue
+            score = sum(
+                10 if term in name.lower() else 2
+                for term in [*required, *optional]
+                if term in haystack
+            )
+            if score:
+                scored.append((score, name))
+        ranked = sorted(scored, key=lambda item: (-item[0], item[1]))[:maximum]
+        return [name for _score, name in ranked]
+
+    def _active_names(self) -> set[str]:
+        return set(self._initially_active) | self._discovered
+
+    def _definition(self, name: str) -> dict[str, Any] | None:
+        return next(
+            (definition for definition in self._inner.list() if definition.get("name") == name),
+            None,
+        )
+
+    def _deferred_definitions(self) -> builtins.list[dict[str, Any]]:
+        return [definition for definition in self._inner.list() if self._is_deferred(definition)]
+
+    def _is_deferred(self, definition: dict[str, Any]) -> bool:
+        if definition.get("always_load") is True:
+            return False
+        name = str(definition.get("name", ""))
+        return bool(
+            name in self._explicit
+            or name.startswith("mcp__")
+            or definition.get("is_mcp") is True
+            or definition.get("should_defer") is True
+            or definition.get("defer_loading") is True
+        )
+
+    def _search_definition(self) -> dict[str, Any]:
+        names = sorted(str(definition.get("name")) for definition in self._deferred_definitions())
+        return {
+            "name": _TOOL_NAME,
+            "description": (
+                "Load complete schemas for deferred tools. Until selected, only these names are "
+                "known and the tools cannot be called. Use 'select:<name>' for exact selection "
+                "or capability keywords to search.\n\n<available_deferred_tools>\n"
+                + "\n".join(names)
+                + "\n</available_deferred_tools>"
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string"},
+                    "max_results": {"type": "integer", "minimum": 1, "maximum": 20},
+                },
+                "required": ["query"],
+                "additionalProperties": False,
+            },
+            "is_exclusive": True,
+            "is_concurrency_safe": True,
+        }

semora_coding-0.2.0.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.5
+Name: semora-coding
+Version: 0.2.0
+Summary: A coding agent's toolset, prompts and policies, assembled over the semora core.
+Project-URL: Homepage, https://github.com/donggyun112/semora
+Project-URL: Source, https://github.com/donggyun112/semora
+Project-URL: Changelog, https://github.com/donggyun112/semora/blob/main/CHANGELOG.md
+Author: donggyun112
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: langchain-core<2,>=1
+Requires-Dist: semora==0.2.0
+Description-Content-Type: text/markdown
+
+# semora-coding
+
+The coding-agent layer over the `semora` core: built-in tools (`read`, `write`, `edit`, `grep`,
+`glob`, `Bash`, `web_fetch`), system-prompt assembly, plan mode, goals, the skill catalog and
+deferred tool search.
+
+```
+uv add "semora[coding]"
+```
+
+It is a reference assembly. The core promises that a tool's effect happens once and that every
+decision about it has a seam; this package is one answer to what those tools and seams say to a
+model. Replace any of it — the core does not know it is here.