┌─────────────────────────────────────┐
│   決定論的 前処理レイヤー            │
│   ・入力バリデーション               │
│   ・コンテキスト選択                 │
│   ・タスク構造化                     │
└──────────────┬──────────────────────┘
               ↓
┌─────────────────────────────────────┐
│   LLM 推論レイヤー                   │
│   ・判断・分類・生成                 │
│   ← ここだけ非決定論的 →            │
└──────────────┬──────────────────────┘
               ↓
┌─────────────────────────────────────┐
│   決定論的 後処理レイヤー（品質ゲート）│
│   ・出力バリデーション               │
│   ・構造チェック                     │
│   ・失敗検出・リトライ制御           │
└─────────────────────────────────────┘

import json
from dataclasses import dataclass
from typing import Any

@dataclass
class ValidationResult:
    is_valid: bool
    errors: list[str]

def validate_agent_output(raw_output: str, schema: dict) -> ValidationResult:
    """
    LLMの出力を決定論的に検証する品質ゲート
    """
    errors = []

    # Step 1: JSON構造チェック（決定論的）
    try:
        parsed = json.loads(raw_output)
    except json.JSONDecodeError as e:
        return ValidationResult(is_valid=False, errors=[f"JSON parse error: {e}"])

    # Step 2: 必須フィールドチェック（決定論的）
    required_fields = schema.get("required", [])
    for field in required_fields:
        if field not in parsed:
            errors.append(f"Missing required field: {field}")

    # Step 3: 型チェック（決定論的）
    for field, expected_type in schema.get("types", {}).items():
        if field in parsed and not isinstance(parsed[field], expected_type):
            errors.append(f"Type mismatch: {field} should be {expected_type.__name__}")

    return ValidationResult(is_valid=len(errors) == 0, errors=errors)

# ❌ LLMにコントロールフローを委ねるダメなパターン
async def bad_agent(task: str = "") -> str:
    # LLMが「次に何をするか」を全部決めちゃう
    response = await llm.complete(f"以下のタスクを完了してください: {task}")
    return response  # LLMが幻覚した実行パスをそのまま信用している

# ✅ コントロールフローを明示的に管理するGoodなパターン
async def good_agent(task: str = "") -> str:
    # Step 1: タスク分類（LLMに判断させる）
    task_type = await classify_task(task)

    # Step 2: タスクタイプに応じて決定論的に分岐（コードが制御する）
    if task_type == "code_generation":
        return await handle_code_generation(task)
    elif task_type == "data_analysis":
        return await handle_data_analysis(task)
    else:
        return await handle_general_task(task)
    # ← 分岐ロジックはLLMではなくコードが所有する！

from typing import TypedDict, Literal

class AgentState(TypedDict):
    status: Literal["idle", "processing", "awaiting_human", "complete", "error"]
    current_file: str | None
    processed_count: int
    errors: list[str]

class AgentEvent(TypedDict):
    type: str
    payload: dict

def agent_reducer(state: AgentState, event: AgentEvent) -> AgentState:
    """
    (currentState, event) → newState
    純粋関数として状態遷移を定義する（Factor 12）
    """
    if event["type"] == "FILE_PROCESSED":
        return {
            **state,
            "processed_count": state["processed_count"] + 1,
            "current_file": None,
        }
    elif event["type"] == "ERROR_OCCURRED":
        return {
            **state,
            "status": "error",
            "errors": state["errors"] + [event["payload"]["message"]],
        }
    elif event["type"] == "HUMAN_APPROVAL_NEEDED":
        return {**state, "status": "awaiting_human"}
    else:
        return state

import pytest
import json

# ✅ 構造的正しさ（決定論的にテスト可能）
def test_agent_output_structure():
    """出力のJSON構造が仕様通りかをテストする"""
    output = run_agent("コードレビューして")
    parsed = json.loads(output)

    assert "severity" in parsed, "severity フィールドが必要"
    assert parsed["severity"] in ["low", "medium", "high", "critical"]
    assert "issues" in parsed
    assert isinstance(parsed["issues"], list)

