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

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

@@ -144,8 +144,8 @@ def _cost_tiebreak(
     Args:
         samples: {tier: beta_sample} の dict（Thompson Sampling 結果）。
         cost_map: {tier: cost} の dict。None なら cost を見ず従来挙動。
-            cost は実測 avg_cost_usd または静的参照単価（ハイブリッド）。
-            混在スケール（USD vs per-MTok）の厳密化は v2.24.0。
+            cost は実測 rate_usd_per_mtok または静的参照単価（ハイブリッド）。
+            v2.24.0 で rate 化（USD/MTok）により実測・静的とも同次元で整合済み。
             ``cost_map`` は None、または contenders 全件をキーとして含む dict を
             渡すこと。partial dict を渡すと ``cost_map[t]`` で KeyError が発生する。
             ``select_tier_detailed`` 経由では呼び出し側（main）が全 TIERS 分を
@@ -556,14 +556,15 @@ def main() -> int:
     else:
         params = c3_db.read_tier_params(complexity)
 
-    # v2.23.0: cost_map をハイブリッド解決（実測 avg_cost を主に、欠損 tier は静的単価で補完）。
+    # v2.24.0: cost_map をハイブリッド解決（実測 rate USD/MTok を主に、欠損 tier は静的単価で補完）。
+    # rate 化により measured(実測)と tier_reference_cost(静的)が同次元（USD/MTok）になり単位整合済み。
     # c3_db が None または pricing import 失敗時は cost_map=None で従来 Thompson にデグレード。
     # cost_map=None の場合、select_tier_detailed/_cost_tiebreak は従来 Thompson 挙動と完全一致（引数定義参照）。
     cost_map = None
     if c3_db is not None:
         try:
             from c3 import pricing  # type: ignore[import-not-found]
-            measured = c3_db.read_tier_cost_for_complexity(complexity)  # {tier: avg} 実測>0 のみ
+            measured = c3_db.read_tier_cost_rate_for_complexity(complexity)  # {tier: rate USD/MTok} 実測>0 のみ
             cost_map = {}
             for tier_name in TIERS:
                 if tier_name in measured and measured[tier_name] > 0:

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

@@ -1,5 +1,32 @@
 # Changelog
 
+## [2.24.0] - 2026-05-25
+
+**tier-routing cost 精度向上**: tie-break が使う cost データを model 一致集計・USD/MTok レート化により信頼できるものにする。新関数 2 つを追加し、`select_tier` の cost_map 源を rate 関数へ切替。既存関数・tie-break ロジックは完全不変。
+
+**スコープ注記**:
+- `tier_bandit.total_cost_usd`/`cost_samples` への書き込み・cost-weighted Thompson 本格統合は **v2.25.0+**。
+- migration なし。**破壊的変更なし**（新関数追加・cost_map 値の意味変更のみ・既存関数 docstring 含め完全不変）。
+
+### 機能追加
+
+- **`src/c3/db.py`: `read_tier_cost_rate_summary(*, db_path=None) -> list[dict]`（新規）**: model 一致集計・(session, tier) 重複排除・USD/MTok レート化を行う精度向上版の cost 集計関数。`agent_cost_runs` を `agent_type <> 'mainline'` で読み、Python 側で `pricing.resolve_tier(model)` により tier 振り分け。`(session_id, tier)` 粒度で集約後、`tier_recent_outcomes` と突合して `(complexity, tier)` 別に集計。`rate_usd_per_mtok = total_cost_usd / (billable_tokens / 1_000_000)`（`billable_tokens = input_tokens + output_tokens`）で `tier_reference_cost`（USD/MTok）と同次元にする。`billable_tokens == 0` の (complexity,tier) は除外。未知 model 行はスキップ。戻り値 dict キー: `complexity / tier / sessions / total_cost_usd / billable_tokens / rate_usd_per_mtok`。内部畳み込み部は DB 非依存の純関数 `_compute_tier_cost_rate_summary` に分離。
+
+- **`src/c3/db.py`: `read_tier_cost_rate_for_complexity(complexity, *, db_path=None) -> dict[str, float]`（新規）**: `read_tier_cost_rate_summary` を complexity 一致 & `rate_usd_per_mtok > 0` でフィルタし `{tier: rate_usd_per_mtok}` を返す薄いラッパー（v2.23.0 の `read_tier_cost_for_complexity` と対称）。データ/DB 不在で `{}`。
+
+### 変更
+
+- **`.claude/hooks/select_tier.py`**: `main()` の cost_map 構築で `read_tier_cost_for_complexity` → `read_tier_cost_rate_for_complexity` に切替。tie-break ロジック不変・cost_map の値の意味が絶対 USD → USD/MTok レートに変化し、静的 `tier_reference_cost` と単位整合。コメント更新（「混在スケール・厳密化は v2.24.0」→「v2.24.0 で rate 化により整合済み」）。
+
+- **`src/c3/cli_tier.py`**: `c3 tier stats` に「Tier 別 USD/MTok レート（model 一致・tie-break が使用）」セクションを追加（complexity/tier/sessions/rate_usd_per_mtok 表示・データなしで「（rate データ未収集）」）。既存 session 合計 USD セクションも維持。「精度向上は v2.24.0」注記を「（粗い概算・session 合計 USD）」に更新。`--json` 出力に `tier_cost_rate` キー自動反映。DB 由来テキストへ `sanitize_terminal_text` 適用。
+
+- **`src/c3/__init__.py`**: `__version__` を `"2.23.0"` から `"2.24.0"` に更新。
+
+### 後方互換
+
+- 既存 `read_tier_cost_summary` / `read_tier_cost_for_complexity` は docstring 含め完全不変。
+- migration なし（`agent_cost_runs` の token 4 列 + model 列は v2.21.0 (002 migration) で既存）。
+
 ## [2.23.0] - 2026-05-25
 
 **tier-routing cost-aware tie-break**: `select_tier` の Thompson Sampling 分岐に「拮抗 tier 群内コスト tie-break」を追加する。サンプル最大から ε(=0.05) 以内の拮抗 tier が複数ある場合のみ、min-max 正規化コストが最安の tier を選ぶ。単独最大なら従来通り（挙動不変）。成功率を犠牲にしない最小スコープの cost 統合。

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-conductor
-Version: 2.23.0
+Version: 2.24.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

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

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

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

@@ -22,6 +22,7 @@ import sys
 from typing import Any
 
 from c3 import db as c3_db
+from c3._terminal import sanitize_terminal_text
 
 
 logger = logging.getLogger(__name__)
@@ -118,6 +119,8 @@ def _collect_snapshot(db_path, recent_limit: int) -> dict[str, Any]:
 
     tier_cost: list[dict[str, Any]] = c3_db.read_tier_cost_summary(db_path=db_path)
 
+    tier_cost_rate: list[dict[str, Any]] = c3_db.read_tier_cost_rate_summary(db_path=db_path)
+
     if total_trials < _LEARNING_THRESHOLD:
         mode = "uniform"
     else:
@@ -133,6 +136,7 @@ def _collect_snapshot(db_path, recent_limit: int) -> dict[str, Any]:
         "recent_outcomes": recent_outcomes,
         "agent_cost": agent_cost,
         "tier_cost": tier_cost,
+        "tier_cost_rate": tier_cost_rate,
     }
 
 
