Deploy free local 4B+4B+8B 829d4932ef224f7b02587a37d9948c47459042ac KB kb-20260814T042741+0900

Dockerfile

@@ -1,19 +1,80 @@
-FROM python:3.13-slim
+FROM ghcr.io/ggml-org/llama.cpp:server AS llama_cpp
+
+FROM python:3.12-slim
 
 ENV PYTHONDONTWRITEBYTECODE=1 \
     PYTHONUNBUFFERED=1 \
-    PORT=7860
+    PORT=7860 \
+    LD_LIBRARY_PATH=/opt/llama \
+    CUSTOMER_AI_CONSTRUCTIVE_API_URL=http://127.0.0.1:8081/v1/chat/completions \
+    CUSTOMER_AI_ADVERSARIAL_API_URL=http://127.0.0.1:8082/v1/chat/completions \
+    CUSTOMER_AI_EVIDENCE_API_URL=http://127.0.0.1:8083/v1/chat/completions \
+    CUSTOMER_AI_LOCAL_4B_PATH=/models/llm-jp-3-3.7b-instruct3-Q4_K_M.gguf \
+    CUSTOMER_AI_LOCAL_8B_PATH=/models/llm-jp-4-8b-instruct-Q4_K_M.gguf
 
 WORKDIR /app
 
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends ca-certificates curl libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY --from=llama_cpp /app /opt/llama
+
 COPY requirements.txt /app/requirements.txt
 RUN python -m pip install --no-cache-dir --upgrade pip \
     && python -m pip install --no-cache-dir -r /app/requirements.txt
 
+# Download immutable, public GGUF weights at build time. These are local model
+# files, not Hugging Face Inference Provider calls, so runtime inference credits
+# are never consumed.
+RUN mkdir -p /models \
+    && python - <<'PY'
+from hashlib import sha256
+from pathlib import Path
+from huggingface_hub import hf_hub_download
+
+targets = [
+    {
+        "repo": "mmnga/llm-jp-3-3.7b-instruct3-gguf",
+        "revision": "7edef5a4f094ec8c1aed1e196c6a544675efbc2f",
+        "filename": "llm-jp-3-3.7b-instruct3-Q4_K_M.gguf",
+        "sha256": "a4a09d2141717a01b44e7a8dbdb28da8c01e9078c8051367cd6a20f7008ef5a8",
+    },
+    {
+        "repo": "mmnga-o/llm-jp-4-8b-instruct-gguf",
+        "revision": "7ae4da12cee2f109509cb8e1d01cf8a0f1a5fbc1",
+        "filename": "llm-jp-4-8b-instruct-Q4_K_M.gguf",
+        "sha256": "b6a61b9c8d4e7cb1ae543d8fcf472c9fb9abfc5d48af17f5017ce89c2dc0bd56",
+    },
+]
+
+for item in targets:
+    path = Path(
+        hf_hub_download(
+            repo_id=item["repo"],
+            revision=item["revision"],
+            filename=item["filename"],
+            local_dir="/models",
+        )
+    )
+    h = sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""):
+            h.update(chunk)
+    actual = h.hexdigest()
+    if actual != item["sha256"]:
+        raise SystemExit(
+            f"local_model_sha_mismatch file={item['filename']} expected={item['sha256']} actual={actual}"
+        )
+    print(f"LOCAL_MODEL_PINNED={path.name} SHA256={actual}")
+PY
+
 COPY app.py /app/app.py
 COPY runtime /app/runtime
 COPY config /app/config
+COPY scripts/start_local_cpu.sh /app/scripts/start_local_cpu.sh
+RUN chmod +x /app/scripts/start_local_cpu.sh
 
 EXPOSE 7860
 
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["/app/scripts/start_local_cpu.sh"]

config/model.yaml

@@ -1,19 +1,33 @@
 model:
   topology: one_work_three_role_models
   constructive:
