boost-skill-cli 1.0.415__tar.gz → 1.0.417__tar.gz

{boost_skill_cli-1.0.415 → boost_skill_cli-1.0.417}/MANIFEST.in

@@ -1,8 +1,10 @@
 # Keep source releases lean: the runtime is boost_cli/ (with its bundled
-# data), plus the usual metadata. Everything below is dev-only or generated
-# and should never ship in the sdist.
+# data) plus boost_langchain/ (the LangChain bindings — in the wheel, inert
+# without the [langchain] extra), plus the usual metadata. Everything below
+# is dev-only or generated and should never ship in the sdist.
 include README.md LICENSE pyproject.toml setup.cfg
 recursive-include boost_cli *.py *.json
+recursive-include boost_langchain *.py py.typed
 prune mutants
 prune dist
 prune .idea
@@ -13,6 +15,6 @@ exclude .coverage
 # only; nothing in the shipped runtime touches node.
 exclude package.json package-lock.json
 global-exclude __pycache__ *.pyc *.pyo .DS_Store
-# integrations/ hosts separately-versioned distributions (boost-langchain);
-# boost-skill-cli's own sdist must not ship a nested pyproject.
-prune integrations
+# The package README is repo documentation, not wheel payload — the wheel's
+# long_description is the root README.
+exclude boost_langchain/README.md

{boost_skill_cli-1.0.415 → boost_skill_cli-1.0.417}/Makefile

@@ -52,7 +52,7 @@ mutation:
 	$(PY) scripts/mutation_gate.py --run --min 80
 
 lint:
-	$(VENV)/bin/ruff check boost_cli tests evals
+	$(VENV)/bin/ruff check boost_cli boost_langchain tests evals scripts
 	$(VENV)/bin/mypy
 	$(VENV)/bin/pyright
 	$(VENV)/bin/lint-imports
@@ -60,7 +60,7 @@ lint:
 	$(VENV)/bin/xenon --max-absolute F --max-modules E --max-average B boost_cli
 	$(VENV)/bin/interrogate boost_cli/core
 	$(VENV)/bin/refurb boost_cli
-	$(VENV)/bin/codespell boost_cli docs README.md
+	$(VENV)/bin/codespell boost_cli boost_langchain docs README.md
 	@# actionlint does not lint `run:` blocks itself — it shells out to
 	@# shellcheck, and if shellcheck is not on PATH it skips them silently and
 	@# still exits 0. So `make lint` could report a clean workflow lint having

{boost_skill_cli-1.0.415/boost_skill_cli.egg-info → boost_skill_cli-1.0.417}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.415
+Version: 1.0.417
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -707,6 +707,9 @@ Requires-Dist: ragas<0.3,>=0.2; extra == "eval"
 Requires-Dist: langchain-core<0.4; extra == "eval"
 Requires-Dist: langchain-community<0.4; extra == "eval"
 Requires-Dist: langchain-openai<1; extra == "eval"
+Provides-Extra: langchain
+Requires-Dist: langchain-core<2,>=1; extra == "langchain"
+Requires-Dist: pydantic>=2; extra == "langchain"
 Provides-Extra: bdd
 Requires-Dist: behave>=1.2.6; extra == "bdd"
 Provides-Extra: perf

{boost_skill_cli-1.0.415 → boost_skill_cli-1.0.417}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.415'
-__version_tuple__ = version_tuple = (1, 0, 415)
+__version__ = version = '1.0.417'
+__version_tuple__ = version_tuple = (1, 0, 417)
 
 __commit_id__ = commit_id = None

boost_skill_cli-1.0.417/boost_langchain/__init__.py

