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

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

@@ -27,6 +27,7 @@ import collections
 import difflib
 import hashlib
 import json
+import math
 import os
 import random
 import re
@@ -47,8 +48,14 @@ except AttributeError:
 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
 except ImportError:
     LEARNING_THRESHOLD = 30
+    EPSILON = 0.05
+    ESCALATION_THRESHOLD = 0.5
+    COST_LAMBDA_DEFAULT = None
 
 # 複雑度推定のキーワード
 SIMPLE_KEYWORDS = frozenset({
@@ -111,10 +118,9 @@ _PROMPT_HISTORY_SCAN_LINES = 1000
 
 TIERS: tuple[str, ...] = ("haiku", "sonnet", "opus")
 
-# cost-aware tie-break の拮抗判定閾値（v2.23.0）。
+# cost-aware tie-break の拮抗判定閾値（v2.23.0・SSOT は db.EPSILON_TIEBREAK）。
 # Beta サンプルは 0〜1 スケール。成功率 5pt 以内＝実質同等とみなす拮抗判定閾値。
-# 過大は成功率犠牲リスク、過小は無発動。調整可能化は v2.24.0。
-EPSILON: float = 0.05
+# 過大は成功率犠牲リスク、過小は無発動。C3_TIER_EPSILON env で上書き可（v2.25.0）。
 
 
 class SelectionResult(NamedTuple):
@@ -125,12 +131,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(
@@ -138,41 +148,79 @@ 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 <= 1=全 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。
+            経路 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())
+        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]
+        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]:
@@ -295,6 +343,8 @@ 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 で返す。
 
@@ -307,15 +357,21 @@ def select_tier_detailed(
             含む完全な dict」のいずれか。partial dict は渡されない前提
             （呼び出し側が全 TIERS 分を構築して保証する）。
             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 で上書き可）。
+            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 と完全一致させる
@@ -323,8 +379,10 @@ def select_tier_detailed(
         tier: rng.betavariate(p[0], p[1])
         for tier, p in params.items()
     }
-    chosen, did_tiebreak, contenders = _cost_tiebreak(samples, cost_map)
-    return SelectionResult(chosen, "thompson", did_tiebreak, contenders)
+    eff_epsilon = epsilon if epsilon is not None else EPSILON
+    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(
@@ -332,6 +390,8 @@ 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 を返す。
 
@@ -343,13 +403,16 @@ def select_tier(
             None なら cost を見ず従来の Thompson Sampling と完全一致。
             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)
+    result = select_tier_detailed(params, rng=rng, cost_map=cost_map, epsilon=epsilon, lam=lam)
     return result.tier, result.mode
 
 
@@ -361,7 +424,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:
@@ -380,6 +443,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 段昇格する。
 
@@ -389,6 +453,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)``。
@@ -400,7 +467,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]
@@ -422,6 +490,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`` に書く。
 