@@ -184,9 +188,10 @@ def _render_human(snapshot: dict[str, Any]) -> None:
             f"{'in_tok':>9}  {'out_tok':>9}  {'cache_r':>9}  {'cache_w':>9}"
         )
         for row in agent_cost:
-            note = "  （マクロ集計・tier 学習対象外）" if row["agent_type"] == "mainline" else ""
+            agent_type_safe = sanitize_terminal_text(str(row["agent_type"]))
+            note = "  （マクロ集計・tier 学習対象外）" if agent_type_safe == "mainline" else ""
             print(
-                f"{row['agent_type']:<16} {row['runs']:>5}  "
+                f"{agent_type_safe:<16} {row['runs']:>5}  "
                 f"${row['total_cost_usd']:>9.4f}  "
                 f"{row['input_tokens']:>9}  {row['output_tokens']:>9}  "
                 f"{row['cache_read_tokens']:>9}  {row['cache_create_tokens']:>9}"
@@ -194,18 +199,37 @@ def _render_human(snapshot: dict[str, Any]) -> None:
             )
     print()
 
-    print("== Tier 別平均コスト（粗い概算 / 精度向上は v2.24.0） ==")
+    print("== Tier 別平均コスト（粗い概算・session 合計 USD） ==")
     tier_cost = snapshot.get("tier_cost", [])
     if not tier_cost:
         print("（cost 紐づけデータ未収集）")
     else:
         print(f"{'complexity':<12} {'tier':<8} {'sessions':>8}  {'avg_usd':>10}  {'total_usd':>10}")
         for row in tier_cost:
+            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['sessions']:>8}  "
                 f"${row['avg_cost_usd']:>9.4f}  "
                 f"${row['total_cost_usd']:>9.4f}"
             )
     print()
-    print("（注: cost-aware routing 本体（tie-break）実装済み。精度向上は v2.24.0 予定）")
+    print("（注: 粗い概算・session 合計 USD。v2.24.0 より rate セクション追加済み）")
+    print()
+
+    print("== Tier 別 USD/MTok レート（model 一致・tie-break が使用） ==")
+    tier_cost_rate = snapshot.get("tier_cost_rate", [])
+    if not tier_cost_rate:
+        print("（rate データ未収集）")
+    else:
+        print(f"{'complexity':<12} {'tier':<8} {'sessions':>8}  {'rate_usd_per_mtok':>18}")
+        for row in tier_cost_rate:
+            complexity_safe = sanitize_terminal_text(str(row["complexity"]))
+            tier_safe = sanitize_terminal_text(str(row["tier"]))
+            print(
+                f"{complexity_safe:<12} {tier_safe:<8} "
+                f"{row['sessions']:>8}  "
+                f"{row['rate_usd_per_mtok']:>18.4f}"
+            )
+    print()

{claude_code_conductor-2.23.0 → claude_code_conductor-2.24.0}/src/c3/db.py

@@ -792,6 +792,241 @@ def read_tier_cost_for_complexity(
     }
 
 