@@ -0,0 +1,51 @@
+"""LangChain bindings for boost's skill catalog.
+
+Three seams, all thin on purpose: :class:`BoostRetriever` puts the tapped
+catalog behind LangChain's retriever contract, :class:`SkillMarkdownLoader`
+turns one SKILL.md into a Document, and :func:`skill_context_node` wraps the
+retriever as a LangGraph-shaped node (built on ``langchain_core`` types only,
+so langgraph stays a separate install). Everything that decides *what comes
+back* — ranking, fusion, dedupe, the degrade ladder — stays in
+``boost_cli.core``, where it is measured by the repo's eval gate; this
+package only translates the result into LangChain's types.
+
+This package ships inside the ``boost-skill-cli`` wheel, but its
+dependencies ride the opt-in ``[langchain]`` extra — the default install
+stays zero-dependency, so the module files are always present while
+``langchain_core`` may not be. The guard below turns that mismatch into the
+one actionable message instead of a bare import error pointing at an
+internal module.
+"""
+from ._compat import supported_langchain_core
+
+try:
+    from .graph import skill_context_node
+    from .loader import SkillMarkdownLoader
+    from .retriever import BoostRetriever
+except ModuleNotFoundError as exc:
+    _root = (exc.name or "").partition(".")[0]
+    if _root in ("langchain_core", "pydantic"):
+        raise ModuleNotFoundError(
+            "boost_langchain ships with boost-skill-cli, but its LangChain "
+            "dependencies are opt-in — install the extra: "
+            "pip install 'boost-skill-cli[langchain]'",
+            name=_root,
+        ) from exc
+    raise
+
+# The imports above SUCCEED on langchain-core 0.3 — the [eval] extra's pin —
+# and then fail subtly at runtime (see _compat). Enforce the declared major
+# here, where the failure can name the fix, instead of surfacing later as an
+# AttributeError mid-graph.
+import langchain_core as _langchain_core
+
+if not supported_langchain_core(getattr(_langchain_core, "__version__", "")):
+    raise ImportError(
+        "boost_langchain requires langchain-core>=1,<2 but %s is installed. "
+        "The [eval] extra pins the langchain 0.3 stack, so [eval] and "
+        "[langchain] cannot share an environment until ragas ships its "
+        "langchain-1.x fix — reinstall with: "
+        "pip install 'boost-skill-cli[langchain]'"
+        % getattr(_langchain_core, "__version__", "unknown"))
+
+__all__ = ["BoostRetriever", "SkillMarkdownLoader", "skill_context_node"]

boost_skill_cli-1.0.417/boost_langchain/_compat.py

@@ -0,0 +1,24 @@
+"""Import-time compatibility checks, importable without langchain installed.
+
+Deliberately dependency-free: the package __init__ needs this BEFORE it can
+trust the langchain imports, and the unit suite needs to test the rule from
+the base venv, where importing boost_langchain itself raises the extra hint.
+"""
+from __future__ import annotations
+
+
+def supported_langchain_core(version: str) -> bool:
+    """True when ``version`` satisfies the [langchain] extra's pin (>=1,<2).
+
+    The floor is not pedantry: langchain-core 0.3 — exactly what the [eval]
+    extra pins — satisfies every import this package makes (BaseRetriever,
+    BaseLoader and the message types all exist there) and then fails subtly
+    at runtime, because ``BaseMessage.text`` is a method in 0.3 and a
+    property from 1.0. The cap matters for the same reason in reverse: the
+    BaseRetriever contract moves on majors.
+    """
+    try:
+        major = int(version.partition(".")[0])
+    except ValueError:
+        return False
+    return 1 <= major < 2

boost_skill_cli-1.0.417/boost_langchain/graph.py