-    model_id: Qwen/Qwen3-4B
-    route_alias: qwen3:4b
-    revision: null
+    model_id: llm-jp/llm-jp-3-3.7b-instruct3
+    class: 4B
+    backend: local_llama_cpp
+    endpoint: http://127.0.0.1:8081/v1/chat/completions
+    gguf_repo: mmnga/llm-jp-3-3.7b-instruct3-gguf
+    revision: 7edef5a4f094ec8c1aed1e196c6a544675efbc2f
+    gguf_sha256: a4a09d2141717a01b44e7a8dbdb28da8c01e9078c8051367cd6a20f7008ef5a8
   adversarial:
-    model_id: Qwen/Qwen3-4B
-    route_alias: qwen3:4b
-    revision: null
+    model_id: llm-jp/llm-jp-3-3.7b-instruct3
+    class: 4B
+    backend: local_llama_cpp
+    endpoint: http://127.0.0.1:8082/v1/chat/completions
+    gguf_repo: mmnga/llm-jp-3-3.7b-instruct3-gguf
+    revision: 7edef5a4f094ec8c1aed1e196c6a544675efbc2f
+    gguf_sha256: a4a09d2141717a01b44e7a8dbdb28da8c01e9078c8051367cd6a20f7008ef5a8
   evidence_bound:
-    model_id: Qwen/Qwen3-8B
-    route_alias: qwen3:8b
-    revision: null
-  backend_mode: benchmark_required
-  role_adapter_mode: benchmark_required
+    model_id: llm-jp/llm-jp-4-8b-instruct
+    class: 8B
+    backend: local_llama_cpp
+    endpoint: http://127.0.0.1:8083/v1/chat/completions
+    gguf_repo: mmnga-o/llm-jp-4-8b-instruct-gguf
+    revision: 7ae4da12cee2f109509cb8e1d01cf8a0f1a5fbc1
+    gguf_sha256: b6a61b9c8d4e7cb1ae543d8fcf472c9fb9abfc5d48af17f5017ce89c2dc0bd56
+  backend_mode: local_cpu_basic_no_inference_provider
+  role_adapter_mode: independent_role_processes
+  inference_provider_allowed: false
+  inference_provider_credit_burn_allowed: false
   require_trained_domain_model: true
   allow_untrained_production_model: false
   zero_gpu: false

deployment-manifest.json

@@ -1,7 +1,13 @@
 {
   "schema_version": 5,
-  "kb_storage": "huggingface_private_bucket_direct_runtime",
+  "source_sha": "829d4932ef224f7b02587a37d9948c47459042ac",
+  "generated_at": "2026-08-23T07:31:44.635267+00:00",
+  "kb_storage": "huggingface_private_bucket_remote_read",
   "kb_bucket_id": "G-ACE/astera-customerai-kb",
   "kb_build_id": "kb-20260814T042741+0900",
-  "kb_embedded_in_space": false
+  "kb_active_pointer": "active.json",
+  "kb_embedded_in_space": false,
+  "role_topology": "local_cpu_4b_4b_8b",
+  "inference_provider": "disabled",
+  "deployment_path": "direct_hf_hub_cpu_basic"
 }

pyproject.toml

@@ -2,7 +2,7 @@
 name = "astera-customer-ai"
 version = "0.0.0"
 requires-python = ">=3.11"
-dependencies = ["fastapi>=0.128,<1", "uvicorn>=0.48,<1", "pydantic>=2.12,<3", "httpx>=0.28,<1", "rapidfuzz==3.14.3", "pyyaml>=6,<7", "huggingface_hub>=1.24,<2"]
+dependencies = ["fastapi>=0.128,<1", "uvicorn>=0.48,<1", "pydantic>=2.12,<3", "httpx>=0.28,<1", "rapidfuzz==3.14.3", "pyyaml>=6,<7", "huggingface_hub>=1.24,<2", "hf-xet>=1.1,<2"]
 
 [project.optional-dependencies]
 training = ["datasets", "transformers", "peft", "trl"]

requirements.txt

@@ -5,3 +5,4 @@ httpx>=0.28,<1
 rapidfuzz==3.14.3
 pyyaml>=6,<7
 huggingface_hub>=1.24,<2
+hf-xet>=1.1,<2