+# ---------------------------------------------------------------------------
+# v2.24.0: model 一致集計・USD/MTok レート化（精度向上版）
+# ---------------------------------------------------------------------------
+
+
+def _compute_tier_cost_rate_summary(
+    cost_rows: list[tuple],
+    outcome_rows: list[tuple],
+) -> list[dict]:
+    """agent_cost_runs 行リストと tier_recent_outcomes 行リストから
+    (complexity, tier) 別 USD/MTok レートを集計して返す（DB 非依存の純関数）。
+
+    DB に依存しないため、単体テストで任意のデータを直接渡せる。
+
+    集計ステップ:
+      1. cost_rows の各行を pricing.resolve_tier(model) で tier に振り分け。
+         resolve_tier が None の未知モデル行はスキップ。
+      2. (session_id, tier) 粒度で cost_sum と billable_tokens を集約。
+         PK=(session_id, agent_id, model) のため行は元々一意 → 重複排除は構造的に成立。
+      3. outcome_rows の各行 (session_id, task_complexity, tier) を
+         (session_id, tier) バケットと突合し (complexity, tier) 別に集約。
+      4. rate 化: rate_usd_per_mtok = total_cost_usd / (billable_tokens / 1_000_000)。
+         billable_tokens == 0 の (complexity, tier) は除外。
+
+    分母の定義:
+        billable_tokens = input_tokens + output_tokens のみ（cache tokens 除外）。
+        tier_reference_cost が input+output 単価和である次元に揃えるため。
+
+    分子の注記:
+        total_cost_usd は cache コストも含むが、cache 単価は input の約 1/10 と小さく
+        tier 間順位（min-max が見る対象）の単調性は保たれる。
+        厳密な cache 分離は過剰最適化のためスコープ外（v2.24.0 許容）。
+
+    cross-outcome 重複の残存許容:
+        1 session が同一 tier で複数の complexity outcome を持つレアケースでは、
+        その session のコストが複数 (complexity, tier) に重複加算される。
+        session_id JOIN では帰属先 complexity が原理的に不明なため按分は恣意的であり
+        精度を逆に損なう。残存許容・docstring 明記（按分は将来検討）。
+
+    Args:
+        cost_rows: agent_cost_runs の行タプル。
+            各要素: (session_id, model, total_cost_usd, input_tokens, output_tokens)。
+        outcome_rows: tier_recent_outcomes の行タプル。
+            各要素: (session_id, task_complexity, tier)。
+            DISTINCT 化・session_id NOT NULL フィルタ済み想定。
+
+    Returns:
+        dict リスト。キー: complexity / tier / sessions / total_cost_usd /
+        billable_tokens / rate_usd_per_mtok。
+        billable_tokens == 0 の (complexity, tier) は除外。
+        返却順は ``rate_usd_per_mtok`` 降順（既存 ``read_tier_cost_summary`` の
+        ``ORDER BY total_cost_usd DESC`` と対称）。
+    """
+    from c3 import pricing  # noqa: PLC0415
+
+    # Step 1-2: (session_id, tier) 粒度でコスト集約
+    # bucket: {(session_id, tier): {"cost_sum": float, "billable": int}}
+    bucket: dict[tuple[str, str], dict] = {}
+    for row in cost_rows:
+        sess_id, model, total_cost, input_tok, output_tok = row
+        tier = pricing.resolve_tier(model)
+        if tier is None:
+            continue  # 未知モデルはスキップ（read 規約: ログなし）
+        key = (sess_id, tier)
+        if key not in bucket:
+            bucket[key] = {"cost_sum": 0.0, "billable": 0}
+        bucket[key]["cost_sum"] += float(total_cost) if total_cost is not None else 0.0
+        bucket[key]["billable"] += (
+            (int(input_tok) if input_tok else 0)
+            + (int(output_tok) if output_tok else 0)
+        )
+
+    # Step 3: outcome を (complexity, tier) 別に集約
+    # agg: {(complexity, tier): {"sessions": int, "cost_sum": float, "billable": int}}
+    agg: dict[tuple[str, str], dict] = {}
+    for row in outcome_rows:
+        sess_id, complexity, tier = row
+        key_bucket = (sess_id, tier)
+        if key_bucket not in bucket:
+            continue  # cost データがない session は集計対象外
+        agg_key = (complexity, tier)
+        if agg_key not in agg:
+            agg[agg_key] = {"sessions": 0, "cost_sum": 0.0, "billable": 0}
+        agg[agg_key]["sessions"] += 1
+        agg[agg_key]["cost_sum"] += bucket[key_bucket]["cost_sum"]
+        agg[agg_key]["billable"] += bucket[key_bucket]["billable"]
+
+    # Step 4: rate 化・billable == 0 を除外
+    result = []
+    for (complexity, tier), vals in agg.items():
+        billable = vals["billable"]
+        if billable == 0:
+            continue
+        rate = vals["cost_sum"] / (billable / 1_000_000)
+        result.append(
+            {
+                "complexity": complexity,
+                "tier": tier,
+                "sessions": vals["sessions"],
+                "total_cost_usd": vals["cost_sum"],
+                "billable_tokens": billable,
+                "rate_usd_per_mtok": rate,
+            }
+        )
+    result.sort(key=lambda r: r["rate_usd_per_mtok"], reverse=True)
+    return result
+
+
+def read_tier_cost_rate_summary(
+    *,
+    db_path: Path | None = None,
+) -> list[dict]:
+    """model 一致集計で (complexity, tier) 別 USD/MTok レートを返す（精度向上版）。
+
+    v2.23.0 までの ``read_tier_cost_summary`` は session 全体の非 mainline コストを
+    合算しており、outcome の tier の model に限定していなかった（H5 テストが確認）。
+    本関数はこの不正確性を解消し、``pricing.resolve_tier(model)`` による model 一致
+    集計と USD/MTok レート化（``tier_reference_cost`` と同次元）を行う。
+
+    集計アルゴリズム（内部実装は :func:`_compute_tier_cost_rate_summary` 参照）:
+      1. ``agent_cost_runs`` を ``agent_type <> 'mainline'`` で素読み。
+      2. Python 側で各行を ``pricing.resolve_tier(model)`` で tier に振り分け。
+         ``resolve_tier`` が ``None`` の未知モデル行はスキップ。
+      3. ``(session_id, tier)`` 粒度で ``cost_sum`` と
+         ``billable_tokens = input_tokens + output_tokens`` を集約。
+         PK=(session_id, agent_id, model) のため行は元々一意 → 重複排除は構造的に成立。
+      4. ``tier_recent_outcomes`` を
+         ``DISTINCT (session_id, task_complexity, tier)``（``session_id IS NOT NULL``）で読み、
+         ``(session_id, tier)`` バケットと突合して ``(complexity, tier)`` 別に集約。
+      5. rate 化: ``rate_usd_per_mtok = total_cost_usd / (billable_tokens / 1_000_000)``。
+         ``billable_tokens == 0`` の ``(complexity, tier)`` は除外。
+
+    分母の定義:
+        ``billable_tokens = input_tokens + output_tokens`` のみ（cache tokens 除外）。
+        ``tier_reference_cost`` が input+output 単価和である次元に揃えるため。
+
+    分子の注記:
+        ``total_cost_usd`` は cache コストも含むが、cache 単価は input の約 1/10 と小さく
+        tier 間順位（min-max が見る対象）の単調性は保たれる（v2.24.0 許容）。
+
+    cross-outcome 重複の残存許容:
+        1 session が同一 tier で複数の complexity outcome を持つレアケースでは、
+        その session のコストが複数 ``(complexity, tier)`` に重複加算される。
+        session_id JOIN では帰属先 complexity が原理的に不明なため按分は恣意的であり
+        精度を逆に損なう。残存許容・docstring 明記（按分は将来検討）。
+
+    Args:
+        db_path: c3.db のパス。省略時は :func:`locate_c3_db` で探索。
+
+    Returns:
+        各行を dict にしたリスト。キー:
+        ``complexity``(str) / ``tier``(str) / ``sessions``(int) /
+        ``total_cost_usd``(float) / ``billable_tokens``(int) /
+        ``rate_usd_per_mtok``(float)。
+        ``billable_tokens == 0`` の行は除外。
+        テーブル不在 / データ不在 / DB 不在 / エラー時は空リストを返す。
+    """
+    if db_path is None:
+        db_path = locate_c3_db()
+        if db_path is None:
+            return []
+
+    try:
+        conn = sqlite3.connect(str(db_path))
+        try:
+            # WAL は書き込みヘルパー呼び出し時または migrate 時に設定済みの前提
+            # （read_agent_cost_summary 等の read ヘルパーと同方針 / CR-M-001）
+            _apply_busy_timeout(conn)
+            cost_rows = conn.execute(
+                "SELECT session_id, model, total_cost_usd, "
+                "       input_tokens, output_tokens "
+                "FROM agent_cost_runs "
+                "WHERE agent_type <> 'mainline'"
+            ).fetchall()
+            outcome_rows = conn.execute(
+                "SELECT DISTINCT session_id, task_complexity, tier "
+                "FROM tier_recent_outcomes "
+                "WHERE session_id IS NOT NULL"
+            ).fetchall()
+        finally:
+            conn.close()
+    except sqlite3.OperationalError as exc:
+        # テーブル不在（no such table）は [] を返す（DB 未初期化でも止めない）
+        logger.debug(
+            "read_tier_cost_rate_summary: table not found or inaccessible: %s",
+            type(exc).__name__,
+        )
+        return []
+    except Exception as exc:  # noqa: BLE001
+        logger.warning(
+            "read_tier_cost_rate_summary: unexpected error: %s", type(exc).__name__
+        )
+        return []
+
+    return _compute_tier_cost_rate_summary(cost_rows, outcome_rows)
+
+
+def read_tier_cost_rate_for_complexity(
+    complexity: str,
+    *,
+    db_path: Path | None = None,
+) -> dict[str, float]:
+    """complexity 別の tier USD/MTok レートを {tier: rate_usd_per_mtok} で返す（精度向上版）。
+
+    tie-break のハイブリッド cost 源（model 一致集計・rate 化）。
+    complexity 一致 & rate_usd_per_mtok > 0 のみ。
+    ``read_tier_cost_rate_summary`` の薄いラッパー。
+
+    v2.23.0 の ``read_tier_cost_for_complexity``（session 合計 avg_cost_usd）と対称な構造を持ち、
+    cost_map の値を「絶対 USD」から「USD/MTok レート」へ精度向上させた代替関数。
+    これにより fallback の ``tier_reference_cost``（静的 per-MTok 単価）と同次元になり、
+    tie-break の min-max 正規化が同スケールで比較可能になる。
+
+    DB アクセスは ``read_tier_cost_rate_summary`` に委譲するため、
+    DB 例外処理・busy_timeout・read 規約は同関数から継承される。
+    データ/DB 不在で ``read_tier_cost_rate_summary`` が ``[]`` を返す場合、
+    本関数は ``{}`` を返す。
+
+    Args:
+        complexity: フィルタ対象の complexity 値（"simple" / "medium" / "complex"）。
+        db_path: c3.db のパス。省略時は :func:`locate_c3_db` で探索
+                 （``read_tier_cost_rate_summary`` に委譲）。
+
+    Returns:
+        ``{tier: rate_usd_per_mtok}`` の dict。
+        該当データ不在・DB 不在・エラー時は ``{}``。
+    """
+    rows = read_tier_cost_rate_summary(db_path=db_path)
+    return {
+        r["tier"]: r["rate_usd_per_mtok"]
+        for r in rows
+        if r["complexity"] == complexity and r["rate_usd_per_mtok"] > 0
+    }
+
+
 def get_ingest_offset(
     file_key: str,
     *,

{claude_code_conductor-2.23.0 → claude_code_conductor-2.24.0}/tests/hooks/test_select_tier.py

@@ -923,7 +923,7 @@ class TestMainCostMapIntegration:
     ) -> None:
         """cost_tiebreak が発動する状況で main 経由の tier_selection.json に cost_tiebreak=true が出る（AC-2）。
 
-        c3_db.read_tier_cost_for_complexity をモックして measured を注入し、
+        c3_db.read_tier_cost_rate_for_complexity をモックして measured を注入し、
         拮抗する params + 安い tier が選ばれるケースを検証する。
         """
         mod = _load_hook_module()