@@ -0,0 +1,94 @@
+"""A LangGraph node that pulls the right skill into a run, mid-run.
+
+The alternative this exists to avoid is stuffing every procedure into the
+system prompt up front: that spends context on procedures the run never
+needs and stops scaling the moment the catalog does. Retrieving against the
+current state instead means each turn carries only the procedures that turn
+asked for.
+
+Nothing in this module imports langgraph. A graph node is just a callable
+from state to a partial state update, so building the callable against
+``langchain_core`` types alone keeps langgraph out of the ``[langchain]``
+extra entirely — install it only if your app actually runs graphs — while
+the node still drops straight into ``builder.add_node``.
+"""
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
+
+from .retriever import BoostRetriever
+
+
+def _last_human_text(messages: list[BaseMessage]) -> str:
+    """The most recent human turn — the query the *current* state poses.
+
+    Earlier human turns are already answered context; retrieving on them
+    would re-inject procedures for questions the graph has moved past.
+    ``.text`` rather than ``.content`` because content may be a block list.
+    """
+    for msg in reversed(messages):
+        if isinstance(msg, HumanMessage):
+            return msg.text
+    return ""
+
+
+def skill_context_node(
+    retriever: BoostRetriever | None = None,
+    k: int = 3,
+    kind: str | None = None,
+) -> Callable[[dict], dict]:
+    """Build a graph node that injects relevant boost procedures as context.
+
+    The returned callable reads the last human message from
+    ``state["messages"]``, retrieves up to ``k`` matching catalog items, and
+    returns ``{"messages": [SystemMessage(...)]}`` carrying their full
+    bodies. Three choices worth knowing about:
+
+    - **It degrades to a no-op.** No human turn, nothing tapped, or no match
+      all return ``{}`` — in langgraph, "no state update". A graph wired
+      through this node must keep working on a machine with an empty
+      catalog, because retrieval here is an enhancement, not a dependency.
+    - **Provenance rides along.** Every injected procedure is prefixed with
+      its name, tap, in-repo path and version. Injected text steers the
+      model, so when a run goes wrong the first question is *which* skill
+      said that and *where it came from* — a poisoned or stale skill is
+      traceable from the transcript alone, without re-running retrieval.
+    - **``k`` defaults lower than the retriever's own.** These are full
+      procedure bodies landing in a live conversation; three is a context
+      budget, eight is a search page.
+
+    Pass a configured ``retriever`` to control retrieval wholesale (it wins
+    over ``k``/``kind``, which only shape the default ``BoostRetriever``).
+    """
+    if retriever is None:
+        retriever = BoostRetriever(k=k, kind=kind, full_content=True)
+
+    def boost_skill_context(state: dict) -> dict:
+        query = _last_human_text(state.get("messages") or [])
+        if not query.strip():
+            return {}
+        docs = retriever.invoke(query)
+        if not docs:
+            return {}
+        blocks = []
+        for doc in docs:
+            meta = doc.metadata
+            prov = "%s:%s" % (meta.get("tap") or "?", meta.get("source") or "?")
+            if meta.get("version"):
+                prov = "%s @ %s" % (prov, meta["version"])
+            blocks.append("### %s (%s — %s)\n\n%s" % (
+                meta.get("name") or "unnamed",
+                meta.get("kind") or "skill",
+                prov,
+                doc.page_content,
+            ))
+        content = (
+            "Procedures from the boost catalog relevant to the current "
+            "request. Apply the ones that fit; each is labeled with its "
+            "source so it can be audited.\n\n%s" % "\n\n".join(blocks)
+        )
+        return {"messages": [SystemMessage(content=content)]}
+
+    return boost_skill_context

boost_skill_cli-1.0.417/boost_langchain/loader.py

@@ -0,0 +1,59 @@
+"""Load one skill's SKILL.md as a LangChain ``Document``."""
+from __future__ import annotations
+
+from collections.abc import Iterator
+from pathlib import Path
+
+from langchain_core.document_loaders import BaseLoader
+from langchain_core.documents import Document
+
+from boost_cli.core import frontmatter
+
+
+class SkillMarkdownLoader(BaseLoader):
+    """Yield a SKILL.md as one Document: body as content, frontmatter as metadata.
+
+    One Document per skill, not one per chunk: a skill file is already the
+    author's chosen unit of instruction, and boost's own indexer moved off
+    chunking for the same reason (see rag._make_docs). Callers that want
+    chunks can run any LangChain splitter over the result.
+
+    Parsing reuses ``boost_cli.core.frontmatter`` rather than a YAML library
+    so this loader reads a skill file *exactly* the way boost's catalog does —
+    including the lossless-number rule that keeps ``version: 1.10`` from
+    silently becoming ``1.1``.
+    """
+
+    def __init__(self, path: str | Path):
+        """``path`` is a SKILL.md file, or a directory holding one."""
+        self.path = Path(path)
+
+    @classmethod
+    def from_installed(cls, name: str) -> SkillMarkdownLoader:
+        """Loader for a skill installed in boost's canonical store.
+
+        Resolves through ``store.skill_store_dir`` so the path is the single
+        source of truth every agent's symlink points at — not one particular
+        agent's view of it — and so unsafe names are rejected exactly the way
+        ``boost install`` rejects them (raises BoostError). A name installed
+        as a rule or workflow is declined by kind rather than with a bare
+        missing-file error: those kinds materialize into agent context files
+        and keep no store copy to load.
+        """
+        from boost_cli.core import lockfile, store
+        found = lockfile.find_any(name)
+        if found is not None and found[0] != "skill":
+            raise ValueError(
+                "%s is a %s — it materializes into agent context files and "
+                "has no store copy to load; retrieve it with "
+                "BoostRetriever(kind=%r) instead" % (name, found[0], found[0]))
+        return cls(store.skill_store_dir(name))
+
+    def lazy_load(self) -> Iterator[Document]:
+        path = self.path / "SKILL.md" if self.path.is_dir() else self.path
+        text = path.read_text(encoding="utf-8", errors="replace")
+        meta, body = frontmatter.parse(text)
+        # The real file path wins over any frontmatter key that happens to be
+        # named "source": metadata provenance must state where the bytes came
+        # from, and a self-reported value is the one thing that cannot.
+        yield Document(page_content=body, metadata={**meta, "source": str(path)})