runtime/bootstrap.py

@@ -3,7 +3,13 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Iterable, Mapping
 
-from .hf_client import HF_CHAT_API, HF_MODEL_4B, HF_MODEL_8B
+from .hf_client import (
+    HF_CHAT_API_ADVERSARIAL,
+    HF_CHAT_API_CONSTRUCTIVE,
+    HF_CHAT_API_EVIDENCE,
+    HF_MODEL_4B,
+    HF_MODEL_8B,
+)
 from .japanese_skills import JapaneseShortQASkillPack
 from .runtime_factory import InternalRuntimeDependencies, build_internal_core
 from .service import CustomerAIWork
@@ -19,13 +25,15 @@ class RuntimeDependencies:
     kb_generation_id: str | None = None
     hf_token: str | None = None
     role_pool: object | None = None
-    shared_head: object | None = None  # compatibility injection only; not a single-model contract
+    shared_head: object | None = None
     max_targeted_retry: int = 1
     constructive_model_id: str = HF_MODEL_4B
     adversarial_model_id: str = HF_MODEL_4B
     evidence_model_id: str = HF_MODEL_8B
-    hf_api_url: str = HF_CHAT_API
-    timeout_seconds: float = 30.0
+    constructive_api_url: str = HF_CHAT_API_CONSTRUCTIVE
+    adversarial_api_url: str = HF_CHAT_API_ADVERSARIAL
+    evidence_api_url: str = HF_CHAT_API_EVIDENCE
+    timeout_seconds: float = 300.0
 
 
 def build_work(deps: RuntimeDependencies) -> CustomerAIWork:
@@ -51,7 +59,9 @@ def build_work(deps: RuntimeDependencies) -> CustomerAIWork:
             constructive_model_id=deps.constructive_model_id,
             adversarial_model_id=deps.adversarial_model_id,
             evidence_model_id=deps.evidence_model_id,
-            hf_api_url=deps.hf_api_url,
+            constructive_api_url=deps.constructive_api_url,
+            adversarial_api_url=deps.adversarial_api_url,
+            evidence_api_url=deps.evidence_api_url,
             timeout_seconds=deps.timeout_seconds,
         )
     )

runtime/hf_client.py

@@ -5,31 +5,47 @@ from collections.abc import Sequence
 
 import httpx
 
-HF_MODEL_4B = "Qwen/Qwen3-4B"
-HF_MODEL_8B = "Qwen/Qwen3-8B"
+HF_MODEL_4B = "llm-jp/llm-jp-3-3.7b-instruct3"
+HF_MODEL_8B = "llm-jp/llm-jp-4-8b-instruct"
 HF_ALLOWED_MODELS = frozenset({HF_MODEL_4B, HF_MODEL_8B})
-HF_CHAT_API = "https://router.huggingface.co/v1/chat/completions"
+
+HF_CHAT_API_CONSTRUCTIVE = "http://127.0.0.1:8081/v1/chat/completions"
+HF_CHAT_API_ADVERSARIAL = "http://127.0.0.1:8082/v1/chat/completions"
+HF_CHAT_API_EVIDENCE = "http://127.0.0.1:8083/v1/chat/completions"
+HF_CHAT_API = HF_CHAT_API_CONSTRUCTIVE  # compatibility alias only
+
+
+def _default_local_url(model_id: str) -> str:
+    if model_id == HF_MODEL_4B:
+        return HF_CHAT_API_CONSTRUCTIVE
+    if model_id == HF_MODEL_8B:
+        return HF_CHAT_API_EVIDENCE
+    raise ValueError(f"model_drift:{model_id}")
 
 
 class HFChatClient:
-    """Role-scoped Hugging Face chat client. Multiple role clients may share one HTTP pool."""
+    """Role-scoped OpenAI-compatible client backed only by local llama.cpp.
+
+    Production rejects non-loopback endpoints so HF Inference Providers cannot
+    be used accidentally and cannot consume inference credits.
+    """
 
     def __init__(
         self,
         *,
-        token: str,
+        token: str = "",
         model_id: str,
-        api_url: str = HF_CHAT_API,
-        timeout_seconds: float = 30.0,
+        api_url: str | None = None,
+        timeout_seconds: float = 600.0,
         client: httpx.AsyncClient | None = None,
     ):
         if model_id not in HF_ALLOWED_MODELS:
             raise ValueError(f"model_drift:{model_id}")
