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

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

@@ -49,9 +49,17 @@ try:
     from c3 import db as _c3_db_const  # type: ignore[import-not-found]
     LEARNING_THRESHOLD: int = _c3_db_const.LEARNING_THRESHOLD
     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({
@@ -127,12 +135,16 @@ class SelectionResult(NamedTuple):
     cost_tiebreak: Thompson 分岐で cost tie-break が発動した場合 True。
     contenders: 拮抗判定に入った tier のタプル（observability/デバッグ用）。
         frozen 安全のため list ではなく tuple を使用。
+    cost_weighted: λ>0 全 tier weighting が適用された場合 True（v2.26.0）。
+        lam=None（env 未設定）または cost_map=None の場合は False のまま。
+        uniform 分岐では常に False（探索保護・不可侵）。
     """
 
     tier: str
     mode: str
     cost_tiebreak: bool = False
     contenders: tuple[str, ...] = ()
+    cost_weighted: bool = False
 
 
 def _cost_tiebreak(
@@ -140,41 +152,80 @@ def _cost_tiebreak(
     cost_map: dict[str, float] | None,
     *,
     epsilon: float = EPSILON,
+    lam: float | None = None,
 ) -> tuple[str, bool, tuple[str, ...]]:
-    """Thompson サンプル拮抗群内で min-max 正規化コストが最安の tier を返す。
+    """Thompson サンプルから cost を考慮して最適な tier を返す（3 経路）。
+
+    lam（λ）の値によって 3 つの経路に分岐する:
+      - 経路 0（cost_map is None or lam == 0）: cost を見ない。argmax(sample) を返す。
+        lam=None を渡しても cost_map が None なら経路 0。lam=0.0 の明示オプトも経路 0。
+      - 経路 1（lam is None・既定）: v2.25.0 の ε-gated min-max 最安（後方互換）。
+        contenders ≤ 1 は argmax、複数 contenders は min-max 正規化コスト最安を選ぶ。
+        lam=None（env 未設定センチネル）がデフォルト→ v2.25.0 挙動と完全一致。
+      - 経路 2（lam > 0）: 全 tier weighting。
+        score[t] = sample[t] - lam * cost_norm[t] で全 tier を比較し最大を選ぶ。
+        cost_norm は全 tier の min-max 正規化（最安→0・最高→1）。
 
     Args:
         samples: {tier: beta_sample} の dict（Thompson Sampling 結果）。
-        cost_map: {tier: cost} の dict。None なら cost を見ず従来挙動。
+        cost_map: {tier: cost} の dict。None なら cost を見ず従来挙動（経路 0）。
             cost は実測 rate_usd_per_mtok または静的参照単価（ハイブリッド）。
             v2.24.0 で rate 化（USD/MTok）により実測・静的とも同次元で整合済み。
-            ``cost_map`` は None、または contenders 全件をキーとして含む dict を
-            渡すこと。partial dict を渡すと ``cost_map[t]`` で KeyError が発生する。
+            ``cost_map`` は None、または samples の全 tier キーを含む dict を渡すこと。
+            partial dict を渡すと ``cost_map[t]`` で KeyError が発生する。
             ``select_tier_detailed`` 経由では呼び出し側（main）が全 TIERS 分を
             構築して保証する。
-        epsilon: 拮抗判定の閾値（デフォルト EPSILON=0.05）。
+        epsilon: 拮抗判定の閾値（デフォルト EPSILON=0.05）。経路 0/1 で使用。
+            経路 2 では contenders 算出にのみ使用（選択自体は全 tier score 比較）。
+        lam: cost weighting 係数（λ）。None=センチネル（経路 1・後方互換）、
+            0.0=cost 無視明示（経路 0）、0 < lam <= COST_LAMBDA_MAX=全 tier weighting（経路 2）。
+            デフォルト None で既存 2 引数呼び出しの挙動・シグネチャを完全不変にする。
 
     Returns:
         (chosen, did_tiebreak, contenders) のタプル。
         - chosen: 選択された tier 名。
-        - did_tiebreak: cost tie-break が発動した場合 True。
-        - contenders: 拮抗判定に入った tier のタプル。
+        - did_tiebreak: cost が選択に影響した場合 True。
+            経路 1: contenders 内 min-max で安い方を選んだ場合 True（全 tier コスト同値時は False）。
+            経路 2: 全 tier weighting で argmax(sample) と異なる選択になった場合 True。
+        - contenders: ε 拮抗判定に入った tier のタプル（observability 用）。
     """
     max_sample = max(samples.values())
     contenders = [t for t in samples if max_sample - samples[t] <= epsilon]
 
-    if len(contenders) <= 1 or cost_map is None:
-        # 従来挙動と完全一致: max(samples, key=lambda t: samples[t]) と同じ式
+    # 経路 0: cost を見ない（cost_map なし or λ=0 明示）。
+    # None == 0 は Python では False のため lam == 0 は float 0.0 のみ真（意図通り）。
+    if cost_map is None or lam == 0:
         chosen = max(samples, key=lambda t: samples[t])
         return chosen, False, tuple(contenders)
 
-    # 拮抗群内で min-max 正規化コストを計算し最安 tier を選ぶ
-    costs = {t: cost_map[t] for t in contenders}
+    # 経路 1（lam=None・既定）: v2.25.0 の ε-gated min-max 最安（現行ロジック完全踏襲）。
+    if lam is None:
+        if len(contenders) <= 1:
+            chosen = max(samples, key=lambda t: samples[t])
+            return chosen, False, tuple(contenders)
+        # 拮抗群内で min-max 正規化コストを計算し最安 tier を選ぶ
+        costs = {t: cost_map[t] for t in contenders}
+        lo, hi = min(costs.values()), max(costs.values())
+        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)
+
+    # 経路 2（lam > 0）: 全 tier weighting。
+    # cost_norm は全 tier で min-max 正規化（最安→0・最高→1）。
+    costs = {t: cost_map[t] for t in samples}
     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 同値時はサンプル大（=従来選好）を優先 → 決定論
-    chosen = min(contenders, key=lambda t: (norm[t], -samples[t]))
-    return chosen, True, tuple(contenders)
+    norm = {t: ((costs[t] - lo) / (hi - lo) if hi > lo else 0.0) for t in samples}
+    score = {t: samples[t] - lam * norm[t] for t in samples}
+    # 同点は sample 大優先（決定論）
+    chosen = max(samples, key=lambda t: (score[t], samples[t]))
+    pure_max = max(samples, key=lambda t: samples[t])
+    cost_tiebreak = chosen != pure_max
+    return chosen, cost_tiebreak, tuple(contenders)
 
 
 def _prompt_prefix_and_hash(prompt: str) -> tuple[str, str]:
@@ -298,6 +349,7 @@ def select_tier_detailed(
     rng: random.Random | None = None,
     cost_map: dict[str, float] | None = None,
     epsilon: float | None = None,
+    lam: float | None = None,
 ) -> SelectionResult:
     """Beta サンプリングまたは uniform 選択で推奨 Tier を SelectionResult で返す。
 
@@ -311,15 +363,20 @@ def select_tier_detailed(
             （呼び出し側が全 TIERS 分を構築して保証する）。
             uniform 分岐では cost_map の有無に関わらず完全無視する（探索保護）。
         epsilon: 拮抗判定閾値。None なら module 定数 EPSILON を使う（C3_TIER_EPSILON で上書き可）。
+        lam: cost weighting 係数（λ）。None=センチネル（v2.25.0 ε-gated 後方互換）、
+            0.0=cost 無視明示、0<lam<=COST_LAMBDA_MAX=全 tier weighting 発動（C3_TIER_COST_LAMBDA で上書き可）。
+            None（デフォルト）では env 未設定時と完全一致する（後方互換の核心）。
+            uniform 分岐では lam の値に関わらず完全無視する（探索保護・不可侵）。
 
     Returns:
-        SelectionResult（tier, mode, cost_tiebreak, contenders）。
+        SelectionResult（tier, mode, cost_tiebreak, contenders, cost_weighted）。
         mode は ``"thompson"`` / ``"uniform"``。
+        cost_weighted は lam>0 かつ cost_map が有効な場合のみ True。
     """
     rng = rng or random
     total_trials = sum(p[2] for p in params.values())
     if total_trials < LEARNING_THRESHOLD:
-        # uniform: cost を完全無視・従来挙動完全維持
+        # uniform: cost/λ を完全無視・従来挙動完全維持（不可侵）
         return SelectionResult(rng.choice(TIERS), "uniform", False, ())
 
     # Thompson Sampling: rng の消費順序を従来 select_tier と完全一致させる
@@ -328,8 +385,9 @@ def select_tier_detailed(
         for tier, p in params.items()
     }
     eff_epsilon = epsilon if epsilon is not None else EPSILON
-    chosen, did_tiebreak, contenders = _cost_tiebreak(samples, cost_map, epsilon=eff_epsilon)
-    return SelectionResult(chosen, "thompson", did_tiebreak, contenders)
+    chosen, did_tiebreak, contenders = _cost_tiebreak(samples, cost_map, epsilon=eff_epsilon, lam=lam)
+    cost_weighted = (cost_map is not None and lam is not None and lam > 0)
+    return SelectionResult(chosen, "thompson", did_tiebreak, contenders, cost_weighted)
 
 
 def select_tier(
@@ -338,6 +396,7 @@ def select_tier(
     rng: random.Random | None = None,
     cost_map: dict[str, float] | None = None,
     epsilon: float | None = None,
+    lam: float | None = None,
 ) -> tuple[str, str]:
     """Beta サンプリングまたは uniform 選択で推奨 Tier を返す。
 
@@ -350,13 +409,15 @@ def select_tier(
             uniform 分岐では cost_map の有無に関わらず完全無視する。
             詳細は :func:`select_tier_detailed` を参照。
         epsilon: 拮抗判定閾値。None なら module 定数 EPSILON を使う。
+        lam: cost weighting 係数（λ）。select_tier_detailed に委譲する。
+            None=センチネル（v2.25.0 後方互換）、0.0=cost 無視、0<lam<=1=全 tier weighting。
 
     Returns:
         ``(tier, mode)`` のタプル。``mode`` は ``"thompson"`` / ``"uniform"`` で、
         プロンプトに「学習データ収集中」と表示するかの分岐に使う。
         戻り値型は v2.22.0 以前と完全に不変。
     """
-    result = select_tier_detailed(params, rng=rng, cost_map=cost_map, epsilon=epsilon)
+    result = select_tier_detailed(params, rng=rng, cost_map=cost_map, epsilon=epsilon, lam=lam)
     return result.tier, result.mode
 
 
@@ -368,7 +429,7 @@ _ESCALATION_MAP: dict[str, str] = {
 }
 
 # Phase 2-B: failure rate がこの値以上で escalation 判定。
-ESCALATION_THRESHOLD = 0.5
+# SSOT: db.ESCALATION_THRESHOLD_DEFAULT 由来（import 部で取得）。C3_ESCALATION_THRESHOLD env で上書き可（v2.26.0）。
 
 
 def _db_failure_rate(complexity: str, tier: str) -> tuple:
@@ -387,6 +448,7 @@ def maybe_escalate(
     chosen_tier: str,
     *,
     failure_rate_fn=None,
+    threshold: float | None = None,
 ) -> tuple[str, str | None]:
     """Phase 2-B: failure rate が高ければ 1 段昇格する。
 
@@ -396,6 +458,9 @@ def maybe_escalate(
         failure_rate_fn: テスト用に注入可能な
             ``(complexity, tier) -> (rate_or_None, sample_count)``。
             省略時は :func:`_db_failure_rate` を使う。
+        threshold: escalation 閾値（failure rate がこの値以上で昇格）。
+            None のとき module 定数 ``ESCALATION_THRESHOLD`` を使う。
+            ``main()`` は ``_resolve_escalation_threshold()`` で解決した値を渡す。
 
     Returns:
         ``(effective_tier, escalation_reason)``。
@@ -407,7 +472,8 @@ def maybe_escalate(
 
     effective_fn = failure_rate_fn or _db_failure_rate
     rate, samples = effective_fn(complexity, chosen_tier)
-    if rate is None or rate < ESCALATION_THRESHOLD:
+    eff_threshold = threshold if threshold is not None else ESCALATION_THRESHOLD
+    if rate is None or rate < eff_threshold:
         return chosen_tier, None
 
     escalated = _ESCALATION_MAP[chosen_tier]
@@ -429,6 +495,8 @@ def write_tier_selection(
     prompt_hash: str | None = None,
     session_id: str | None = None,
     cost_tiebreak: bool = False,
+    cost_weighted: bool = False,
+    cost_lambda: float | None = None,
 ) -> None:
     """直近の選択結果を ``tier_selection.json`` に書く。
 
@@ -448,6 +516,14 @@ def write_tier_selection(
     ``cost_tiebreak`` を任意で含める（v2.23.0）。
     Thompson Sampling の拮抗群内で cost tie-break が発動した場合のみ True。
     False のときはキー自体を省略する（escalated/session_id と同パターン）。
+
+    ``cost_weighted`` を任意で含める（v2.26.0）。
+    λ>0 の全 tier weighting が適用された場合のみ True。
+    False のときはキー自体を省略する（cost_tiebreak と同パターン）。
+
+    ``cost_lambda`` を任意で含める（v2.26.0）。
+    ``_resolve_cost_lambda()`` で解決した λ 値（None 以外のとき出力）。
+    None のときはキー自体を省略する（env 未設定時の後方互換）。
     """
     os.makedirs(os.path.dirname(TIER_SELECTION_PATH), exist_ok=True)
     payload: dict[str, object] = {
@@ -471,6 +547,10 @@ def write_tier_selection(
         payload["session_id"] = session_id
     if cost_tiebreak:
         payload["cost_tiebreak"] = True
+    if cost_weighted:
+        payload["cost_weighted"] = True
+    if cost_lambda is not None:
+        payload["cost_lambda"] = cost_lambda
     try:
         with open(TIER_SELECTION_PATH, "w", encoding="utf-8") as f:
             json.dump(payload, f, ensure_ascii=False)
@@ -488,11 +568,16 @@ def build_additional_context(
     escalation_reason: str | None = None,
     complexity_source: str | None = None,
     cost_tiebreak: bool = False,
+    cost_weighted: bool = False,
 ) -> str:
     """親 Claude に追加注入する文字列を組み立てる。
 
     ``cost_tiebreak`` が True のとき、suffix に cost-aware 発動を示す文言を追加する（v2.23.0）。
     False のときは不変（既存文言と完全一致）。
+
+    ``cost_weighted`` が True のとき、cost-weighted 文言を suffix に追加する（v2.26.0）。
+    True のときは cost_tiebreak の文言より優先される（λ>0 全 tier weighting を明示）。
+    False のときは cost_tiebreak による既存文言のみ（v2.25.0 以前と完全一致）。
     """
     trials = sum(p[2] for p in params.values())
     if mode == "uniform":
@@ -506,7 +591,9 @@ def build_additional_context(
         suffix += f" [Phase 2-B 昇格: {escalation_reason}]"
     if complexity_source:
         suffix += f" [複雑度判定: {complexity_source}]"
-    if cost_tiebreak:
+    if cost_weighted:
+        suffix += " [cost-weighted: 成功率とコストを加重して選択]"
+    elif cost_tiebreak:
         suffix += " [cost-aware: 成功率拮抗のため低コスト Tier を選択]"
 
     return (
@@ -564,6 +651,79 @@ def _resolve_epsilon() -> float:
     return x
 
 
+def _resolve_escalation_threshold() -> float:
+    """``C3_ESCALATION_THRESHOLD`` を安全に解決する。
+
+    不正値（非数値 / 0 以下 / 1 超 / NaN）は受け付けず、stderr 警告 + デフォルト（ESCALATION_THRESHOLD）に戻す。
+    未設定 / 空文字は無警告でデフォルトを返す。
+    妥当域: 0 < x <= 1（_resolve_epsilon と同じ範囲）。区間表記: (0, 1]（x=0 拒否のため半開区間）。
+    """
+    raw = os.environ.get("C3_ESCALATION_THRESHOLD")
+    if raw is None or raw == "":
+        return ESCALATION_THRESHOLD
+    try:
+        x = float(raw)
+    except ValueError:
+        print(
+            f"[select_tier:escalation] invalid C3_ESCALATION_THRESHOLD={raw!r}, "
+            f"using default {ESCALATION_THRESHOLD}",
+            file=sys.stderr,
+        )
+        return ESCALATION_THRESHOLD
+    if math.isnan(x):
+        print(
+            f"[select_tier:escalation] C3_ESCALATION_THRESHOLD={raw!r} is NaN, "
+            f"using default {ESCALATION_THRESHOLD}",
+            file=sys.stderr,
+        )
+        return ESCALATION_THRESHOLD
+    if x <= 0 or x > 1:
+        print(
+            f"[select_tier:escalation] C3_ESCALATION_THRESHOLD={x!r} out of range (0, 1], "
+            f"using default {ESCALATION_THRESHOLD}",
+            file=sys.stderr,
+        )
+        return ESCALATION_THRESHOLD
+    return x
+
+
+def _resolve_cost_lambda() -> float | None:
+    """``C3_TIER_COST_LAMBDA`` を安全に解決する。
+
+    不正値（非数値 / 0 未満 / COST_LAMBDA_MAX 超 / NaN）は受け付けず、stderr 警告 + デフォルト（COST_LAMBDA_DEFAULT）に戻す。
+    未設定 / 空文字は無警告でデフォルト（None）を返す。
+    妥当域: 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")
+    if raw is None or raw == "":
+        return COST_LAMBDA_DEFAULT
+    try:
+        x = float(raw)
+    except ValueError:
+        print(
+            f"[select_tier: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"[select_tier: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"[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,
+        )
+        return COST_LAMBDA_DEFAULT
+    return x
+
+
 def main() -> int:
     try:
         payload = json.loads(sys.stdin.read())
@@ -619,12 +779,14 @@ def main() -> int:
             cost_map = None
 
     eps = _resolve_epsilon()
-    result = select_tier_detailed(params, cost_map=cost_map, epsilon=eps)
+    lam = _resolve_cost_lambda()
+    result = select_tier_detailed(params, cost_map=cost_map, epsilon=eps, lam=lam)
     tier, mode = result.tier, result.mode
     cost_tiebreak = result.cost_tiebreak
 
     # Phase 2-B: failure rate に基づく escalation
-    effective_tier, escalation_reason = maybe_escalate(complexity, tier)
+    esc_thr = _resolve_escalation_threshold()
+    effective_tier, escalation_reason = maybe_escalate(complexity, tier, threshold=esc_thr)
     escalated = effective_tier != tier
 
     write_tier_selection(
@@ -634,6 +796,8 @@ def main() -> int:
         prompt_hash=prompt_hash,
         session_id=session_id,
         cost_tiebreak=cost_tiebreak,
+        cost_weighted=result.cost_weighted,
+        cost_lambda=lam,
     )
 
     context_text = build_additional_context(
@@ -641,6 +805,7 @@ def main() -> int:
         escalation_reason=escalation_reason,
         complexity_source=complexity_source,
         cost_tiebreak=cost_tiebreak,
+        cost_weighted=result.cost_weighted,
     )
     output = {
         "hookSpecificOutput": {

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

@@ -1,5 +1,50 @@
 # 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/hooks/select_tier.py`: cost-weighted Thompson Sampling（全 tier 対象）**: スコアを `score = sample − λ·cost_norm`（cost_norm は全 tier の min-max 正規化）とし最大 tier を選ぶ routing を導入。λ は環境変数 `C3_TIER_COST_LAMBDA`（0〜1）で設定。λ>0 で発動し、安い tier が成功率優位な tier に勝ちうる（成功率 vs コストのトレードオフ）。λ=0 明示でコスト無視（純 Thompson）。`db.COST_LAMBDA_DEFAULT`（None）が SSOT。
+
+- **`.claude/hooks/select_tier.py`: `C3_ESCALATION_THRESHOLD` 対応**: failure-rate escalation の閾値を環境変数 `C3_ESCALATION_THRESHOLD`（0 < x ≤ 1）で設定可能に。`db.ESCALATION_THRESHOLD_DEFAULT`（0.5）が SSOT。NaN・範囲外・非数値は default 値に fallback。
+
+### 変更
+
+- **`.claude/hooks/select_tier.py`**: `SelectionResult` に `cost_weighted: bool` / `cost_lambda: float | None` を末尾追加（既存フィールド不変）。`write_tier_selection`/`build_additional_context` に cost-weighted 発動時 `cost_weighted` / `cost_lambda` を記録（既存 `cost_tiebreak` キーは不変）。
+
+- **`src/c3/db.py`**: `COST_LAMBDA_DEFAULT = None`・`ESCALATION_THRESHOLD_DEFAULT = 0.5` 定数を追加（環境変数オーバーライドの SSOT）。
+
+### 後方互換
+
+- `C3_TIER_COST_LAMBDA` 未設定（デフォルト None）時は v2.25.0 の ε tie-break 挙動を完全維持（routing 出力はバイト互換）。
+- `C3_TIER_EPSILON`・`C3_ESCALATION_THRESHOLD` 未設定時も v2.25.0 と完全一致。
+- 既存関数シグネチャ不変（`select_tier_detailed`/`select_tier` の λ は optional kwarg・`SelectionResult` は末尾フィールド追加）。
+- migration 不要（v2.22.0 の 003 で列確保済み）。**破壊的変更なし**。
+
 ## [2.25.0] - 2026-05-26
 
 **tier_bandit cost 蓄積・EPSILON 調整可能化・例外ログ統一**: v2.22.0 で列確保済みの `tier_bandit.total_cost_usd`/`cost_samples` へ実測値を materialize する同期関数を追加。cost-aware tie-break の拮抗判定閾値を定数 SSOT 化し環境変数で上書き可能にする。db.py 既存 6 関数の例外ログを型名統一（SR-R-001）。routing 挙動は不変。cost-weighted Thompson 本格統合は v2.26.0。

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-conductor
-Version: 2.25.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 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.25.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 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.25.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.25.0"
+__version__ = "2.27.0"

{claude_code_conductor-2.25.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()