@@ -931,7 +931,7 @@ class TestMainCostMapIntegration:
         monkeypatch.setattr(mod, "TIER_SELECTION_PATH", str(target))
 
         # haiku と sonnet が拮抗する params (同一 Beta パラメータ、trials >= 30)
-        # read_tier_cost_for_complexity は measured={} を返す（全て静的 fallback）
+        # read_tier_cost_rate_for_complexity は measured={} を返す（全て静的 fallback）
         tiebreak_params = {
             "haiku": (10.0, 10.0, 30),
             "sonnet": (10.0, 10.0, 30),
@@ -940,7 +940,7 @@ class TestMainCostMapIntegration:
 
         mock_c3_db = types.SimpleNamespace(
             read_tier_params=lambda complexity, **kw: tiebreak_params,
-            read_tier_cost_for_complexity=lambda complexity, **kw: {},  # 実測なし → 全て静的 fallback
+            read_tier_cost_rate_for_complexity=lambda complexity, **kw: {},  # 実測なし → 全て静的 fallback
             read_tier_failure_rate=lambda complexity, tier: (None, 0),  # escalation しない
         )
         monkeypatch.setattr(mod, "_load_c3_db_module", lambda: mock_c3_db)
@@ -988,7 +988,7 @@ class TestMainCostMapIntegration:
         }
         mock_c3_db = types.SimpleNamespace(
             read_tier_params=lambda complexity, **kw: dominant_params,
-            read_tier_cost_for_complexity=lambda complexity, **kw: {},
+            read_tier_cost_rate_for_complexity=lambda complexity, **kw: {},
             read_tier_failure_rate=lambda complexity, tier: (None, 0),  # escalation しない
         )
         monkeypatch.setattr(mod, "_load_c3_db_module", lambda: mock_c3_db)
