test(ai): lock auto and verify orchestrator transport contracts

ARCHITECTURE.md

@@ -83,17 +83,17 @@ flowchart LR
 | `server.py` | Stdlib HTTP server: `GET /api/lineage` (JSON graph) + static viewer |
 | `web/index.html` | Self-contained SVG DAG viewer, no build step, no external script dependency |
 
-> **Known local-test-environment limitation:** `adjudication_client.py`'s
-> `mode="verify"` call depends on contextual-orchestrator's
-> `TaskOrchestrator.route_and_verify`, which as of this writing is still
-> an open, unmerged upstream PR
+> **Known local-test-environment limitation:** `adjudication_client.py`
+> and `post_chat.py` send `mode="verify"` (ADR-0013). That call depends
+> on contextual-orchestrator's `TaskOrchestrator.route_and_verify`,
+> which as of this writing is still an open, unmerged upstream PR
 > (`ContextualWisdomLab/contextual-orchestrator#149`). Until it merges,
-> the four adjudication/chat tests that exercise `mode="verify"` against
+> the live adjudication/chat tests that exercise `mode="verify"` against
 > a real orchestrator fail with `invalid_mode` (the deployed `main` only
 > accepts `auto`/`route`/`conduct`) -- confirmed by reproducing the same
 > `400` directly against the orchestrator's own `/v1/chat/completions`,
-> not caused by anything in this repo. `mode="route"` (every other
-> pluggable client) is unaffected.
+> not caused by anything in this repo. Ordinary product adapters request
+> `mode="auto"` and are unaffected.
 
 ## Design decisions worth naming
 

CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this project are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Changed
+
+- Product LLM adapters now request contextual-orchestrator
+  `mode="auto"` rather than forcing a one-model route. The
+  orchestrator owns the quality-sufficient route, verification, or
+  conducted workflow. Citation-bearing post-chat and lineage
+  adjudication keep their explicit `verify` contracts.
+
 ## [0.71.0] - 2026-08-14
 
 ### Added

docs/lineage-bi-research-notes.md

@@ -254,9 +254,10 @@ classified into the closed `{our_side, counterparty}` set is dropped
 rather than guessed. N:N organization attachments are slot-filling on
 that mention (a person may have zero, one, or several affiliations in
 the same post), not a second independent NER pass. The live client
-calls contextual-orchestrator (`mode="route"`) rather than a raw LLM
-API so reasoning-effort allocation stays centralized with the
-adjudication channel. Proven for real during development against
+calls contextual-orchestrator (`mode="auto"`) rather than a raw LLM
+API so the orchestration plane can allocate route, verify, or a
+deeper workflow; adjudication and post-chat keep explicit
+`mode="verify"`. Proven for real during development against
 `fixtures.ambiguous_keyman_post` when orchestrator credentials are set;
 the default suite asserts the parser and the never-fake null client.
 

lineageweave/post_chat.py

@@ -187,7 +187,7 @@ class ContextualOrchestratorPostChatClient:
     ``mode="verify"`` exists for (one worker call plus one checked
     verifier judgment), same reasoning ``adjudication_client`` already
     uses, not ``keyman_extraction``/``entity_relationship_classification``'s
