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

{claude_code_conductor-2.23.0 → claude_code_conductor-2.25.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,10 @@ 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
 except ImportError:
     LEARNING_THRESHOLD = 30
+    EPSILON = 0.05
 
 # 複雑度推定のキーワード
 SIMPLE_KEYWORDS = frozenset({
@@ -111,10 +114,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):
@@ -144,8 +146,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 分を
@@ -295,6 +297,7 @@ def select_tier_detailed(
     *,
     rng: random.Random | None = None,
     cost_map: dict[str, float] | None = None,
+    epsilon: float | None = None,
 ) -> SelectionResult:
     """Beta サンプリングまたは uniform 選択で推奨 Tier を SelectionResult で返す。
 
@@ -307,6 +310,7 @@ def select_tier_detailed(
             含む完全な dict」のいずれか。partial dict は渡されない前提
             （呼び出し側が全 TIERS 分を構築して保証する）。
             uniform 分岐では cost_map の有無に関わらず完全無視する（探索保護）。
+        epsilon: 拮抗判定閾値。None なら module 定数 EPSILON を使う（C3_TIER_EPSILON で上書き可）。
 
     Returns:
         SelectionResult（tier, mode, cost_tiebreak, contenders）。
@@ -323,7 +327,8 @@ 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)
+    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)
 
 
@@ -332,6 +337,7 @@ def select_tier(
     *,
     rng: random.Random | None = None,
     cost_map: dict[str, float] | None = None,
+    epsilon: float | None = None,
 ) -> tuple[str, str]:
     """Beta サンプリングまたは uniform 選択で推奨 Tier を返す。
 
@@ -343,13 +349,14 @@ def select_tier(
             None なら cost を見ず従来の Thompson Sampling と完全一致。
             uniform 分岐では cost_map の有無に関わらず完全無視する。
             詳細は :func:`select_tier_detailed` を参照。
+        epsilon: 拮抗判定閾値。None なら module 定数 EPSILON を使う。
 
     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)
     return result.tier, result.mode
 
 
@@ -522,6 +529,41 @@ 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 main() -> int:
     try:
         payload = json.loads(sys.stdin.read())
@@ -556,14 +598,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:
@@ -575,7 +618,8 @@ def main() -> int:
         except ImportError:
             cost_map = None
 
-    result = select_tier_detailed(params, cost_map=cost_map)
+    eps = _resolve_epsilon()
+    result = select_tier_detailed(params, cost_map=cost_map, epsilon=eps)
     tier, mode = result.tier, result.mode
     cost_tiebreak = result.cost_tiebreak
 

{claude_code_conductor-2.23.0 → claude_code_conductor-2.25.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.23.0 → claude_code_conductor-2.25.0}/CHANGELOG.md

@@ -1,5 +1,55 @@
 # Changelog
 
+## [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 ロジックは完全不変。
+
+**スコープ注記**:
+- `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.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-conductor
-Version: 2.23.0
+Version: 2.25.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 件数指定） |
 
 ### 基本的な使い方
 

{claude_code_conductor-2.23.0 → claude_code_conductor-2.25.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 件数指定） |
 
 ### 基本的な使い方
 

{claude_code_conductor-2.23.0 → claude_code_conductor-2.25.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.25.0"

{claude_code_conductor-2.23.0 → claude_code_conductor-2.25.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__)
@@ -93,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:
@@ -100,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,
@@ -107,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(
@@ -118,6 +127,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 +144,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,
     }
 
 
@@ -150,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()
 
@@ -184,9 +202,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 +213,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()