kb init: block every stage when the adapter is not in the knowledge repository at the base

The jiuwenswarm pilot ran `kb init --stage modules` with its adapter PR
still unmerged. The stage reads the adapter manifest from the knowledge
repository at the base commit; it was absent there, `_manifest_text()`
returned None, `_language()` degraded to "", and the stage recorded
`empty` with "the adapter declares no repo.language" although the
adapter declares python. That is a silent degrade (invariant 7). Deepen
and harvest already blocked on the same condition, each with its own
copy of the message.

Every stage, the skeleton included, now checks at start that the
manifest exists at the base and blocks with one shared message
(`adapter_missing`) before any model call; deepen and harvest reuse it.
The check runs before the cached-record short cut: the inputs digest
never covered the manifest, so a record from a run before this fix
would otherwise be returned as a pass.
A present manifest that declares no language still scans nothing and
says so on the checklist (never guess a language).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: tzhouam

doc/architecture/SPEC/kb_service.md

@@ -389,7 +389,7 @@ x 必须为正。因阈值停下的调用（`stop_reason="max_budget"`）→ `Mo
   run 却要发布、未运行或处于 blocked/publishing 的前序阶段 → `blocked`，不调模型。后续阶段缺省沿用前序阶段的钉点
   （`--pin` 可改，改了记入 notes）；链的状态进入输入摘要。阶段没有任何改动时记为 `empty`（不是错误）。
   `InitRecord.coverage` 是阶段的覆盖率报告，PR 正文渲染成 before/after 表。适配器 manifest 从前序 dry run 的改动或知识
-  仓库基点读取（`adapters/<adapter 目录名>/manifest.yaml`）；`repo.language` 决定模块扫描的语言。
+  仓库基点读取（`adapters/<adapter 目录名>/manifest.yaml`）；`repo.language` 决定模块扫描的语言。**每个阶段**（含 skeleton）开始时先要求这个 manifest 在知识仓库基点存在，否则用同一条消息（`adapter_missing`）`blocked`，不调模型：adapter 在自己的 PR 里先合入，缺失绝不退化成"未声明语言"（jiuwenswarm 试点回归）。
 - `init_modules`（阶段 2）：在钉点树上 `scan_modules_at_depth`（`source_roots`、`module_depth`、`min_module_loc`、
   `exclude`；adapter 未声明语言或语言未知 → 不扫描，进清单）。按当前 `_routes.yaml` 算模块覆盖率。未覆盖的模块由深到浅：
   已被某个 owner 部分覆盖的，**吸收**进以**最具体**方式覆盖其文件最多的 owner（路由顺序打平）：只在该 owner 的

src/infermatrix_copilot/kb_service/init_deepen.py

@@ -41,7 +41,9 @@
 from .init_budget import BudgetExhausted
 from .init_coverage import Owner, load_owners, make_include, most_specific, pr_weighted_coverage
 from .init_modules import scan_modules
-from .init_stages import ROUTES_NAME, _Candidate, _fence, _numbered, _one_line, _Stage, _title_of
+from .init_stages import (
+    ROUTES_NAME, _Candidate, _fence, _numbered, _one_line, _Stage, _title_of, adapter_missing,
+)
 from .init_support import InitError, InitRecord, generate
 
 MAX_CODE_BYTES = 100_000
@@ -331,7 +333,7 @@ def _flip(self) -> tuple[dict[str, tuple[str | None, str | None]], list[str]]:
         path = self._manifest_path()
         before = self._manifest_text()
         if before is None:
-            return {}, [f"{path} does not exist in the knowledge repository at the base"]
+            return {}, [adapter_missing(path)]
         try:
             after = flip_to_shadow(before)
         except InitError as exc:

src/infermatrix_copilot/kb_service/init_harvest.py

@@ -52,7 +52,7 @@
 from ..knowledge_service.lifecycle import LifecycleError, Page
 from ..knowledge_service.pinned_claims import Evidence
 from .gate import changes_between
-from .init_stages import MAX_EXCERPT_BYTES, _Candidate, _Stage
+from .init_stages import MAX_EXCERPT_BYTES, _Candidate, _Stage, adapter_missing
 from .init_support import STAGES, InitError, InitRecord
 
 CALIBRATION_DIR = "kb-calibration"
@@ -320,7 +320,7 @@ def _write(self, cases: list[dict]) -> InitRecord:
         manifest_path = self._manifest_path()
         before = self._manifest_text()
         if before is None:
-            return self._blocked([f"{manifest_path} does not exist in the knowledge repository at the base"])
+            return self._blocked([adapter_missing(manifest_path)])
         try:
             after = set_calibration_set(before)
         except InitError as exc:

src/infermatrix_copilot/kb_service/init_stages.py

@@ -147,6 +147,13 @@ def run_stage(rt: InitRuntime, lifecycle, stage: str, *, dry_run: bool, pin: str
     return stage_class(rt, lifecycle, dry_run=dry_run, pin=pin, notes=notes, author=author).run()
 
 
+def adapter_missing(path: str) -> str:
+    """The one message every stage gives when the adapter manifest is not in
+    the knowledge repository at the base: adapters ship in their own PR, merged
+    before kb init runs, and a stage never guesses what an absent one says."""
+    return f"{path} does not exist in the knowledge repository at the base"
+
+
 def _stage_class(stage: str) -> type:
     if stage == "skeleton":
         return _Skeleton
@@ -324,8 +331,14 @@ def run(self) -> InitRecord:
         init = lc.init
         self.repo_dir = lc.knowledge_dir
         base_sha = rt.knowledge.fetch()
+        self._base_sha = base_sha
         main = rt.knowledge.knowledge_files(base_sha)
         chain = self._chain()
+        self.overlay = dict(chain.repo_files)
+        # every stage reads the adapter here (language, the flips); an unmerged
+        # adapter PR must block, never degrade to "no language" — and never be
+        # papered over by a record cached from a run before this check
+        adapter_missing_problem = adapter_missing(self._manifest_path()) if self._manifest_text() is None else ""
         upstream = rt.upstream(lc.repo, lc.full_name)
         upstream.sync()
         pin = upstream.resolve(self.pin or chain.pin or "HEAD")
@@ -340,7 +353,7 @@ def run(self) -> InitRecord:
                 raise InitError("a publication of this stage is pending (pushed, PR not confirmed); re-run "
                                 f"without --dry-run to finish it, or remove {record_path} to start over")
             return self._resume(previous)
-        if previous is not None and previous.inputs_digest == digest \
+        if previous is not None and previous.inputs_digest == digest and not adapter_missing_problem \
                 and previous.status in ("dry_run", "published", "empty"):
             return previous
         if previous is not None and previous.pr.get("number") and previous.inputs_digest != digest:
@@ -353,8 +366,9 @@ def run(self) -> InitRecord:
             self.record.notes.append(f"pinned at {pin[:12]}, not at the earlier stages' {chain.pin[:12]}")
         self.budget = Budget(init.budget_usd)
         self.base = {**main, **chain.knowledge}
-        self.overlay = dict(chain.repo_files)
         problems = chain.problems + self._precheck()
+        if adapter_missing_problem:
+            problems.append(adapter_missing_problem)
         if problems:
             return self._blocked(problems)
         schema = rt.knowledge.show(base_sha, "doc/knowledge/SCHEMA.md")
@@ -466,7 +480,7 @@ def _manifest_text(self) -> str | None:
         path = self._manifest_path()
         if path in self.overlay:
             return self.overlay[path]
-        return self.rt.knowledge.show(self.record.kb_base_sha, path)
+        return self.rt.knowledge.show(self._base_sha, path)
 
     def _language(self) -> str:
         """The adapter's ``repo.language`` ("" when it declares none)."""

test/test_kb_init_modules.py

@@ -13,6 +13,7 @@
 
 from infermatrix_copilot.kb_service.init_modules import SYSTEM_CARD, _leading_doc, declaration, routes_append_only
 from infermatrix_copilot.kb_service.init_stages import run_stage
+from infermatrix_copilot.kb_service.config import RepoLifecycle
 from infermatrix_copilot.kb_service.init_support import InitRecord
 from infermatrix_copilot.kb_service.models import ModelReply
 from infermatrix_copilot.knowledge_service.lifecycle import Page
@@ -203,6 +204,19 @@ def test_cards_join_an_existing_group_append_only(world):
     assert len(tooling) == 1 and set(tooling[0]["scope_prefixes"]) >= {"tools/fmt/", "tools/lint/"}
 
 
+def test_an_adapter_missing_at_the_base_blocks_the_modules_stage(world):
+    """The pilot fail-open: an absent manifest is not "no language"."""
+    _world_with_tools(world)
+    _skeleton(world)
+    lifecycle = RepoLifecycle(**{**_modules_lifecycle().__dict__, "adapter_dir": Path("adapters/nope")})
+    gateway = CardGateway()
+    record = run_stage(_runtime(world, gateway), lifecycle, "modules", dry_run=True)
+    assert record.status == "blocked"
+    assert record.problems == ["adapters/nope/manifest.yaml does not exist in the knowledge repository at the base"]
+    assert not any("no repo.language" in item for item in record.checklist)
+    assert not [c for c in gateway.calls if c["system"] == SYSTEM_CARD]
+
+
 def test_no_language_means_no_scan_and_an_empty_stage(world):
     _commit(world["upstream"], TOOLS, "tools")        # the adapter still declares no language
     _skeleton(world)

test/test_kb_init_skeleton.py

@@ -500,7 +500,8 @@ def test_model_headings_in_generated_prose_never_become_rules(world):
 
 def test_a_repo_tag_missing_from_the_taxonomy_blocks(world):
     lifecycle = RepoLifecycle(repo="newrepo", full_name="o/new", enabled=False, mode="shadow",
-                              knowledge_dir="repos/newrepo", init=InitConfig())
+                              knowledge_dir="repos/newrepo", init=InitConfig(),
+                              adapter_dir=Path("adapters/toy"))   # its adapter IS at the base; only the tag is missing
     gateway = FakeGateway()
     record = run_stage(_runtime(world, gateway), lifecycle, "skeleton", dry_run=True)
     assert record.status == "blocked" and "taxonomy" in record.problems[0]
@@ -536,6 +537,32 @@ def test_missing_seed_blocks(world):
     assert record.status == "blocked" and "does not exist" in record.problems[0]
 
 
+def test_an_adapter_missing_at_the_base_blocks_the_skeleton(world):
+    """Regression (jiuwenswarm pilot, 2026-09-30): the adapter PR was not
+    merged, so its manifest was absent from the knowledge repository at the
+    base; the modules stage then read "no language" and ran empty instead of
+    blocking. Every stage now blocks before any model call."""
+    lifecycle = RepoLifecycle(**{**_lifecycle().__dict__, "adapter_dir": Path("adapters/nope")})
+    gateway = FakeGateway()
+    record = run_stage(_runtime(world, gateway), lifecycle, "skeleton", dry_run=True)
+    assert record.status == "blocked"
+    assert record.problems == ["adapters/nope/manifest.yaml does not exist in the knowledge repository at the base"]
+    assert gateway.calls == []
+
+
+def test_an_adapter_missing_at_the_base_is_not_hidden_by_a_cached_record(world):
+    """A record from a run before this check (same inputs digest: the digest
+    never covered the manifest) must not be returned as if the stage passed."""
+    record = run_stage(_runtime(world), _lifecycle(), "skeleton", dry_run=True)
+    assert record.status == "dry_run", record.problems
+    lifecycle = RepoLifecycle(**{**_lifecycle().__dict__, "adapter_dir": Path("adapters/nope")})
+    gateway = FakeGateway()
+    again = run_stage(_runtime(world, gateway), lifecycle, "skeleton", dry_run=True)
+    assert again.status == "blocked"
+    assert again.problems == ["adapters/nope/manifest.yaml does not exist in the knowledge repository at the base"]
+    assert gateway.calls == []
+
+
 def test_private_upstream_is_always_a_dry_run(world):
     lifecycle = RepoLifecycle(**{**_lifecycle().__dict__, "upstream_visibility": "private"})
     record = run_stage(_runtime(world), lifecycle, "skeleton", dry_run=False)