-    single-pass ``mode="route"`` structured extraction.
+    single-pass ``mode="auto"`` structured extraction.
     """
 
     available = True

tests/test_adaptive_orchestrator_default.py

@@ -0,0 +1,111 @@
+"""LineageWeave delegates product-default LLM execution to auto policy."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from lineageweave import adjudication_client, post_chat, post_evaluation
+from lineageweave.post_chat import ChatSourceDocument, ContextualOrchestratorPostChatClient
+
+
+def test_post_evaluation_adapter_defaults_to_auto(monkeypatch) -> None:
+    observed: dict[str, object] = {}
+
+    def fake_post_json(url, payload, *, headers, timeout):
+        observed.update(
+            url=url,
+            payload=payload,
+            headers=headers,
+            timeout=timeout,
+        )
+        return {"choices": [{"message": {"content": "{}"}}]}
+
+    monkeypatch.setattr(post_evaluation, "post_json", fake_post_json)
+    adapter = post_evaluation._OrchestratorCompleteAdapter(
+        "https://orchestrator.example.test", "inference_token"
+    )
+    adapter.complete([{"role": "user", "content": "Evaluate this evidence."}])
+
+    assert observed["payload"]["mode"] == "auto"
+
+
+def test_post_evaluation_judge_uses_auto_by_default() -> None:
+    client = post_evaluation.ContextualOrchestratorPostEvaluationClient(
+        "https://orchestrator.example.test", "inference_token"
+    )
+    assert client._judge.mode == "auto"
+
+
+def test_post_chat_requests_verify_mode(monkeypatch) -> None:
+    """Citation chat must send verify on the wire, not a docstring mention of auto."""
+
+    observed: dict[str, object] = {}
+
+    def fake_post_json(url, payload, *, headers, timeout):
+        observed["payload"] = payload
+        return {
+            "choices": [
+                {
+                    "message": {
+                        "content": (
+                            '{"answer_text": "The follow-up names the same bid.",'
+                            ' "cited_source_numbers": [1]}'
+                        )
+                    }
+                }
+            ]
+        }
+
+    monkeypatch.setattr(post_chat, "post_json", fake_post_json)
+    client = ContextualOrchestratorPostChatClient(
+        "https://orchestrator.example.test", "inference_token"
+    )
+    answer = client.answer(
+        "What happened between these events?",
+        [
+            ChatSourceDocument(
+                post_id="post-bid-follow-up",
+                post_title="Bid follow-up",
+                post_body="Northridge asked to confirm the bid date.",
+            )
+        ],
+    )
+
+    assert answer.cited_post_ids == ("post-bid-follow-up",)
+    assert observed["payload"]["mode"] == "verify"
+
+
+def test_adjudication_requests_verify_mode(monkeypatch) -> None:
+    """Lineage adjudication must send verify on the wire, not a source substring."""
+
+    observed: dict[str, object] = {}
+
+    def fake_post_json(url, payload, *, headers, timeout):
+        observed["payload"] = payload
+        return {"choices": [{"message": {"content": "0.91"}}]}
+
+    monkeypatch.setattr(adjudication_client, "post_json", fake_post_json)
+    client = adjudication_client.ContextualOrchestratorAdjudicationClient(
+        "https://orchestrator.example.test", "inference_token"
+    )
+    confidence = client.judge(
+        "Quarterly budget review meeting notes",
+        "Budget review follow-up: revised quarterly numbers",
+    )
+
+    assert confidence == 0.91
+    assert observed["payload"]["mode"] == "verify"
+
+
+def test_runtime_clients_do_not_force_single_model_route() -> None:
+    package_root = Path(__file__).resolve().parents[1] / "lineageweave"
+    violations: list[str] = []
+    for path in sorted(package_root.glob("*.py")):
+        text = path.read_text(encoding="utf-8")
+        if '"mode": "route"' in text or "'mode': 'route'" in text:
+            violations.append(f"{path.name}: request payload")
+        if 'mode="route"' in text or "mode='route'" in text:
+            violations.append(f"{path.name}: constructor/call default")
+        if 'mode: str = "route"' in text or "mode: str = 'route'" in text:
+            violations.append(f"{path.name}: typed default")
+    assert violations == []

tests/test_contextual_orchestrator_default_policy.py

@@ -0,0 +1,77 @@
+"""Contract tests for adaptive contextual-orchestrator consumer defaults."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+AUTO_CLIENTS = (
+    "lineageweave/post_summary.py",
+    "lineageweave/post_evaluation.py",
+    "lineageweave/keyman_extraction.py",
+    "lineageweave/commitment_extraction.py",
+    "lineageweave/entity_relationship_classification.py",
+)
+VERIFY_CLIENTS = (
+    "lineageweave/post_chat.py",
+    "lineageweave/adjudication_client.py",
+)
+_ROUTE_MARKERS = (
+    '"mode": "route"',
+    'mode="route"',
+    'mode: str = "route"',
+)
+_AUTO_MARKERS = (
+    '"mode": "auto"',
+    'mode="auto"',
+    'mode: str = "auto"',
+)
+_VERIFY_MARKERS = (
+    '"mode": "verify"',
+    'mode="verify"',
+    'mode: str = "verify"',
+)
+
+
+def _source(relative: str) -> str:
+    return (ROOT / relative).read_text(encoding="utf-8")
+
+
+def _contains_any(source: str, markers: tuple[str, ...]) -> bool:
+    return any(marker in source for marker in markers)
+
+
+class AdaptiveOrchestratorDefaultTest(unittest.TestCase):
+    """Protect production clients from regressing to forced one-model routing."""
+
+    def test_auto_clients_request_auto_and_never_force_route(self) -> None:
+        for relative in AUTO_CLIENTS:
+            source = _source(relative)
+            with self.subTest(path=relative):
+                for marker in _ROUTE_MARKERS:
+                    self.assertNotIn(marker, source)
+                self.assertTrue(
+                    _contains_any(source, _AUTO_MARKERS),
+                    f"{relative} must request mode=auto in executable source",
+                )
+
+    def test_verify_clients_keep_checked_judgment_and_never_force_route(self) -> None:
+        for relative in VERIFY_CLIENTS:
+            source = _source(relative)
+            with self.subTest(path=relative):
+                for marker in _ROUTE_MARKERS:
+                    self.assertNotIn(marker, source)
+                self.assertTrue(
+                    _contains_any(source, _VERIFY_MARKERS),
+                    f"{relative} must request mode=verify in executable source",
+                )
+                self.assertNotIn(
+                    '"mode": "auto"',
+                    source,
+                    f"{relative} must send verify, not a payload-level auto default",
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()