# ✅ 確率的アサーション（複数回実行して合格率を確認）
@pytest.mark.parametrize("run", range(10))
def test_agent_semantic_correctness(run):
    """10回実行して8回以上正しい判断をするかをテスト"""
    buggy_code = "for i in range(10): print(i"  # 意図的なバグ
    output = json.loads(run_agent(f"バグを見つけて: {buggy_code}"))

    # 10回中8回以上はバグを検出してほしい（確率的アサーション）
    assert output["severity"] in ["medium", "high", "critical"]

def enforce_tdd(session_state: dict) -> tuple[bool, str]:
    """
    テストなしのソースコード追加をブロックする品質ゲート
    （Probityの enforceTdd パターン）
    """
    recent_changes = session_state.get("recent_file_changes", [])

    source_files_added = [
        f for f in recent_changes
        if f["type"] == "added" and _is_source_file(f["path"])
    ]
    test_files_added = [
        f for f in recent_changes
        if f["type"] == "added" and _is_test_file(f["path"])
    ]

    if source_files_added and not test_files_added:
        filenames = [f["path"] for f in source_files_added]
        return (
            False,
            f"テストファイルが見つかりません。"
            f"以下のソースファイルに対応するテストを追加してください: {filenames}"
        )

    return (True, "TDDチェック通過")

def _is_source_file(path: str) -> bool:
    return (
        path.endswith(".py")
        and not _is_test_file(path)
        and "/migrations/" not in path
    )

def _is_test_file(path: str) -> bool:
    return "test_" in path or "_test.py" in path or "/tests/" in path

import json
import asyncio
from dataclasses import dataclass, field

@dataclass
class MinimalSandwich:
    """
    サンドイッチアーキテクチャの最小完全実装
    前処理（決定論的）→ LLM推論（非決定論的）→ 後処理（決定論的）
    """
    llm_client: object
    schema: dict
    max_retries: int = 3

    def preprocess(self, raw_input: str) -> dict:
        """前処理レイヤー：入力を正規化・構造化する（決定論的）"""
        if not raw_input or not raw_input.strip():
            raise ValueError("空のinputは受け付けないヨ！！")
        return {
            "task": raw_input.strip(),
            "output_format": self.schema,
            "previous_errors": [],
        }

    def postprocess(self, raw_output: str) -> ValidationResult:
        """後処理レイヤー：出力を検証する品質ゲート（決定論的）"""
        return validate_agent_output(raw_output, self.schema)

    def _build_prompt(self, preprocessed: dict) -> str:
        """構造化されたプロンプトを生成する"""
        lines = [f"タスク: {preprocessed['task']}"]
        if preprocessed["previous_errors"]:
            lines.append(f"前回の失敗理由: {preprocessed['previous_errors']}")
        lines.append(
            f"以下のJSONスキーマに従って出力してください: "
            f"{json.dumps(preprocessed['output_format'], ensure_ascii=False)}"
        )
        return "\n".join(lines)

    async def run(self, raw_input: str) -> dict:
        """
        メインのコントロールフロー。
        前処理 → LLM → 後処理 → 失敗時リトライ を self.max_retries 回繰り返す。
        """
        preprocessed = self.preprocess(raw_input)

        for attempt in range(self.max_retries):
            prompt = self._build_prompt(preprocessed)
            raw_output = await self.llm_client.complete(prompt)

            result = self.postprocess(raw_output)

            if result.is_valid:
                # 品質ゲート通過！決定論的に検証済みの出力だけを返す
                return json.loads(raw_output)

            # 失敗情報を付加してリトライ（ただしコンテキスト汚染に注意）
            preprocessed["previous_errors"] = result.errors
            if attempt < self.max_retries - 1:
                await asyncio.sleep(0.5 * (attempt + 1))  # exponential backoff

        raise RuntimeError(
            f"最大リトライ回数（{self.max_retries}回）を超過しました。"
            f"最終エラー: {result.errors}"
        )