fix(ai): rebase adaptive defaults onto current main

ARCHITECTURE.md

@@ -84,17 +84,22 @@ 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
-> (`ContextualWisdomLab/contextual-orchestrator#149`). Until it merges,
-> the four 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.
+> **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`.
+> Upstream `ContextualWisdomLab/contextual-orchestrator#149` closed
+> unmerged; verify-mode honesty continues on
+> `ContextualWisdomLab/contextual-orchestrator#622` and is not on
+> deployed orchestrator `main`. LineageWeave talks to that service over
+> HTTP (`ORCHESTRATOR_BASE_URL`) and cannot pin or ship an unmerged
+> sibling commit. Until a verify-capable orchestrator is deployed, live
+> adjudication/chat tests against a real instance fail with
+> `invalid_mode` (deployed `main` still accepts only
+> `auto`/`route`/`conduct`) -- confirmed by reproducing the same `400`
+> against the orchestrator's own `/v1/chat/completions`, not caused by
+> anything in this repo. This repo keeps the explicit `verify` contract
+> and does not fall back to `auto`. 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.75.0] - 2026-08-17
 
 ### 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,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()