test(ai): require payload literals for orchestrator mode scans

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,18 @@ 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. Source-scan
+  regressions require those payload literals so a docstring mention
+  cannot satisfy ADR-0013.
+
 ## [0.71.0] - 2026-08-14
 
 ### Added

docs/adr/0013-adaptive-contextual-orchestrator-default.md

@@ -21,6 +21,8 @@ LineageWeave continues to own strict output parsing, evidence identifiers, IRT p
 
 A structured task may still be served by one model when the adaptive policy determines that it is sufficient. Harder requests may receive a deeper workflow without changing the LineageWeave API. Consumers must retain returned orchestration and usage evidence when the gateway exposes it.
 
+Contract tests require a payload-level `"mode": "auto"` or `"mode": "verify"` literal (or, for post-evaluation, `"mode": mode` plus `mode: str = "auto"`). A docstring mention of `mode="auto"` or `mode="verify"` is not sufficient. Wire tests call `answer()` / `judge()` / `evaluate()` and assert the outbound body.
+
 ## References
 
 Omidvar, H., & Akhlaghi, V. (2026). *A communication-theoretic framework for LLM agents: Cost-aware adaptive reliability* [Preprint]. arXiv. https://doi.org/10.48550/arXiv.2605.09121

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,85 @@
+"""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"',
+)
+_PAYLOAD_AUTO = '"mode": "auto"'
+_PAYLOAD_VERIFY = '"mode": "verify"'
+_TYPED_AUTO_DEFAULT = 'mode: str = "auto"'
+_FORWARDED_MODE = '"mode": mode'
+
+
+def _source(relative: str) -> str:
+    return (ROOT / relative).read_text(encoding="utf-8")
+
+
+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)
+                if relative.endswith("post_evaluation.py"):
+                    self.assertIn(_FORWARDED_MODE, source)
+                    self.assertIn(_TYPED_AUTO_DEFAULT, source)
+                    continue
+                self.assertIn(
+                    _PAYLOAD_AUTO,
+                    source,
+                    f"{relative} must send a payload-level mode=auto literal",
+                )
+
+    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.assertIn(
+                    _PAYLOAD_VERIFY,
+                    source,
+                    f"{relative} must send a payload-level mode=verify literal",
+                )
+                self.assertNotIn(
+                    _PAYLOAD_AUTO,
+                    source,
+                    f"{relative} must send verify, not a payload-level auto default",
+                )
+
+    def test_docstring_mode_mention_is_not_a_payload_literal(self) -> None:
+        """A class docstring contrast must not satisfy the auto/verify scan."""
+
+        source = (
+            '"""Calls the orchestrator with mode="auto", not mode="verify"."""\n'
+            "body = {\"messages\": [], \"mode\": \"route\"}\n"
+        )
+        self.assertNotIn(_PAYLOAD_AUTO, source)
+        self.assertNotIn(_PAYLOAD_VERIFY, source)
+        self.assertIn('mode="auto"', source)
+        self.assertIn('mode="verify"', source)
+
+
+if __name__ == "__main__":
+    unittest.main()