@@ -1003,3 +1003,80 @@ class TestMainCostMapIntegration:
         # 単独最大 → cost_tiebreak キーが出ないはず
         assert "cost_tiebreak" not in sel
         assert sel["tier"] == "haiku"
+
+    def test_main_rate_cost_map_no_crash(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture
+    ) -> None:
+        """main() が read_tier_cost_rate_for_complexity を呼び AttributeError なく完了する（AC-6 単位整合）。
+
+        v2.24.0 で cost_map 源を read_tier_cost_for_complexity から
+        read_tier_cost_rate_for_complexity に切り替えたため、
+        SimpleNamespace に read_tier_cost_rate_for_complexity が存在しないと
+        AttributeError が発生する。この属性名が正しく解決されることを確認。
+        """
+        mod = _load_hook_module()
+        target = tmp_path / "tier_selection.json"
+        monkeypatch.setattr(mod, "TIER_SELECTION_PATH", str(target))
+
+        params = {
+            "haiku": (5.0, 5.0, 20),
+            "sonnet": (5.0, 5.0, 20),
+            "opus": (5.0, 5.0, 20),
+        }
+        # read_tier_cost_rate_for_complexity（旧名なし）のみ定義 → 旧名があると AttributeError
+        mock_c3_db = types.SimpleNamespace(
+            read_tier_params=lambda complexity, **kw: params,
+            read_tier_cost_rate_for_complexity=lambda complexity, **kw: {},  # rate 関数・実測なし
+            read_tier_failure_rate=lambda complexity, tier: (None, 0),
+        )
+        monkeypatch.setattr(mod, "_load_c3_db_module", lambda: mock_c3_db)
+
+        monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps({"prompt": "テスト"})))
+        random.seed(0)
+
+        # AttributeError が発生しないこと、かつ rc=0 であること
+        rc = mod.main()
+        assert rc == 0
+        assert target.is_file()
+
+    def test_main_rate_cost_map_with_measured_uses_rate(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture
+    ) -> None:
+        """main() が rate 実測値を cost_map に使い、静的 fallback と同次元で比較する（AC-6）。
+
+        read_tier_cost_rate_for_complexity が haiku=6.0 USD/MTok を返す場合、
+        cost_map['haiku'] は 6.0 になる（tier_reference_cost('haiku')=6.0 の静的値と同次元）。
+        単位混在が解消されており crash なく rc=0 で完了することを確認。
+
+        NOTE: cost_tiebreak の発動 assert は
+        ``test_main_cost_tiebreak_appears_in_json_when_triggered`` で担保。
+        本テストは rate 関数への切替が AttributeError なく完了することの確認が主眼。
+        """
+        mod = _load_hook_module()
+        target = tmp_path / "tier_selection.json"
+        monkeypatch.setattr(mod, "TIER_SELECTION_PATH", str(target))
+
+        # haiku に実測 rate を返す（tier_reference_cost と同次元 USD/MTok）
+        measured_rates = {"haiku": 6.0}
+
+        params = {
+            "haiku": (10.0, 10.0, 30),
+            "sonnet": (10.0, 10.0, 30),
+            "opus": (1.0, 10.0, 10),
+        }
+        mock_c3_db = types.SimpleNamespace(
+            read_tier_params=lambda complexity, **kw: params,
+            read_tier_cost_rate_for_complexity=lambda complexity, **kw: dict(measured_rates),
+            read_tier_failure_rate=lambda complexity, tier: (None, 0),
+        )
+        monkeypatch.setattr(mod, "_load_c3_db_module", lambda: mock_c3_db)
+
+        monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps({"prompt": "テスト"})))
+        random.seed(0)
+
+        rc = mod.main()
+        assert rc == 0
+        assert target.is_file()
+        sel = json.loads(target.read_text(encoding="utf-8"))
+        # 拮抗群が存在するので cost_tiebreak が発動する可能性があるが crash しないことが重要
+        assert sel.get("tier") in ("haiku", "sonnet", "opus")