-        if not token.strip() and client is None:
-            raise ValueError("hf_token_required")
+        resolved_url = (api_url or _default_local_url(model_id)).strip()
+        if not resolved_url.startswith(("http://127.0.0.1", "http://localhost")):
+            raise ValueError("remote_inference_endpoint_forbidden")
         self.model_id = model_id
-        self.api_url = api_url
-        self._token = token.strip()
+        self.api_url = resolved_url
         self._owned = client is None
         self._client = client or httpx.AsyncClient(timeout=timeout_seconds)
 
@@ -37,7 +53,7 @@ class HFChatClient:
         self,
         messages: Sequence[dict[str, str]],
         *,
-        max_tokens: int = 1800,
+        max_tokens: int = 900,
     ) -> dict[str, object]:
         payload = {
             "model": self.model_id,
@@ -45,10 +61,10 @@ class HFChatClient:
             "response_format": {"type": "json_object"},
             "stream": False,
             "temperature": 0.1,
+            "top_p": 0.9,
             "max_tokens": max_tokens,
         }
-        headers = {"authorization": f"Bearer {self._token}"} if self._token else {}
-        response = await self._client.post(self.api_url, headers=headers, json=payload)
+        response = await self._client.post(self.api_url, json=payload)
         response.raise_for_status()
         body = response.json()
         choices = body.get("choices") or []
@@ -57,7 +73,12 @@ class HFChatClient:
         content = choices[0].get("message", {}).get("content")
         if not isinstance(content, str) or not content.strip():
             raise RuntimeError("model_empty_content")
-        decoded = json.loads(content)
+        text = content.strip()
+        first = text.find("{")
+        last = text.rfind("}")
+        if first >= 0 and last >= first:
+            text = text[first : last + 1]
+        decoded = json.loads(text)
         if not isinstance(decoded, dict):
             raise RuntimeError("model_non_object_json")
         return decoded

runtime/model.py

@@ -7,6 +7,13 @@ from typing import Protocol
 
 import httpx
 
+from .hf_client import (
+    HF_CHAT_API_ADVERSARIAL,
+    HF_CHAT_API_CONSTRUCTIVE,
+    HF_CHAT_API_EVIDENCE,
+    HF_MODEL_4B,
+    HF_MODEL_8B,
+)
 from .roles import role_rules
 from .schemas import RoleName, RoleResult, SharedRolePacket
 
@@ -39,26 +46,76 @@ class ResidentRolePool:
         return await self._workers[role].run(packet)
 
 
+_LOCAL_ROLE_CONFIG = {
+    RoleName.CONSTRUCTIVE: (HF_MODEL_4B, HF_CHAT_API_CONSTRUCTIVE),
+    RoleName.ADVERSARIAL: (HF_MODEL_4B, HF_CHAT_API_ADVERSARIAL),
+    RoleName.EVIDENCE_BOUND: (HF_MODEL_8B, HF_CHAT_API_EVIDENCE),
+}
+
+
 class HuggingFaceRoleBackend:
