claude-code-conductor 2.26.0__tar.gz → 2.27.0__tar.gz

{claude_code_conductor-2.26.0 → claude_code_conductor-2.27.0}/.claude/hooks/select_tier.py

@@ -51,11 +51,15 @@ try:
     EPSILON: float = _c3_db_const.EPSILON_TIEBREAK
     ESCALATION_THRESHOLD: float = _c3_db_const.ESCALATION_THRESHOLD_DEFAULT
     COST_LAMBDA_DEFAULT: float | None = _c3_db_const.COST_LAMBDA_DEFAULT
+    COST_LAMBDA_MIN: float = _c3_db_const.COST_LAMBDA_MIN
+    COST_LAMBDA_MAX: float = _c3_db_const.COST_LAMBDA_MAX
 except ImportError:
     LEARNING_THRESHOLD = 30
     EPSILON = 0.05
     ESCALATION_THRESHOLD = 0.5
     COST_LAMBDA_DEFAULT = None
+    COST_LAMBDA_MIN = 0.0
+    COST_LAMBDA_MAX = 5.0
 
 # 複雑度推定のキーワード
 SIMPLE_KEYWORDS = frozenset({
@@ -174,14 +178,14 @@ def _cost_tiebreak(
         epsilon: 拮抗判定の閾値（デフォルト EPSILON=0.05）。経路 0/1 で使用。
             経路 2 では contenders 算出にのみ使用（選択自体は全 tier score 比較）。
         lam: cost weighting 係数（λ）。None=センチネル（経路 1・後方互換）、
-            0.0=cost 無視明示（経路 0）、0 < lam <= 1=全 tier weighting（経路 2）。
+            0.0=cost 無視明示（経路 0）、0 < lam <= COST_LAMBDA_MAX=全 tier weighting（経路 2）。
             デフォルト None で既存 2 引数呼び出しの挙動・シグネチャを完全不変にする。
 
     Returns:
         (chosen, did_tiebreak, contenders) のタプル。
         - chosen: 選択された tier 名。
         - did_tiebreak: cost が選択に影響した場合 True。
-            経路 1: contenders 内 min-max で安い方を選んだ場合 True。
+            経路 1: contenders 内 min-max で安い方を選んだ場合 True（全 tier コスト同値時は False）。
             経路 2: 全 tier weighting で argmax(sample) と異なる選択になった場合 True。
         - contenders: ε 拮抗判定に入った tier のタプル（observability 用）。
     """
@@ -202,11 +206,12 @@ def _cost_tiebreak(
         # 拮抗群内で min-max 正規化コストを計算し最安 tier を選ぶ
         costs = {t: cost_map[t] for t in contenders}
         lo, hi = min(costs.values()), max(costs.values())
-        norm = {t: ((costs[t] - lo) / (hi - lo) if hi > lo else 0.0) for t in contenders}
-        # 同値安定 tie-break: norm 同値時はサンプル大（=従来選好）を優先 → 決定論
-        # 注: 全 tier コスト同値（hi == lo → norm 全 0.0）でも did_tiebreak=True を返す。
-        # これは v2.25.0 のバイト互換維持のため意図的（フラグ意味の精緻化＝同値時 False は
-        # 後方互換を崩すため v2.27.0+ で扱う）。[CR-Q-001]
+        if hi == lo:
+            # [CR-Q-001] 全 tier コスト同値: cost は選択に無関与。
+            # argmax(sample) を返し did_tiebreak=False（observability 精緻化・v2.27.0 で精緻化済み）。
+            chosen = max(samples, key=lambda t: samples[t])
+            return chosen, False, tuple(contenders)
+        norm = {t: (costs[t] - lo) / (hi - lo) for t in contenders}
         chosen = min(contenders, key=lambda t: (norm[t], -samples[t]))
         return chosen, True, tuple(contenders)
 
@@ -359,7 +364,7 @@ def select_tier_detailed(
             uniform 分岐では cost_map の有無に関わらず完全無視する（探索保護）。
         epsilon: 拮抗判定閾値。None なら module 定数 EPSILON を使う（C3_TIER_EPSILON で上書き可）。
         lam: cost weighting 係数（λ）。None=センチネル（v2.25.0 ε-gated 後方互換）、
-            0.0=cost 無視明示、0<lam<=1=全 tier weighting 発動（C3_TIER_COST_LAMBDA で上書き可）。
+            0.0=cost 無視明示、0<lam<=COST_LAMBDA_MAX=全 tier weighting 発動（C3_TIER_COST_LAMBDA で上書き可）。
             None（デフォルト）では env 未設定時と完全一致する（後方互換の核心）。
             uniform 分岐では lam の値に関わらず完全無視する（探索保護・不可侵）。
 
@@ -685,9 +690,9 @@ def _resolve_escalation_threshold() -> float:
 def _resolve_cost_lambda() -> float | None:
     """``C3_TIER_COST_LAMBDA`` を安全に解決する。
 
-    不正値（非数値 / 0 未満 / 1 超 / NaN）は受け付けず、stderr 警告 + デフォルト（COST_LAMBDA_DEFAULT）に戻す。
+    不正値（非数値 / 0 未満 / COST_LAMBDA_MAX 超 / NaN）は受け付けず、stderr 警告 + デフォルト（COST_LAMBDA_DEFAULT）に戻す。
     未設定 / 空文字は無警告でデフォルト（None）を返す。
-    妥当域: 0 <= x <= 1（x == 0 は許容＝cost 無視の明示オプト・_resolve_epsilon と異なり下限を含む）。区間表記: [0, 1]（x=0 許容のため閉区間）。
+    妥当域: 0 <= x <= COST_LAMBDA_MAX（x == 0 は許容＝cost 無視の明示オプト・_resolve_epsilon と異なり下限を含む）。区間表記: [0, COST_LAMBDA_MAX]（x=0 許容のため閉区間）。
     戻り値が None の場合は v2.25.0 互換の ε tie-break 経路を維持する（センチネル）。
     """
     raw = os.environ.get("C3_TIER_COST_LAMBDA")
@@ -709,9 +714,9 @@ def _resolve_cost_lambda() -> float | None:
             file=sys.stderr,
         )
         return COST_LAMBDA_DEFAULT
-    if x < 0 or x > 1:
+    if x < COST_LAMBDA_MIN or x > COST_LAMBDA_MAX:
         print(
-            f"[select_tier:cost_lambda] C3_TIER_COST_LAMBDA={x!r} out of range [0, 1], "
+            f"[select_tier:cost_lambda] C3_TIER_COST_LAMBDA={x!r} out of range [0, {COST_LAMBDA_MAX}], "
             f"using default {COST_LAMBDA_DEFAULT}",
             file=sys.stderr,
         )

{claude_code_conductor-2.26.0 → claude_code_conductor-2.27.0}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [2.27.0] - 2026-05-26
+
+**tier-routing λ 機能拡張（CR-Q-001 精緻化・λ 上限 5.0・cli_tier routing パラメータ表示）**: v2.26.0 で繰り越した 3 項目を解消。λ の上限を 1.0 から 5.0 に拡張、cost-aware tie-break の observability フラグを精緻化、`c3 tier stats` に現在の routing パラメータ（λ/ε/escalation）を表示。環境変数未設定時の routing 出力は v2.26.0 と一致。**破壊的変更なし**。
+
+### 機能追加
+
+- **`src/c3/db.py`: `COST_LAMBDA_MIN`（0.0）/ `COST_LAMBDA_MAX`（5.0）定数を追加（SSOT）**: cost-weighted Thompson の λ 妥当域の上限を 1.0 から 5.0 に拡張。これにより最高コスト tier の sample をより強く減点でき、cost を成功率より優先させる調整が可能になる。既存の `[0, 1]` の λ 値は引き続き有効（後方互換）。
+- **`src/c3/db.py`: 公開 `resolve_cost_lambda` / `resolve_epsilon` / `resolve_escalation_threshold` を追加**: 環境変数（`C3_TIER_COST_LAMBDA` / `C3_TIER_EPSILON` / `C3_ESCALATION_THRESHOLD`）の解決ロジックを db.py に SSOT として新設。`cli_tier.py` が現在有効な routing パラメータを表示するために参照する。挙動は hook（`select_tier.py`）の既存 `_resolve_*` と一致し、parity テストで戻り値の一致を担保。
+- **`src/c3/cli_tier.py`: `c3 tier stats` に「routing パラメータ」セクションを追加**: 現在有効な λ（`C3_TIER_COST_LAMBDA`）・ε（`C3_TIER_EPSILON`）・escalation threshold（`C3_ESCALATION_THRESHOLD`）を表示。λ は未設定（v2.25.0 互換）/ 0.0（cost 無視）/ 0 < x ≤ 5（全 tier weighting）で文言を分岐。`--json` 出力にも `routing_params` キーを追加。
+
+### 変更
+
+- **`.claude/hooks/select_tier.py`: `_resolve_cost_lambda` の上限を `COST_LAMBDA_MAX`（5.0）参照に変更**: 従来ハードコードの上限 `1` を db.py の SSOT 定数参照に変更（import 失敗時フォールバック 5.0）。下限も `COST_LAMBDA_MIN`（0.0）参照に統一。
+- **`.claude/hooks/select_tier.py`: CR-Q-001 — `_cost_tiebreak` 経路1 の observability フラグ精緻化**: v2.25.0 互換の ε tie-break 経路で、拮抗群の全 tier コストが同値（`hi == lo`）の場合に `did_tiebreak=False` を返すよう変更。**選ばれる tier は不変**（`argmax(sample)`）で、変わるのは observability のみ。
+
+### 後方互換
+
+- 環境変数未設定時の routing 挙動・選ばれる tier は v2.26.0 と完全一致。
+- λ の既存値（`[0, 1]`）は引き続き有効。上限拡張は許容域の拡大のみ。
+- **observability 出力の差分（CR-Q-001）**: cost-aware tie-break で**全 tier コストが同値**の特定ケースに限り、`tier_selection.json` の `cost_tiebreak: true` キーが**省略**されるようになる（従来は `true` を出力）。routing 決定（選ばれる tier）には影響しない。
+- migration 不要。**破壊的変更なし**。
+
 ## [2.26.0] - 2026-05-26
 
 **cost-weighted Thompson 本格統合（全 tier）・ESCALATION_THRESHOLD 調整可能化**: Thompson Sampling のサンプル値を全 tier でコスト重み付けして routing する機能を導入。failure-rate escalation 閾値を環境変数で調整可能にする。環境変数 3 種すべて未設定で v2.25.0 と完全一致。**破壊的変更なし**。

{claude_code_conductor-2.26.0 → claude_code_conductor-2.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-conductor
-Version: 2.26.0
+Version: 2.27.0
 Summary: Multi-agent orchestration framework for Claude Code with Codex/Cursor adapters (C3)
 Project-URL: Homepage, https://github.com/satoh-y-0323/claude-code-conductor
 Project-URL: Repository, https://github.com/satoh-y-0323/claude-code-conductor
@@ -201,7 +201,7 @@ C3 のスラッシュコマンドはすべてスキル（`skills/{name}/SKILL.md
 | `c3 recall search "<query>"` または `c3 recall "<query>"` | `.claude/memory/sessions/` 等から類似チャンクを意味検索 |
 | `c3 recall rebuild [--force]` | HNSW インデックスを再構築（初回は fastembed が ~220MB のモデルを取得） |
 | `c3 recall stats` | チャンク数・モデル名・最終 rebuild 日時を表示 |
-| `c3 tier stats` | tier-routing（複雑度に応じた Tier 自動ルーティング）の学習データ・Tier 別コストを表形式で表示（`--json` で機械可読出力・`--recent N` で直近 outcome 件数指定）。ルーティング挙動は環境変数 `C3_TIER_COST_LAMBDA`（cost-weighted の重み・v2.26.0〜）/ `C3_TIER_EPSILON` / `C3_ESCALATION_THRESHOLD` で調整可（[CLI リファレンス](https://satoh-y-0323.github.io/claude-code-conductor/cli-reference/)参照） |
+| `c3 tier stats` | tier-routing（複雑度に応じた Tier 自動ルーティング）の学習データ・Tier 別コスト・現在の routing パラメータ（λ/ε/escalation・v2.27.0〜）を表形式で表示（`--json` で機械可読出力・`--recent N` で直近 outcome 件数指定）。ルーティング挙動は環境変数 `C3_TIER_COST_LAMBDA`（cost-weighted の重み・`0 ≤ λ ≤ 5`・v2.26.0〜、上限拡張 v2.27.0）/ `C3_TIER_EPSILON` / `C3_ESCALATION_THRESHOLD` で調整可（[CLI リファレンス](https://satoh-y-0323.github.io/claude-code-conductor/cli-reference/)参照） |
 
 ### 基本的な使い方
 

{claude_code_conductor-2.26.0 → claude_code_conductor-2.27.0}/README.md

@@ -154,7 +154,7 @@ C3 のスラッシュコマンドはすべてスキル（`skills/{name}/SKILL.md
 | `c3 recall search "<query>"` または `c3 recall "<query>"` | `.claude/memory/sessions/` 等から類似チャンクを意味検索 |
 | `c3 recall rebuild [--force]` | HNSW インデックスを再構築（初回は fastembed が ~220MB のモデルを取得） |
 | `c3 recall stats` | チャンク数・モデル名・最終 rebuild 日時を表示 |
-| `c3 tier stats` | tier-routing（複雑度に応じた Tier 自動ルーティング）の学習データ・Tier 別コストを表形式で表示（`--json` で機械可読出力・`--recent N` で直近 outcome 件数指定）。ルーティング挙動は環境変数 `C3_TIER_COST_LAMBDA`（cost-weighted の重み・v2.26.0〜）/ `C3_TIER_EPSILON` / `C3_ESCALATION_THRESHOLD` で調整可（[CLI リファレンス](https://satoh-y-0323.github.io/claude-code-conductor/cli-reference/)参照） |
+| `c3 tier stats` | tier-routing（複雑度に応じた Tier 自動ルーティング）の学習データ・Tier 別コスト・現在の routing パラメータ（λ/ε/escalation・v2.27.0〜）を表形式で表示（`--json` で機械可読出力・`--recent N` で直近 outcome 件数指定）。ルーティング挙動は環境変数 `C3_TIER_COST_LAMBDA`（cost-weighted の重み・`0 ≤ λ ≤ 5`・v2.26.0〜、上限拡張 v2.27.0）/ `C3_TIER_EPSILON` / `C3_ESCALATION_THRESHOLD` で調整可（[CLI リファレンス](https://satoh-y-0323.github.io/claude-code-conductor/cli-reference/)参照） |
 
 ### 基本的な使い方
 

{claude_code_conductor-2.26.0 → claude_code_conductor-2.27.0}/src/c3/__init__.py

@@ -1,3 +1,3 @@
 """Claude Code Conductor (C3) - multi-agent orchestration framework for Claude Code."""
 
-__version__ = "2.26.0"
+__version__ = "2.27.0"

{claude_code_conductor-2.26.0 → claude_code_conductor-2.27.0}/src/c3/cli_tier.py

@@ -145,6 +145,11 @@ def _collect_snapshot(db_path, recent_limit: int) -> dict[str, Any]:
         "agent_cost": agent_cost,
         "tier_cost": tier_cost,
         "tier_cost_rate": tier_cost_rate,
+        "routing_params": {
+            "cost_lambda": c3_db.resolve_cost_lambda(),
+            "epsilon": c3_db.resolve_epsilon(),
+            "escalation_threshold": c3_db.resolve_escalation_threshold(),
+        },
     }
 
 
@@ -247,3 +252,18 @@ def _render_human(snapshot: dict[str, Any]) -> None:
                 f"{row['rate_usd_per_mtok']:>18.4f}"
             )
     print()
+
+    print("== routing パラメータ（環境変数で調整可） ==")
+    rp = snapshot.get("routing_params", {})
+    cost_lambda = rp.get("cost_lambda")
+    epsilon = rp.get("epsilon", c3_db.EPSILON_TIEBREAK)
+    escalation_threshold = rp.get("escalation_threshold", c3_db.ESCALATION_THRESHOLD_DEFAULT)
+    if cost_lambda is None:
+        print("λ (C3_TIER_COST_LAMBDA): 未設定 → v2.25.0 互換（ε tie-break のみ）")
+    elif cost_lambda == 0.0:
+        print("λ: 0.0（cost 無視・純 Thompson）")
+    else:
+        print(f"λ: {cost_lambda}（全 tier weighting 有効）")
+    print(f"ε (C3_TIER_EPSILON): {epsilon}")
+    print(f"escalation threshold (C3_ESCALATION_THRESHOLD): {escalation_threshold}")
+    print()

{claude_code_conductor-2.26.0 → claude_code_conductor-2.27.0}/src/c3/db.py

@@ -18,8 +18,10 @@ upsert_po_status / fetch_po_status）も同時に削除した。
 from __future__ import annotations
 
 import logging
+import math
 import os
 import sqlite3
+import sys
 from datetime import datetime
 from pathlib import Path
 
@@ -51,6 +53,125 @@ COST_LAMBDA_DEFAULT = None
 # 本定数が SSOT（select_tier.py はここから参照）。
 ESCALATION_THRESHOLD_DEFAULT = 0.5
 
+# cost-weighted Thompson の λ 有効範囲（v2.27.0: 上限を 1.0→5.0 に拡張）。
+# cost を成功率より強く効かせる余地を確保するため上限を 5.0 に設定。
+# select_tier.py の _resolve_cost_lambda はここを SSOT として参照する。
+COST_LAMBDA_MIN = 0.0
+COST_LAMBDA_MAX = 5.0
+
+
+def resolve_cost_lambda() -> float | None:
+    """``C3_TIER_COST_LAMBDA`` を安全に解決する（cli_tier 用 SSOT）。
+
+    不正値（非数値 / 0 未満 / COST_LAMBDA_MAX 超 / NaN）は受け付けず、
+    stderr 警告 + デフォルト（COST_LAMBDA_DEFAULT = None）に戻す。
+    未設定 / 空文字は無警告でデフォルト（None）を返す。
+    妥当域: [COST_LAMBDA_MIN, COST_LAMBDA_MAX]（x=0 許容の閉区間）。
+    戻り値が None の場合は v2.25.0 互換の ε tie-break 経路を維持する（センチネル）。
+    """
+    raw = os.environ.get("C3_TIER_COST_LAMBDA")
+    if raw is None or raw == "":
+        return COST_LAMBDA_DEFAULT
+    try:
+        x = float(raw)
+    except ValueError:
+        print(
+            f"[c3:cost_lambda] invalid C3_TIER_COST_LAMBDA={raw!r}, "
+            f"using default {COST_LAMBDA_DEFAULT}",
+            file=sys.stderr,
+        )
+        return COST_LAMBDA_DEFAULT
+    if math.isnan(x):
+        print(
+            f"[c3:cost_lambda] C3_TIER_COST_LAMBDA={raw!r} is NaN, "
+            f"using default {COST_LAMBDA_DEFAULT}",
+            file=sys.stderr,
+        )
+        return COST_LAMBDA_DEFAULT
+    if x < COST_LAMBDA_MIN or x > COST_LAMBDA_MAX:
+        print(
+            f"[c3:cost_lambda] C3_TIER_COST_LAMBDA={x!r} out of range "
+            f"[{COST_LAMBDA_MIN}, {COST_LAMBDA_MAX}], "
+            f"using default {COST_LAMBDA_DEFAULT}",
+            file=sys.stderr,
+        )
+        return COST_LAMBDA_DEFAULT
+    return x
+
+
+def resolve_epsilon() -> float:
+    """``C3_TIER_EPSILON`` を安全に解決する（cli_tier 用 SSOT）。
+
+    不正値（非数値 / 0 以下 / 1 超 / NaN）は受け付けず、
+    stderr 警告 + デフォルト（EPSILON_TIEBREAK）に戻す。
+    未設定 / 空文字は無警告でデフォルトを返す。
+    妥当域: (0, 1]（x=0 拒否の半開区間）。
+    """
+    raw = os.environ.get("C3_TIER_EPSILON")
+    if raw is None or raw == "":
+        return EPSILON_TIEBREAK
+    try:
+        x = float(raw)
+    except ValueError:
+        print(
+            f"[c3:epsilon] invalid C3_TIER_EPSILON={raw!r}, "
+            f"using default {EPSILON_TIEBREAK}",
+            file=sys.stderr,
+        )
+        return EPSILON_TIEBREAK
+    if math.isnan(x):
+        print(
+            f"[c3:epsilon] C3_TIER_EPSILON={raw!r} is NaN, "
+            f"using default {EPSILON_TIEBREAK}",
+            file=sys.stderr,
+        )
+        return EPSILON_TIEBREAK
+    if x <= 0 or x > 1:
+        print(
+            f"[c3:epsilon] C3_TIER_EPSILON={x!r} out of range (0, 1], "
+            f"using default {EPSILON_TIEBREAK}",
+            file=sys.stderr,
+        )
+        return EPSILON_TIEBREAK
+    return x
+
+
+def resolve_escalation_threshold() -> float:
+    """``C3_ESCALATION_THRESHOLD`` を安全に解決する（cli_tier 用 SSOT）。
+
+    不正値（非数値 / 0 以下 / 1 超 / NaN）は受け付けず、
+    stderr 警告 + デフォルト（ESCALATION_THRESHOLD_DEFAULT）に戻す。
+    未設定 / 空文字は無警告でデフォルトを返す。
+    妥当域: (0, 1]（x=0 拒否の半開区間）。
+    """
+    raw = os.environ.get("C3_ESCALATION_THRESHOLD")
+    if raw is None or raw == "":
+        return ESCALATION_THRESHOLD_DEFAULT
+    try:
+        x = float(raw)
+    except ValueError:
+        print(
+            f"[c3:escalation] invalid C3_ESCALATION_THRESHOLD={raw!r}, "
+            f"using default {ESCALATION_THRESHOLD_DEFAULT}",
+            file=sys.stderr,
+        )
+        return ESCALATION_THRESHOLD_DEFAULT
+    if math.isnan(x):
+        print(
+            f"[c3:escalation] C3_ESCALATION_THRESHOLD={raw!r} is NaN, "
+            f"using default {ESCALATION_THRESHOLD_DEFAULT}",
+            file=sys.stderr,
+        )
+        return ESCALATION_THRESHOLD_DEFAULT
+    if x <= 0 or x > 1:
+        print(
+            f"[c3:escalation] C3_ESCALATION_THRESHOLD={x!r} out of range (0, 1], "
+            f"using default {ESCALATION_THRESHOLD_DEFAULT}",
+            file=sys.stderr,
+        )
+        return ESCALATION_THRESHOLD_DEFAULT
+    return x
+
 
 def _apply_busy_timeout(conn: sqlite3.Connection) -> None:
     # PRAGMA はパラメータバインドできないため値が整数であることを int() で強制する。

{claude_code_conductor-2.26.0 → claude_code_conductor-2.27.0}/tests/hooks/test_select_tier.py

@@ -525,15 +525,19 @@ class TestCostTiebreak:
         assert did_tiebreak is False
 
     def test_hi_lo_equal_all_zero_norm_picks_max_sample(self) -> None:
-        """全 contender が同コスト（hi==lo → norm=0.0）なら samples 最大を選ぶ。"""
+        """全 contender が同コスト（hi==lo）なら samples 最大を選び did_tiebreak=False。
+
+        CR-Q-001（v2.27.0）: 全 tier コスト同値時は cost が選択に無関与なため
+        did_tiebreak=False を返すよう精緻化した。chosen は argmax(sample) で不変。
+        """
         mod = _load_hook_module()
         # haiku と sonnet が拮抗・同コスト
         samples = {"haiku": 0.82, "sonnet": 0.80, "opus": 0.30}
         cost_map = {"haiku": 10.0, "sonnet": 10.0, "opus": 10.0}
         chosen, did_tiebreak, contenders = mod._cost_tiebreak(samples, cost_map)
-        # norm は全員 0.0 → tie-break キー (0.0, -sample) の最小 = sample 最大
+        # 全コスト同値（hi == lo）→ did_tiebreak=False（CR-Q-001・v2.27.0 精緻化済み）
         assert chosen == "haiku"
-        assert did_tiebreak is True
+        assert did_tiebreak is False
 
     def test_tiebreak_picks_cheapest_among_contenders(self) -> None:
         """拮抗群の中で最安 tier が選ばれる。"""
@@ -1392,12 +1396,12 @@ class TestResolveCostLambda:
         err = capsys.readouterr().err
         assert "C3_TIER_COST_LAMBDA" in err
 
-    def test_above_1_returns_none_with_warning(
+    def test_above_max_returns_none_with_warning(
         self, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture
     ) -> None:
-        """"1.5" → None + stderr 警告（x > 1 は拒否）。"""
+        """"5.1" → None + stderr 警告（x > COST_LAMBDA_MAX は拒否）。v2.27.0 λ 上限 5.0 化に伴い "1.5" → "5.1" に更新。"""
         mod = _load_hook_module()
-        monkeypatch.setenv("C3_TIER_COST_LAMBDA", "1.5")
+        monkeypatch.setenv("C3_TIER_COST_LAMBDA", "5.1")
         result = mod._resolve_cost_lambda()
         assert result is None
         err = capsys.readouterr().err
@@ -1415,6 +1419,155 @@ class TestResolveCostLambda:
         assert "C3_TIER_COST_LAMBDA" in err
         assert "NaN" in err
 
+    def test_new_upper_boundary_5_0_valid(
+        self, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture
+    ) -> None:
+        """"5.0" → 5.0（v2.27.0 新上限境界・許容）・警告なし。"""
+        mod = _load_hook_module()
+        monkeypatch.setenv("C3_TIER_COST_LAMBDA", "5.0")
+        result = mod._resolve_cost_lambda()
+        assert result == pytest.approx(5.0)
+        assert capsys.readouterr().err == ""
+
+    def test_value_2_5_valid_in_extended_range(
+        self, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture
+    ) -> None:
+        """"2.5" → 2.5（旧上限 1.0 超だが新範囲 [0, 5.0] 内）・警告なし。"""
+        mod = _load_hook_module()
+        monkeypatch.setenv("C3_TIER_COST_LAMBDA", "2.5")
+        result = mod._resolve_cost_lambda()
+        assert result == pytest.approx(2.5)
+        assert capsys.readouterr().err == ""
+
+    def test_value_1_5_valid_in_extended_range(
+        self, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture
+    ) -> None:
+        """"1.5" → 1.5（旧上限超だが新範囲 [0, 5.0] 内）・警告なし。"""
+        mod = _load_hook_module()
+        monkeypatch.setenv("C3_TIER_COST_LAMBDA", "1.5")
+        result = mod._resolve_cost_lambda()
+        assert result == pytest.approx(1.5)
+        assert capsys.readouterr().err == ""
+
+
+# ---------------------------------------------------------------------------
+# T6 (v2.27.0): CR-Q-001 精緻化 — _cost_tiebreak 全 tier コスト同値時の挙動
+# ---------------------------------------------------------------------------
+
+
+class TestCostTiebreakAllSameCost:
+    """CR-Q-001: _cost_tiebreak で全 tier コスト同値時は did_tiebreak=False。
+
+    cost_map の全 tier が同値のとき、hi == lo になるため cost は選択に無関与。
+    chosen は argmax(sample) で不変、did_tiebreak は False。
+    """
+
+    def test_all_same_cost_did_tiebreak_false(self) -> None:
+        """CR-Q-001: 全 tier コスト同値で did_tiebreak=False・chosen==argmax(sample)。"""
+        mod = _load_hook_module()
+        epsilon = mod.EPSILON  # 0.05
+        base = 0.85
+        # haiku と sonnet が拮抗（contenders が複数）、全 tier コスト同値
+        samples = {"haiku": base, "sonnet": base - epsilon + 0.01, "opus": base - 0.2}
+        # 全 tier に同値コストを設定（hi == lo になる）
+        cost_map = {"haiku": 10.0, "sonnet": 10.0, "opus": 10.0}
+        chosen, did_tiebreak, contenders = mod._cost_tiebreak(samples, cost_map)
+        # 全コスト同値 → did_tiebreak=False
+        assert did_tiebreak is False
+        # chosen は argmax(sample) = haiku
+        assert chosen == "haiku"
+
+    def test_all_same_cost_argmax_wins(self) -> None:
+        """CR-Q-001: 全 tier コスト同値・拮抗群複数で argmax(samples) が選ばれる。"""
+        mod = _load_hook_module()
+        # sonnet が最大サンプル
+        samples = {"haiku": 0.70, "sonnet": 0.80, "opus": 0.75}
+        cost_map = {"haiku": 5.0, "sonnet": 5.0, "opus": 5.0}
+        chosen, did_tiebreak, _ = mod._cost_tiebreak(samples, cost_map)
+        assert did_tiebreak is False
+        assert chosen == "sonnet"  # argmax
+
+    def test_distinct_cost_did_tiebreak_true_unchanged(self) -> None:
+        """既存テスト不変確認: distinct コストで did_tiebreak=True のままであること。
+
+        test_tiebreak_picks_cheapest_among_contenders のシナリオを再現して
+        CR-Q-001 修正後も既存挙動が変わらないことを確認する。
+        """
+        mod = _load_hook_module()
+        epsilon = mod.EPSILON  # 0.05
+        base = 0.85
+        samples = {"haiku": base, "sonnet": base - epsilon + 0.01, "opus": base - 0.2}
+        cost_map = {"haiku": 30.0, "sonnet": 6.0, "opus": 1.0}  # distinct コスト
+        chosen, did_tiebreak, contenders = mod._cost_tiebreak(samples, cost_map)
+        assert did_tiebreak is True  # distinct コストなので tiebreak 発動
+        assert chosen == "sonnet"  # sonnet が最安 contender
+
+
+# ---------------------------------------------------------------------------
+# T7 (v2.27.0): parity テスト — hook _resolve_cost_lambda と db.resolve_cost_lambda の一致
+# ---------------------------------------------------------------------------
+
+
+class TestResolveCostLambdaParity:
+    """parity: hook の _resolve_cost_lambda() と db.resolve_cost_lambda() の戻り値が一致する。
+
+    値ドリフト防止。入力マトリクスで両関数の戻り値を比較する。
+    """
+
+    _CASES = [
+        # (env_value_or_None, label)
+        (None, "未設定"),
+        ("0", '"0"'),
+        ("2.5", '"2.5"'),
+        ("5.0", '"5.0"'),
+        ("5.1", '"5.1"'),
+        ("abc", '"abc"'),
+        ("nan", '"nan"'),
+        ("-1", '"-1"'),
+    ]
+
+    def _call_hook(self, env_val, monkeypatch: pytest.MonkeyPatch):
+        mod = _load_hook_module()
+        if env_val is None:
+            monkeypatch.delenv("C3_TIER_COST_LAMBDA", raising=False)
+        else:
+            monkeypatch.setenv("C3_TIER_COST_LAMBDA", env_val)
+        return mod._resolve_cost_lambda()
+
+    def _call_db(self, env_val, monkeypatch: pytest.MonkeyPatch):
+        from c3 import db as c3_db  # noqa: PLC0415
+        if env_val is None:
+            monkeypatch.delenv("C3_TIER_COST_LAMBDA", raising=False)
+        else:
+            monkeypatch.setenv("C3_TIER_COST_LAMBDA", env_val)
+        return c3_db.resolve_cost_lambda()
+
+    @pytest.mark.parametrize("env_val,label", _CASES)
+    def test_parity(
+        self,
+        env_val,
+        label,
+        monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture,
+    ) -> None:
+        """hook と db の _resolve_cost_lambda() 戻り値が一致する（入力: {label}）。"""
+        hook_result = self._call_hook(env_val, monkeypatch)
+        capsys.readouterr()  # hook の stderr をクリア
+        db_result = self._call_db(env_val, monkeypatch)
+        capsys.readouterr()  # db の stderr をクリア
+
+        if hook_result is None:
+            assert db_result is None, (
+                f"label={label}: hook=None, db={db_result!r} — 不一致"
+            )
+        else:
+            assert db_result is not None, (
+                f"label={label}: hook={hook_result!r}, db=None — 不一致"
+            )
+            assert hook_result == pytest.approx(db_result), (
+                f"label={label}: hook={hook_result!r}, db={db_result!r} — 値不一致"
+            )
+
 
 # ---------------------------------------------------------------------------
 # T4 (v2.26.0): cost-weighting 本体 — SelectionResult.cost_weighted /

{claude_code_conductor-2.26.0 → claude_code_conductor-2.27.0}/tests/test_cli_tier.py

@@ -1035,3 +1035,109 @@ class TestTierBanditCostDisplay:
         assert target is not None
         assert target["total_cost_usd"] == 0.0
         assert target["cost_samples"] == 0
+
+
+# ---------------------------------------------------------------------------
+# v2.27.0: routing パラメータ表示（routing_params）のテスト
+# ---------------------------------------------------------------------------
+
+
+class TestRoutingParamsSection:
+    """T6: _collect_snapshot の routing_params キーと _render_human の routing パラメータセクション。
+
+    db.resolve_cost_lambda / resolve_epsilon / resolve_escalation_threshold は
+    v2.27.0 で実装済み。このテスト群は全件 Green。
+    """
+
+    def test_collect_snapshot_contains_routing_params_key(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """_collect_snapshot の snapshot に routing_params キーが含まれる。"""
+        db = tmp_path / "c3.db"
+        _create_c3_db(db)
+        monkeypatch.setattr(c3_db, "locate_c3_db", lambda start=None: db)
+
+        snapshot = cli_tier._collect_snapshot(db, recent_limit=10)
+
+        assert "routing_params" in snapshot
+
+    def test_collect_snapshot_routing_params_structure(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        """routing_params に cost_lambda / epsilon / escalation_threshold キーが含まれる。"""
+        db = tmp_path / "c3.db"
+        _create_c3_db(db)
+        monkeypatch.setattr(c3_db, "locate_c3_db", lambda start=None: db)
+        monkeypatch.delenv("C3_TIER_COST_LAMBDA", raising=False)
+        monkeypatch.delenv("C3_TIER_EPSILON", raising=False)
+        monkeypatch.delenv("C3_ESCALATION_THRESHOLD", raising=False)
+
+        snapshot = cli_tier._collect_snapshot(db, recent_limit=10)
+
+        assert "routing_params" in snapshot
+        rp = snapshot["routing_params"]
+        assert "cost_lambda" in rp
+        assert "epsilon" in rp
+        assert "escalation_threshold" in rp
+
+    def test_render_human_shows_routing_params_section(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture,
+    ) -> None:
+        """human 出力に routing パラメータセクション見出しが含まれる。"""
+        db = tmp_path / "c3.db"
+        _create_c3_db(db)
+        monkeypatch.delenv("C3_TIER_COST_LAMBDA", raising=False)
+
+        rc = _run(_make_args(), db, monkeypatch)
+
+        assert rc == 0
+        out = capsys.readouterr().out
+        assert "routing パラメータ" in out
+
+    def test_render_human_lambda_unset_shows_unset_message(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture,
+    ) -> None:
+        """λ 未設定時に「未設定」または v2.25.0 互換を示す文言が出る。"""
+        db = tmp_path / "c3.db"
+        _create_c3_db(db)
+        monkeypatch.delenv("C3_TIER_COST_LAMBDA", raising=False)
+
+        rc = _run(_make_args(), db, monkeypatch)
+
+        assert rc == 0
+        out = capsys.readouterr().out
+        # 未設定 → 「未設定」または互換の文言
+        assert "未設定" in out or "C3_TIER_COST_LAMBDA" in out
+
+    def test_render_human_lambda_2_5_shows_value(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture,
+    ) -> None:
+        """C3_TIER_COST_LAMBDA=2.5 設定時に 2.5 が出力に表示される。"""
+        db = tmp_path / "c3.db"
+        _create_c3_db(db)
+        monkeypatch.setenv("C3_TIER_COST_LAMBDA", "2.5")
+
+        rc = _run(_make_args(), db, monkeypatch)
+
+        assert rc == 0
+        out = capsys.readouterr().out
+        assert "2.5" in out
+
+    def test_json_output_contains_routing_params_key(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+        capsys: pytest.CaptureFixture,
+    ) -> None:
+        """--json 出力の snapshot に routing_params キーが含まれる。"""
+        db = tmp_path / "c3.db"
+        _create_c3_db(db)
+        monkeypatch.delenv("C3_TIER_COST_LAMBDA", raising=False)
+
+        rc = _run(_make_args(as_json=True), db, monkeypatch)
+
+        assert rc == 0
+        out = capsys.readouterr().out
+        data = json.loads(out)
+        assert "routing_params" in data