boost_skill_cli-1.0.417/boost_langchain/retriever.py

@@ -0,0 +1,76 @@
+"""A LangChain retriever over boost's tapped skill/rule/workflow catalog."""
+from __future__ import annotations
+
+from typing import Literal
+
+from langchain_core.callbacks import CallbackManagerForRetrieverRun
+from langchain_core.documents import Document
+from langchain_core.retrievers import BaseRetriever
+from pydantic import Field
+
+from boost_cli.core import rag
+
+
+class BoostRetriever(BaseRetriever):
+    """Retrieve tapped boost items as LangChain ``Document`` objects.
+
+    This deliberately reuses boost's own engine (``rag.retrieve_any``) rather
+    than re-embedding the catalog into a vector store. Retrieval quality is
+    the reason: boost's Tier-1 eval gate floors recall@k, hit@1, MRR and
+    nDCG@k over a golden set on every merge, so wrapping that engine means the
+    retriever ships with numbers rather than claims — a fresh embedding
+    pipeline here would start from zero evidence. Reuse also inherits the
+    degrade ladder for free: hybrid RRF when the user has built a dense store,
+    BM25 full-content otherwise, and never an API key as the entry fee.
+
+    ``kind`` narrows results to one of boost's three item kinds ("skill",
+    "rule", "workflow"); ``None`` searches all of them. ``full_content``
+    controls whether a Document carries the item's whole body (what a chain
+    stuffing context wants) or just its one-line description (what a router
+    choosing among items wants).
+    """
+
+    # Validated at construction: a typo'd kind would otherwise return [] for
+    # every query, indistinguishable from an empty catalog; a negative k
+    # would silently drop the last hit via slice semantics.
+    k: int = Field(default=8, ge=0)
+    kind: Literal["skill", "rule", "workflow"] | None = None
+    full_content: bool = True
+
+    def _get_relevant_documents(
+        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
+    ) -> list[Document]:
+        # ensure() is what makes first use behave like `boost search`: it
+        # builds the BM25 index from the tapped catalog on demand and is
+        # incremental after that. Without it, a freshly tapped HOME would
+        # answer [] until the user happened to run a CLI search first.
+        rag.ensure()
+        hits, engine = rag.retrieve_any(query, k=self.k, kind=self.kind)
+        if hits is None:
+            # No index of any kind could be built — nothing is tapped. Mirror
+            # the CLI's degrade-cleanly rule: an empty shelf is an answer, not
+            # an error, and a chain should keep running without boost context.
+            return []
+        docs: list[Document] = []
+        for hit in hits:
+            entry = hit["entry"]
+            if self.full_content:
+                content = rag.read_body(entry)
+            else:
+                content = entry.get("description") or rag.surface(entry)
+            docs.append(Document(
+                page_content=content,
+                metadata={
+                    "name": entry.get("name", ""),
+                    "kind": entry.get("kind", "skill"),
+                    "tap": entry.get("tap", ""),
+                    "version": entry.get("version", ""),
+                    "source": entry.get("skill_md", ""),
+                    # Which engine actually answered (BM25 / dense / hybrid
+                    # RRF). Carried per-document because it is the first thing
+                    # to check when result quality surprises — see rag.rerank
+                    # for why a guessed label is worse than none.
+                    "engine": engine,
+                },
+            ))
+        return docs