@@ -441,6 +511,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] = {
@@ -464,6 +542,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)
@@ -481,11 +563,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":
@@ -499,7 +586,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 (
@@ -522,6 +611,114 @@ def _load_c3_db_module():
         return None
 
 
+def _resolve_epsilon() -> float:
+    """``C3_TIER_EPSILON`` を安全に解決する。
+
+    不正値（非数値 / 0 以下 / 1 超 / NaN）は受け付けず、stderr 警告 + デフォルト（EPSILON）に戻す。
+    未設定 / 空文字は無警告でデフォルトを返す（[SR-V-001]）。
+    """
+    raw = os.environ.get("C3_TIER_EPSILON")
+    if raw is None or raw == "":
+        return EPSILON
+    try:
+        x = float(raw)
+    except ValueError:
+        print(
+            f"[select_tier:epsilon] invalid C3_TIER_EPSILON={raw!r}, "
+            f"using default {EPSILON}",
+            file=sys.stderr,
+        )
+        return EPSILON
+    if math.isnan(x):
+        print(
+            f"[select_tier:epsilon] C3_TIER_EPSILON={raw!r} is NaN, "
+            f"using default {EPSILON}",
+            file=sys.stderr,
+        )
+        return EPSILON
+    if x <= 0 or x > 1:
+        print(
+            f"[select_tier:epsilon] C3_TIER_EPSILON={x} out of range (0, 1], "
+            f"using default {EPSILON}",
+            file=sys.stderr,
+        )
+        return EPSILON
+    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 未満 / 1 超 / NaN）は受け付けず、stderr 警告 + デフォルト（COST_LAMBDA_DEFAULT）に戻す。
+    未設定 / 空文字は無警告でデフォルト（None）を返す。
+    妥当域: 0 <= x <= 1（x == 0 は許容＝cost 無視の明示オプト・_resolve_epsilon と異なり下限を含む）。区間表記: [0, 1]（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 < 0 or x > 1:
+        print(
+            f"[select_tier:cost_lambda] C3_TIER_COST_LAMBDA={x!r} out of range [0, 1], "
+            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())
@@ -576,12 +773,15 @@ def main() -> int:
         except ImportError:
             cost_map = None
 
-    result = select_tier_detailed(params, cost_map=cost_map)
+    eps = _resolve_epsilon()
+    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(
@@ -591,6 +791,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(
@@ -598,6 +800,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.24.0 → claude_code_conductor-2.26.0}/.claude/hooks/session_stop.py

@@ -103,6 +103,8 @@ def main() -> int:
                 from c3.usage_ingester import ingest_session  # noqa: PLC0415
                 project_dir = _Path(transcript_path).parent
                 ingest_session(session_id=session_id, project_dir=project_dir)
+                from c3.db import sync_tier_bandit_cost  # noqa: PLC0415
+                sync_tier_bandit_cost()
     except Exception as e:
         print(f"[session_stop:usage_ingester] failed: {type(e).__name__}", file=sys.stderr)
 

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

@@ -1,5 +1,51 @@
 # Changelog
 
+## [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。
+
+### 機能追加
+
+- **`src/c3/db.py`: `sync_tier_bandit_cost(*, db_path=None) -> None`（新規）**: `read_tier_cost_rate_summary` 由来の model 一致集計値を `tier_bandit` テーブルへ materialize する冪等な同期関数。「全クリア(total_cost_usd=0, cost_samples=0) → 集計 SET」の UPDATE-only 実装（INSERT なし）。session_stop の usage ingest 直後に実行。tier_bandit 行が存在しない複合キー (complexity, tier) は無視（INSERT は行わない）。
+
+- **`.claude/hooks/select_tier.py`: `db.EPSILON_TIEBREAK`（0.05）定数 SSOT 化・環境変数 `C3_TIER_EPSILON` 対応**: 従来 `EPSILON=0.05` をモジュールローカルで持っていた値を `c3.db.EPSILON_TIEBREAK` に移し Single Source of Truth 化。`select_tier.py` は `db.EPSILON_TIEBREAK` を参照するよう変更。環境変数 `C3_TIER_EPSILON` に数値が設定されている場合は実行時にその値で上書き可能。NaN・範囲外(0 < x <= 1 の外)・非数値は default 値（0.05）に fallback。env 未設定時の routing 挙動は v2.24.0 と完全一致。
+
+### 変更
+
+- **`src/c3/cli_tier.py`**: `c3 tier stats` の tier_bandit セクションに `total_cost_usd`（合計コスト USD）および `cost_samples`（計上セッション数）列を追加。値は `sync_tier_bandit_cost` 蓄積値を表示。データ未蓄積（0/0）時はセルを「-」表示。
+
+- **`src/c3/db.py`: 例外ログ型名統一（SR-R-001）**: 既存 6 関数 7 箇所の `except Exception as exc` ログを `logger.warning("...: %s", exc)` から `logger.warning("...: %s", type(exc).__name__)` に統一。生 exc message（外部 path・SQL 文・行データ等）の意図しない流出を防止。関数シグネチャ・戻り値・呼び出し元への影響なし。
+
+### 後方互換
+
+- 既存関数シグネチャ不変（`read_tier_params`・`read_tier_cost_rate_summary` 等）。
+- `select_tier_detailed`/`select_tier` の `epsilon` は optional kwarg（省略時 `db.EPSILON_TIEBREAK` を参照）。
+- migration 不要（`tier_bandit` の cost 列は v2.22.0 の 003 migration で確保済み）。
+- **破壊的変更なし**。
+
 ## [2.24.0] - 2026-05-25
 
 **tier-routing cost 精度向上**: tie-break が使う cost データを model 一致集計・USD/MTok レート化により信頼できるものにする。新関数 2 つを追加し、`select_tier` の cost_map 源を rate 関数へ切替。既存関数・tie-break ロジックは完全不変。

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-conductor
-Version: 2.24.0
+Version: 2.26.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,6 +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/)参照） |
 
 ### 基本的な使い方
 

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

@@ -154,6 +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/)参照） |
 
 ### 基本的な使い方
 

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

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

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