-    def __init__(self, *, role: RoleName, model_id: str, token: str, api_url: str = "https://router.huggingface.co/v1/chat/completions", timeout_seconds: float = 30.0):
-        if not model_id.strip(): raise ValueError("model_id_required")
-        if not token.strip(): raise ValueError("hf_token_required")
-        self.role, self.model_id, self.token, self.api_url, self.timeout_seconds = role, model_id.strip(), token.strip(), api_url, timeout_seconds
+    """Compatibility backend name retained; inference itself is local-only.
+
+    No Hugging Face Inference Provider endpoint is accepted. The HF token is
+    intentionally ignored for inference and exists only for old constructor compatibility.
+    """
+
+    def __init__(
+        self,
+        *,
+        role: RoleName,
+        model_id: str | None = None,
+        token: str = "",
+        api_url: str | None = None,
+        timeout_seconds: float = 600.0,
+    ):
+        expected_model, expected_url = _LOCAL_ROLE_CONFIG[role]
+        chosen_model = (model_id or expected_model).strip()
+        chosen_url = (api_url or expected_url).strip()
+        if chosen_model != expected_model:
+            raise ValueError(f"model_drift:{role.value}:{chosen_model}")
+        if chosen_url != expected_url:
+            raise ValueError(f"remote_or_wrong_endpoint_forbidden:{role.value}:{chosen_url}")
+        self.role = role
+        self.model_id = chosen_model
+        self.api_url = chosen_url
+        self.timeout_seconds = timeout_seconds
 
     async def generate_role(self, role: RoleName, packet: SharedRolePacket) -> RoleResult:
-        if role != self.role: raise ValueError("backend_role_mismatch")
+        if role != self.role:
+            raise ValueError("backend_role_mismatch")
         prompt = {
             "role": role.value,
             "rules": role_rules(role),
             "packet": packet.model_dump(mode="json"),
             "required_output_schema": RoleResult.model_json_schema(),
-            "constraints": ["Use only supplied packet facts for Astera-specific claims.", "Return JSON only.", "Do not claim external actions were executed."],
+            "constraints": [
+                "Use only supplied packet facts for Astera-specific claims.",
+                "Return JSON only.",
+                "Do not claim external actions were executed.",
+            ],
         }
         async with httpx.AsyncClient(timeout=self.timeout_seconds) as client:
-            response = await client.post(self.api_url, headers={"authorization": f"Bearer {self.token}"}, json={"model": self.model_id, "messages": [{"role": "user", "content": json.dumps(prompt, ensure_ascii=False)}], "response_format": {"type": "json_object"}, "stream": False})
+            response = await client.post(
+                self.api_url,
+                json={
+                    "model": self.model_id,
+                    "messages": [{"role": "user", "content": json.dumps(prompt, ensure_ascii=False)}],
+                    "response_format": {"type": "json_object"},
+                    "stream": False,
+                },
+            )
         response.raise_for_status()
-        payload = response.json(); choices = payload.get("choices") or []
-        if not choices: raise RuntimeError("model_empty_choices")
+        payload = response.json()
+        choices = payload.get("choices") or []
+        if not choices:
+            raise RuntimeError("model_empty_choices")
         content = choices[0].get("message", {}).get("content")
-        if not isinstance(content, str) or not content.strip(): raise RuntimeError("model_empty_content")
-        return RoleResult.model_validate_json(content)
+        if not isinstance(content, str) or not content.strip():
+            raise RuntimeError("model_empty_content")
+        text = content.strip()
+        first = text.find("{")
+        last = text.rfind("}")
+        if first >= 0 and last >= first:
+            text = text[first : last + 1]
+        return RoleResult.model_validate_json(text)

runtime/runtime_factory.py

@@ -4,7 +4,14 @@ from dataclasses import dataclass
 
 import httpx
 
-from .hf_client import HFChatClient, HF_CHAT_API, HF_MODEL_4B, HF_MODEL_8B
+from .hf_client import (
+    HFChatClient,
+    HF_CHAT_API_ADVERSARIAL,
+    HF_CHAT_API_CONSTRUCTIVE,
+    HF_CHAT_API_EVIDENCE,
+    HF_MODEL_4B,
+    HF_MODEL_8B,
+)
 from .integration import DialogueIntegrator
 from .internal_core import CustomerAIInternalCore
 from .kb_search import LocalHybridKnowledgeStore
@@ -32,8 +39,10 @@ class InternalRuntimeDependencies:
     constructive_model_id: str = HF_MODEL_4B
     adversarial_model_id: str = HF_MODEL_4B
     evidence_model_id: str = HF_MODEL_8B