{boost_skill_cli-1.0.415 → boost_skill_cli-1.0.417/boost_skill_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.415
+Version: 1.0.417
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE
@@ -707,6 +707,9 @@ Requires-Dist: ragas<0.3,>=0.2; extra == "eval"
 Requires-Dist: langchain-core<0.4; extra == "eval"
 Requires-Dist: langchain-community<0.4; extra == "eval"
 Requires-Dist: langchain-openai<1; extra == "eval"
+Provides-Extra: langchain
+Requires-Dist: langchain-core<2,>=1; extra == "langchain"
+Requires-Dist: pydantic>=2; extra == "langchain"
 Provides-Extra: bdd
 Requires-Dist: behave>=1.2.6; extra == "bdd"
 Provides-Extra: perf

{boost_skill_cli-1.0.415 → boost_skill_cli-1.0.417}/boost_skill_cli.egg-info/SOURCES.txt

@@ -98,6 +98,12 @@ boost_cli/core/updatediff.py
 boost_cli/core/util.py
 boost_cli/core/workflows.py
 boost_cli/data/registries.json
+boost_langchain/__init__.py
+boost_langchain/_compat.py
+boost_langchain/graph.py
+boost_langchain/loader.py
+boost_langchain/py.typed
+boost_langchain/retriever.py
 boost_skill_cli.egg-info/PKG-INFO
 boost_skill_cli.egg-info/SOURCES.txt
 boost_skill_cli.egg-info/dependency_links.txt
@@ -252,6 +258,7 @@ docs/roadmap/items/invocation-pid-logging-for-crash-correlation.md
 docs/roadmap/items/journal-rotation-race-and-handle-leak.md
 docs/roadmap/items/keyless-dense-tier-local-static-embeddings.md
 docs/roadmap/items/keyless-semantic-search-for-everyone.md
+docs/roadmap/items/langchain-in-the-wheel.md
 docs/roadmap/items/langchain-integration-explainer-page.md
 docs/roadmap/items/langchain-langgraph-langsmith-integration.md
 docs/roadmap/items/layering-guard-import-linter.md
@@ -398,6 +405,7 @@ evals/golden_set.json
 evals/make_corpus.py
 evals/make_golden.py
 evals/metrics.py
+evals/publish_golden_dataset.py
 evals/run_evals.py
 examples/README.md
 examples/adapt-demo.sh
@@ -515,6 +523,10 @@ tests/fuzz/corpus/registry/05-empty.txt
 tests/fuzz/corpus/registry/06-space.txt
 tests/fuzz/corpus/registry/07-slash.txt
 tests/fuzz/corpus/registry/08-bare-host.txt
+tests/langchain/conftest.py
+tests/langchain/test_graph.py
+tests/langchain/test_loader.py
+tests/langchain/test_retriever.py
 tests/perf/test_benchmarks.py
 tests/unit/test_a11y_check.py
 tests/unit/test_adapters.py
@@ -568,6 +580,7 @@ tests/unit/test_injectscan.py
 tests/unit/test_installscan.py
 tests/unit/test_integrity.py
 tests/unit/test_journal.py
+tests/unit/test_langchain_packaging.py
 tests/unit/test_link_ownership.py
 tests/unit/test_localembed.py
 tests/unit/test_localembed_e2e.py

{boost_skill_cli-1.0.415 → boost_skill_cli-1.0.417}/boost_skill_cli.egg-info/requires.txt

@@ -9,6 +9,10 @@ langchain-core<0.4
 langchain-community<0.4
 langchain-openai<1
 
+[langchain]
+langchain-core<2,>=1
+pydantic>=2
+
 [perf]
 pytest-benchmark>=4.0
 

boost_skill_cli-1.0.417/boost_skill_cli.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+boost_cli
+boost_langchain

{boost_skill_cli-1.0.415 → boost_skill_cli-1.0.417}/docs/langchain.html

@@ -129,10 +129,12 @@
   <!-- ===== hero ===== -->
   <div class="wrap hero">
     <p class="crumbs"><a href="index.html">boost</a> / docs / langchain integration</p>
-    <span class="badge">Interop · shipped in PR #466</span>
+    <span class="badge">Interop · shipped in PR #466 · folded into the wheel in PR #472</span>
     <h1>The skill catalog, <span class="grad-text">behind LangChain's</span> retriever contract.</h1>
     <p class="lede">boost's tapped catalog is 10,000+ retrievable procedures with frontmatter,
-      provenance and a lock file. <code>boost-langchain</code> makes it addressable from a Python
+      provenance and a lock file. The <code>boost_langchain</code> package — shipped inside the
+      <code>boost-skill-cli</code> wheel, switched on by the <code>[langchain]</code> extra —
+      makes it addressable from a Python
       agent runtime: a <b>retriever</b> over the same measured engine <code>boost search</code>
       runs on, a <b>document loader</b> for one SKILL.md, and a <b>LangGraph node</b> that pulls
       the right procedure into a run mid-flight. No API key, ever — and nothing tapped means
@@ -182,7 +184,7 @@
         the engine is why wrapping it beats re-embedding the catalog.</p>
 
       <div class="diagram">
-        <svg viewBox="0 0 900 400" role="img" aria-label="boost-langchain architecture: a LangChain app calls the boost_langchain seams, which call boost's retrieval engine over the tapped catalog; the Tier-1 eval gate floors the engine's quality">
+        <svg viewBox="0 0 900 400" role="img" aria-label="boost langchain integration architecture: a LangChain app calls the boost_langchain seams, which call boost's retrieval engine over the tapped catalog; the Tier-1 eval gate floors the engine's quality">
           <defs>
             <marker id="ah" markerWidth="9" markerHeight="9" refX="7" refY="3" orient="auto">
               <path d="M0,0 L7,3 L0,6 Z" fill="#7dd3fc"></path>
@@ -482,7 +484,7 @@ builder.<span class="fn">add_edge</span>(<span class="s">"skills"</span>, <span
           story). To run <b>online</b> evals against the <em>same</em> ground truth, publish the
           golden set as a LangSmith dataset with the
           <code>publish_golden_dataset.py</code> script (under
-          <code>integrations/langchain/scripts/</code>) — key-gated,
+          <code>evals/</code>) — key-gated,
           opt-in, run from a boost checkout. Re-running replaces examples wholesale, so the
           dataset always mirrors <code>tests/eval/golden.jsonl</code> rather than accreting. The
           point is one set of judgments in both places: an online regression and an offline