@@ -94,6 +94,11 @@ def _collect_snapshot(db_path, recent_limit: int) -> dict[str, Any]:
     bandit_rows: list[dict[str, Any]] = []
     total_trials = 0
 
+    # cost 列は別 SELECT（read_tier_params は alpha/beta/trials 専用を維持）
+    bandit_cost: dict[tuple[str, str], tuple[float, int]] = c3_db.read_tier_bandit_cost(
+        db_path=db_path,
+    )
+
     for complexity in _COMPLEXITIES:
         params = c3_db.read_tier_params(complexity, db_path=db_path)
         for tier in _TIERS:
@@ -101,6 +106,7 @@ def _collect_snapshot(db_path, recent_limit: int) -> dict[str, Any]:
             total_trials += trials
             denom = alpha + beta
             expected = alpha / denom if denom > 0 else 0.5
+            cost_usd, cost_samples = bandit_cost.get((complexity, tier), (0.0, 0))
             bandit_rows.append({
                 "complexity": complexity,
                 "tier": tier,
@@ -108,6 +114,8 @@ def _collect_snapshot(db_path, recent_limit: int) -> dict[str, Any]:
                 "beta": beta,
                 "trials": trials,
                 "expected_success_rate": expected,
+                "total_cost_usd": cost_usd,
+                "cost_samples": cost_samples,
             })
 
     recent_outcomes: list[dict[str, Any]] = c3_db.read_recent_outcomes(
@@ -154,12 +162,18 @@ def _render_human(snapshot: dict[str, Any]) -> None:
     print()
 
     print("== Tier 別累積（tier_bandit） ==")
-    print(f"{'complexity':<12} {'tier':<8} {'trials':>6}  {'alpha':>5}  {'beta':>5}  {'期待成功率':>10}")
+    print(
+        f"{'complexity':<12} {'tier':<8} {'trials':>6}  {'alpha':>5}  {'beta':>5}  "
+        f"{'期待成功率':>10}  {'cost_usd':>10}  {'cost_samples':>12}"
+    )
     for row in snapshot["tier_bandit"]:
+        complexity_safe = sanitize_terminal_text(str(row["complexity"]))
+        tier_safe = sanitize_terminal_text(str(row["tier"]))
         print(
-            f"{row['complexity']:<12} {row['tier']:<8} "
+            f"{complexity_safe:<12} {tier_safe:<8} "
             f"{row['trials']:>6}  {row['alpha']:>5.2f}  {row['beta']:>5.2f}  "
-            f"{row['expected_success_rate'] * 100:>9.2f}%"
+            f"{row['expected_success_rate'] * 100:>9.2f}%  "
+            f"${row['total_cost_usd']:>9.4f}  {row['cost_samples']:>12}"
         )
     print()