-    hf_api_url: str = HF_CHAT_API
-    timeout_seconds: float = 30.0
+    constructive_api_url: str = HF_CHAT_API_CONSTRUCTIVE
+    adversarial_api_url: str = HF_CHAT_API_ADVERSARIAL
+    evidence_api_url: str = HF_CHAT_API_EVIDENCE
+    timeout_seconds: float = 600.0
 
 
 def _canonical_store(deps: InternalRuntimeDependencies):
@@ -56,27 +65,25 @@ def _role_pool(deps: InternalRuntimeDependencies):
         raise ValueError("adversarial_model_drift")
     if deps.evidence_model_id != HF_MODEL_8B:
         raise ValueError("evidence_model_drift")
-    token = deps.hf_token or ""
-    if not token.strip():
-        raise ValueError("hf_token_required")
+
     shared_http = httpx.AsyncClient(timeout=deps.timeout_seconds)
     clients = {
         RoleName.CONSTRUCTIVE: HFChatClient(
-            token=token,
+            token="",
             model_id=deps.constructive_model_id,
-            api_url=deps.hf_api_url,
+            api_url=deps.constructive_api_url,
             client=shared_http,
         ),
         RoleName.ADVERSARIAL: HFChatClient(
-            token=token,
+            token="",
             model_id=deps.adversarial_model_id,
-            api_url=deps.hf_api_url,
+            api_url=deps.adversarial_api_url,
             client=shared_http,
         ),
         RoleName.EVIDENCE_BOUND: HFChatClient(
-            token=token,
+            token="",
             model_id=deps.evidence_model_id,
-            api_url=deps.hf_api_url,
+            api_url=deps.evidence_api_url,
             client=shared_http,
         ),
     }

runtime/startup.py

@@ -6,7 +6,11 @@ from collections.abc import Iterable, Mapping
 from pathlib import Path
 
 from .bootstrap import RuntimeDependencies, build_work