@@ -493,13 +495,14 @@ builder.<span class="fn">add_edge</span>(<span class="s">"skills"</span>, <span
         <p><b>The honest dependency paragraph.</b> boost's own <code>[eval]</code> extra pins the
           langchain 0.3 stack, because ragas — through 0.4.3 — still imports a
           <code>ChatVertexAI</code> path that langchain-community 0.4 removed, so
-          <code>import ragas</code> crashes beside langchain 1.x. What dissolves the conflict is
-          distribution isolation, not an unpin: <code>boost-langchain</code> is a separately
-          versioned package, so the langchain 1.x stack lives in its own environment and its own
-          CI leg while <code>[eval]</code> keeps its 0.3-stack pins in its own. The two majors
-          never co-install — pip refuses the combination loudly — and each surface tests against
-          the stack it really runs on. The unpin becomes a small follow-up the day ragas ships a
-          release after 0.4.3, which already carries the fix on its main branch.</p>
+          <code>import ragas</code> crashes beside langchain 1.x. What keeps the conflict honest
+          is <b>extra isolation</b>: the integration ships in the same wheel, but its langchain
+          1.x dependencies live in the <code>[langchain]</code> extra while <code>[eval]</code>
+          keeps its 0.3-stack pins. The two majors never co-install — asking pip for both extras
+          at once fails resolution loudly rather than silently breaking one of them — and each
+          surface tests against the stack it really runs on (the conformance leg installs the
+          extra; the eval tooling installs its own). The unpin becomes a small follow-up the day
+          ragas ships a release after 0.4.3, which already carries the fix on its main branch.</p>
       </div>
     </div>
   </section>
@@ -508,34 +511,37 @@ builder.<span class="fn">add_edge</span>(<span class="s">"skills"</span>, <span
   <section>
     <div class="wrap">
       <span class="eyebrow">Install</span>
-      <h2 class="sec-title">One pip install, two optional extras</h2>
+      <h2 class="sec-title">One extra on the wheel you already have</h2>
       <div class="term-wrap">
         <div class="window">
           <div class="bar"><div class="dots"><i></i><i></i><i></i></div>
-            <div class="bar-title">pip · boost-langchain</div></div>
-          <pre><span class="cm"># the package — pulls in boost-skill-cli + langchain-core</span>
-<span class="tp">$</span> <span class="tv">pip</span> <span class="tc">install</span> boost-langchain
+            <div class="bar-title">pip · boost-skill-cli[langchain]</div></div>
+          <pre><span class="cm"># the CLI plus the LangChain bindings — one wheel, one extra</span>
+<span class="tp">$</span> <span class="tv">pip</span> <span class="tc">install</span> 'boost-skill-cli[langchain]'
 
 <span class="cm"># give boost something to search (once)</span>
 <span class="tp">$</span> <span class="tv">boost</span> <span class="tc">tap</span> anthropics/skills
 
 <span class="cm"># optional: the LangGraph runtime for skill_context_node graphs</span>
-<span class="tp">$</span> <span class="tv">pip</span> <span class="tc">install</span> 'boost-langchain[langgraph]'
+<span class="tp">$</span> <span class="tv">pip</span> <span class="tc">install</span> langgraph
 
 <span class="cm"># optional: publish the golden set as a LangSmith dataset</span>
-<span class="tp">$</span> <span class="tv">pip</span> <span class="tc">install</span> 'boost-langchain[langsmith]'
-<span class="tp">$</span> <span class="tv">python</span> integrations/langchain/scripts/publish_golden_dataset.py
+<span class="tp">$</span> <span class="tv">pip</span> <span class="tc">install</span> langsmith
+<span class="tp">$</span> <span class="tv">python</span> evals/publish_golden_dataset.py
   <span class="tdim">published 91 examples to LangSmith dataset 'boost-golden-retrieval'</span></pre>
         </div>
       </div>
-      <p class="caption">The dataset publish is illustrative output; it exits with a one-line hint
+      <p class="caption">Without the extra the modules still ship but decline to import — naming
+        this exact fix. The dataset publish is illustrative output; it exits with a one-line hint
         rather than a traceback when the key or package is missing.</p>
       <div class="prose">
         <p>More depth: the
-          <a href="https://github.com/jonnyeclectic/boost/tree/main/integrations/langchain">package
-          README</a> covers the same ground as a reference, and the
-          <a href="roadmap.html#langchain-langgraph-langsmith-integration">roadmap card</a> holds
-          the full reasoning — including the packaging decision and the corrected ragas story.</p>
+          <a href="https://github.com/jonnyeclectic/boost/tree/main/boost_langchain">package
+          README</a> covers the same ground as a reference, and two roadmap cards hold the
+          reasoning: <a href="roadmap.html#langchain-langgraph-langsmith-integration">the
+          integration itself</a> and
+          <a href="roadmap.html#langchain-in-the-wheel">why it rides the wheel</a> instead of a
+          second PyPI project.</p>
       </div>
     </div>
   </section>

{boost_skill_cli-1.0.415 → boost_skill_cli-1.0.417}/docs/roadmap/items/boost-langchain-publishing.md

@@ -2,15 +2,24 @@
 id: boost-langchain-publishing
 board: code
 section: planned
-status: planned
+status: declined
 category: Release
 complexity: S
 impact: Med
 wow: 2
-note: the artifacts already build and pass twine check in CI — what is missing is a cadence and a Trusted Publisher
+note: declined — superseded by shipping the integration inside the boost-skill-cli wheel (see langchain-in-the-wheel)
 order: 98
 title: give <code>boost-langchain</code> a release path to PyPI
 ---
+<b>Declined, deliberately.</b> Both missing pieces below were owner-only or upstream-blocked, and
+the research they prompted dissolved the premise: a second PyPI project bought a separate release
+cadence nobody needed (boost releases more often than langchain), while the ecosystem evidence —
+langchain-community sunset, non-<code>langchain-*</code> names in LangChain's own integrations
+listing, in-host precedents from <code>ragatouille</code> to <code>mlflow</code> — showed the
+standalone distribution was never required. The integration now ships inside the
+<code>boost-skill-cli</code> wheel behind a <code>[langchain]</code> extra instead; see
+<code>langchain-in-the-wheel</code>. The original card follows for the record.
+
 The <code>boost-langchain</code> distribution shipped under <code>integrations/langchain/</code>
 with its whole point being a <b>separate release cadence</b> from <code>boost-skill-cli</code> —
 langchain majors move faster than boost does, and the conformance workflow already builds the