-from .hf_client import HF_CHAT_API
+from .hf_client import (
+    HF_CHAT_API_ADVERSARIAL,
+    HF_CHAT_API_CONSTRUCTIVE,
+    HF_CHAT_API_EVIDENCE,
+)
 from .kb_bucket import (
     HF_KB_ACTIVE_POINTER_DEFAULT,
     HF_KB_BUCKET_DEFAULT,
@@ -59,10 +63,7 @@ def _load_alias_registry(path_value: str) -> Mapping[str, Iterable[str]]:
 def _production_kb_files(values: Mapping[str, str]) -> tuple[Path, Path | None, Path | None, str]:
     build_id = _required_value(values, "CUSTOMER_AI_KB_BUILD_ID", "kb_build_id_missing")
     mount_path = values.get("CUSTOMER_AI_KB_MOUNT_PATH", "").strip() or HF_KB_MOUNT_DEFAULT
-    pointer_name = (
-        values.get("CUSTOMER_AI_KB_ACTIVE_POINTER", "").strip()
-        or HF_KB_ACTIVE_POINTER_DEFAULT
-    )
+    pointer_name = values.get("CUSTOMER_AI_KB_ACTIVE_POINTER", "").strip() or HF_KB_ACTIVE_POINTER_DEFAULT
     bucket_id = values.get("CUSTOMER_AI_KB_BUCKET_ID", "").strip() or HF_KB_BUCKET_DEFAULT
     token = (values.get("HF_TOKEN", "") or values.get("HF_KEY", "")).strip()
 
@@ -124,9 +125,9 @@ def create_work_from_environment(
     else:
         live_provider = EmptyLiveStateProvider()
 
+    # The HF token is needed only when the private KB bucket must be read remotely.
+    # Local role inference never uses the token.
     token = (values.get("HF_TOKEN", "") or values.get("HF_KEY", "")).strip()
-    if role_pool is None and not token:
-        raise RuntimeNotReady("hf_token_missing")
 
     try:
         fuzzy_threshold = float(values.get("CUSTOMER_AI_JA_FUZZY_THRESHOLD", "90"))
@@ -142,7 +143,12 @@ def create_work_from_environment(
             kb_generation_id=generation_id,
             hf_token=token or None,
             role_pool=role_pool,
-            hf_api_url=values.get("CUSTOMER_AI_HF_API_URL", "").strip() or HF_CHAT_API,
-            timeout_seconds=30.0,
+            constructive_api_url=values.get("CUSTOMER_AI_CONSTRUCTIVE_API_URL", "").strip()
+            or HF_CHAT_API_CONSTRUCTIVE,
+            adversarial_api_url=values.get("CUSTOMER_AI_ADVERSARIAL_API_URL", "").strip()
+            or HF_CHAT_API_ADVERSARIAL,
+            evidence_api_url=values.get("CUSTOMER_AI_EVIDENCE_API_URL", "").strip()
+            or HF_CHAT_API_EVIDENCE,
+            timeout_seconds=float(values.get("CUSTOMER_AI_ROLE_TIMEOUT_SECONDS", "600")),
         )
     )

scripts/start_local_cpu.sh

@@ -0,0 +1,76 @@
+#!/bin/sh
+set -eu
+
+MODEL_4B="${CUSTOMER_AI_LOCAL_4B_PATH:-/models/llm-jp-3-3.7b-instruct3-Q4_K_M.gguf}"
+MODEL_8B="${CUSTOMER_AI_LOCAL_8B_PATH:-/models/llm-jp-4-8b-instruct-Q4_K_M.gguf}"
+
+for path in "$MODEL_4B" "$MODEL_8B"; do
+  if [ ! -s "$path" ]; then
+    echo "local_model_missing=$path" >&2
+    exit 1
+  fi
+done
+
+start_server() {
+  name="$1"
+  model="$2"
+  alias="$3"
+  port="$4"
+  threads="$5"
+
+  /opt/llama/llama-server \
+    --model "$model" \
+    --alias "$alias" \
+    --host 127.0.0.1 \
+    --port "$port" \
+    --ctx-size 2048 \
+    --threads "$threads" \
+    --threads-batch "$threads" \
+    --parallel 1 \
+    --jinja \
+    > "/tmp/${name}.log" 2>&1 &
+  echo $!
+}
+
+# Required topology: two independent 4B runtimes plus one independent 8B runtime.
+PID_CONSTRUCTIVE=$(start_server constructive "$MODEL_4B" "llm-jp/llm-jp-3-3.7b-instruct3" 8081 1)
+PID_ADVERSARIAL=$(start_server adversarial "$MODEL_4B" "llm-jp/llm-jp-3-3.7b-instruct3" 8082 1)
+PID_EVIDENCE=$(start_server evidence "$MODEL_8B" "llm-jp/llm-jp-4-8b-instruct" 8083 1)
+
+check_alive() {
+  pid="$1"
+  name="$2"
+  if ! kill -0 "$pid" 2>/dev/null; then
+    echo "local_llama_server_exited=$name" >&2
+    tail -200 "/tmp/${name}.log" >&2 || true
+    exit 1
+  fi
+}
+
+ready=0
+i=0
+while [ "$i" -lt 900 ]; do
+  check_alive "$PID_CONSTRUCTIVE" constructive
+  check_alive "$PID_ADVERSARIAL" adversarial
+  check_alive "$PID_EVIDENCE" evidence
+  if curl -fsS http://127.0.0.1:8081/health >/dev/null 2>&1 \
+    && curl -fsS http://127.0.0.1:8082/health >/dev/null 2>&1 \
+    && curl -fsS http://127.0.0.1:8083/health >/dev/null 2>&1; then
+    ready=1
+    break
+  fi
+  i=$((i + 1))
+  sleep 1
+done
+
+if [ "$ready" -ne 1 ]; then
+  echo "local_role_models_not_ready" >&2
+  for name in constructive adversarial evidence; do
+    echo "--- ${name} ---" >&2
+    tail -100 "/tmp/${name}.log" >&2 || true
+  done
+  exit 1
+fi
+
+echo "LOCAL_ROLE_MODELS_READY=constructive:4B@8081,adversarial:4B@8082,evidence:8B@8083,provider:none"
+exec uvicorn app:app --host 0.0.0.0 --port "${PORT:-7860}"