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

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

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

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

@@ -1,5 +1,46 @@
 # Changelog
 
+## [2.28.0] - 2026-05-27
+
+**recall 増分 rebuild**: `c3 recall rebuild` を全再構築から増分に最適化。未変更チャンクは既存インデックスのベクトルを再利用し、変更/新規チャンクのみ再埋め込みする。律速の埋め込み（fastembed 推論）を削減して rebuild を高速化する。検索結果・インデックス形式は全再構築と一致。**破壊的変更なし**。
+
+### 機能追加
+
+- **`src/c3/cli_recall.py`: `c3 recall rebuild` の増分化**: `(source_type, path, chunk_id)` と `source_hash`（v2 で既に保存済み）が一致する未変更チャンクは旧ベクトルを再利用し、変更/新規チャンクのみ `embed_passages` に渡す。出力は `embedded M / reused K chunks` 形式。`--force` 指定時は従来どおり全再構築。
+- **`src/c3/recall_index.py`: `RecallIndex.get_vector(chunk_id)` / 公開 `content_hash(text)` を追加**: `get_vector` は hnswlib 格納ベクトルを取得（増分時の再利用に使用）。`content_hash` は source_hash 計算を一元化した公開ヘルパー（`build` と `cli_recall` が共用）。
+
+### 変更
+
+- **増分不可時の安全フォールバック**: 既存インデックス不在・`--force`・`load()` 失敗（model/dim 不一致・破損）の場合は全再構築にフォールバックし、stderr に理由（例外型名のみ）を 1 行出力する。
+
+### 後方互換
+
+- 検索結果・インデックス形式は全再構築と完全一致（増分はベクトル再利用のみで意味論を変えない）。
+- `--force` で従来の全再構築を維持。
+- migration 不要。**破壊的変更なし**。
+
+## [2.27.0] - 2026-05-26
+
+**tier-routing λ 機能拡張（CR-Q-001 精緻化・λ 上限 5.0・cli_tier routing パラメータ表示）**: v2.26.0 で繰り越した 3 項目を解消。λ の上限を 1.0 から 5.0 に拡張、cost-aware tie-break の observability フラグを精緻化、`c3 tier stats` に現在の routing パラメータ（λ/ε/escalation）を表示。環境変数未設定時の routing 出力は v2.26.0 と一致。**破壊的変更なし**。
+
+### 機能追加
+
+- **`src/c3/db.py`: `COST_LAMBDA_MIN`（0.0）/ `COST_LAMBDA_MAX`（5.0）定数を追加（SSOT）**: cost-weighted Thompson の λ 妥当域の上限を 1.0 から 5.0 に拡張。これにより最高コスト tier の sample をより強く減点でき、cost を成功率より優先させる調整が可能になる。既存の `[0, 1]` の λ 値は引き続き有効（後方互換）。
+- **`src/c3/db.py`: 公開 `resolve_cost_lambda` / `resolve_epsilon` / `resolve_escalation_threshold` を追加**: 環境変数（`C3_TIER_COST_LAMBDA` / `C3_TIER_EPSILON` / `C3_ESCALATION_THRESHOLD`）の解決ロジックを db.py に SSOT として新設。`cli_tier.py` が現在有効な routing パラメータを表示するために参照する。挙動は hook（`select_tier.py`）の既存 `_resolve_*` と一致し、parity テストで戻り値の一致を担保。
+- **`src/c3/cli_tier.py`: `c3 tier stats` に「routing パラメータ」セクションを追加**: 現在有効な λ（`C3_TIER_COST_LAMBDA`）・ε（`C3_TIER_EPSILON`）・escalation threshold（`C3_ESCALATION_THRESHOLD`）を表示。λ は未設定（v2.25.0 互換）/ 0.0（cost 無視）/ 0 < x ≤ 5（全 tier weighting）で文言を分岐。`--json` 出力にも `routing_params` キーを追加。
+
+### 変更
+
+- **`.claude/hooks/select_tier.py`: `_resolve_cost_lambda` の上限を `COST_LAMBDA_MAX`（5.0）参照に変更**: 従来ハードコードの上限 `1` を db.py の SSOT 定数参照に変更（import 失敗時フォールバック 5.0）。下限も `COST_LAMBDA_MIN`（0.0）参照に統一。
+- **`.claude/hooks/select_tier.py`: CR-Q-001 — `_cost_tiebreak` 経路1 の observability フラグ精緻化**: v2.25.0 互換の ε tie-break 経路で、拮抗群の全 tier コストが同値（`hi == lo`）の場合に `did_tiebreak=False` を返すよう変更。**選ばれる tier は不変**（`argmax(sample)`）で、変わるのは observability のみ。
+
+### 後方互換
+
+- 環境変数未設定時の routing 挙動・選ばれる tier は v2.26.0 と完全一致。
+- λ の既存値（`[0, 1]`）は引き続き有効。上限拡張は許容域の拡大のみ。
+- **observability 出力の差分（CR-Q-001）**: cost-aware tie-break で**全 tier コストが同値**の特定ケースに限り、`tier_selection.json` の `cost_tiebreak: true` キーが**省略**されるようになる（従来は `true` を出力）。routing 決定（選ばれる tier）には影響しない。
+- migration 不要。**破壊的変更なし**。
+
 ## [2.26.0] - 2026-05-26
 
 **cost-weighted Thompson 本格統合（全 tier）・ESCALATION_THRESHOLD 調整可能化**: Thompson Sampling のサンプル値を全 tier でコスト重み付けして routing する機能を導入。failure-rate escalation 閾値を環境変数で調整可能にする。環境変数 3 種すべて未設定で v2.25.0 と完全一致。**破壊的変更なし**。

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

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

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

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

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

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

{claude_code_conductor-2.26.0 → claude_code_conductor-2.28.0}/src/c3/cli_recall.py

@@ -14,7 +14,6 @@ fast even when the embedding model has not yet been downloaded.
 from __future__ import annotations
 
 import argparse
-import hashlib
 import json
 import sys
 from pathlib import Path
@@ -30,6 +29,7 @@ from c3.recall_index import (
     RecallIndex,
     SourceChunk,
     collect_sources,
+    content_hash,
     default_index_paths,
     snippet_of,
     warn_if_stale,
@@ -200,6 +200,58 @@ def _handle_search(args: argparse.Namespace) -> int:
     return 0
 
 
+def _partition_chunks_for_reuse(
+    chunks: list[SourceChunk],
+    old_index: RecallIndex,
+) -> tuple[list[int], dict[int, list[float]], int]:
+    """Partition *chunks* into embed targets and reusable vectors from *old_index*.
+
+    Returns a triple ``(to_embed_indices, reuse_map, reused_count)`` where:
+
+    - ``to_embed_indices``: positions in *chunks* that need fresh embedding
+      (new or content-changed chunks).
+    - ``reuse_map``: ``{chunk_position: vector}`` for unchanged chunks whose
+      vector was successfully retrieved from *old_index*.
+    - ``reused_count``: number of chunks successfully reused.
+
+    The caller is responsible for embedding ``to_embed_indices`` and then
+    assembling the final ``items`` list in original *chunks* order to keep
+    ``build()`` ID assignment consistent with a full rebuild.
+    """
+    # Build a lookup: (source_type, path, chunk_id) -> (source_hash, int_id)
+    old_key_map: dict[tuple[str, str, str], tuple[str, int]] = {}
+    for id_str, rec in old_index.meta.chunks.items():
+        key = (rec.source_type, rec.path, rec.chunk_id)
+        old_key_map[key] = (rec.source_hash, int(id_str))
+
+    # Partition chunks into those that need embedding and those that can be reused.
+    # We fill reuse_map for unchanged slots so the final items list preserves the
+    # original order — this ensures build() assigns sequential IDs identically to
+    # a full rebuild (same order → same IDs → same search results).
+    to_embed_indices: list[int] = []  # indices into chunks that need embedding
+    reuse_map: dict[int, list[float]] = {}  # chunk index → reused vector
+    reused_count = 0
+
+    for i, src in enumerate(chunks):
+        key = (src.source_type, src.path, src.chunk_id)
+        new_hash = content_hash(src.content)
+        if key in old_key_map:
+            old_hash, old_id = old_key_map[key]
+            if old_hash == new_hash:
+                # Unchanged: reuse the stored vector.
+                try:
+                    vec = old_index.get_vector(old_id)
+                    reuse_map[i] = vec
+                    reused_count += 1
+                    continue
+                except Exception:
+                    pass  # Vector retrieval failed; fall through to embed
+        # New or changed chunk: needs embedding.
+        to_embed_indices.append(i)
+
+    return to_embed_indices, reuse_map, reused_count
+
+
 def _handle_rebuild(args: argparse.Namespace) -> int:
     repo_root = _resolve_repo_root(getattr(args, "target", None))
     if repo_root is None:
@@ -225,27 +277,98 @@ def _handle_rebuild(args: argparse.Namespace) -> int:
         )
         return 1
 
-    print(f"[recall] embedding {len(chunks)} chunks...")
-    vectors = embedder.embed_passages([c.content for c in chunks]) if chunks else []
+    index_path, meta_path = default_index_paths(repo_root)
+
+    # ----- incremental path -----
+    # Attempt to load the existing index and reuse vectors for unchanged chunks.
+    # Falls back to full embed when:
+    #   - --force is requested
+    #   - no existing index files
+    #   - load() raises RuntimeError (model/dim mismatch or corrupt meta)
+    #   - any other unexpected error during load
+
+    old_index: RecallIndex | None = None
+    if not args.force and index_path.exists() and meta_path.exists():
+        candidate = RecallIndex(
+            index_path=index_path,
+            meta_path=meta_path,
+            model_name=embedder.model_name,
+            dim=embedder.dim,
+        )
+        try:
+            candidate.load()
+            old_index = candidate
+        except Exception as exc:
+            # CR-E-002/SR-R-004: log the failure reason so operators can diagnose
+            # corrupt or mismatched index files. Exception message is intentionally
+            # omitted (type name only) to avoid leaking internal state — consistent
+            # with the SR-R-001 policy used in _hnsw_save/_hnsw_load.
+            print(
+                f"[recall] 既存 index を読めず増分不可・全再構築にフォールバック: {type(exc).__name__}",
+                file=sys.stderr,
+            )
+            old_index = None
+
     items: list[tuple[ChunkRecord, list[float]]] = []
-    for src, vec in zip(chunks, vectors):
-        # CR-M-04 / SR-L-5: compute source_hash from the full content so that
-        # identical chunks in different files produce the same hash and changed
-        # content is reliably detected across rebuilds.
-        content_hash = hashlib.sha256(
-            src.content.encode("utf-8", errors="replace")
-        ).hexdigest()
-        record = ChunkRecord(
-            source_type=src.source_type,
-            path=src.path,
-            chunk_id=src.chunk_id,
-            snippet=snippet_of(src.content),
-            mtime=src.mtime,
-            source_hash=content_hash,
+
+    if old_index is not None:
+        to_embed_indices, reuse_map, reused_count = _partition_chunks_for_reuse(
+            chunks, old_index
         )
-        items.append((record, vec))
 
-    index_path, meta_path = default_index_paths(repo_root)
+        # Embed only the changed/new chunks.
+        embed_count = len(to_embed_indices)
+        to_embed_contents = [chunks[i].content for i in to_embed_indices]
+        if to_embed_contents:
+            new_vectors = embedder.embed_passages(to_embed_contents)
+        else:
+            new_vectors = []
+
+        # i is always present in embed_vec_map because it was added to
+        # to_embed_indices during _partition_chunks_for_reuse — every chunk
+        # not in reuse_map is guaranteed to have an entry here.
+        embed_vec_map: dict[int, list[float]] = {
+            idx: vec for idx, vec in zip(to_embed_indices, new_vectors)
+        }
+
+        # Build items in original chunks order to preserve ID assignment consistency.
+        for i, src in enumerate(chunks):
+            if i in reuse_map:
+                vec = reuse_map[i]
+            else:
+                # Invariant: i is in to_embed_indices, so it is always present in
+                # embed_vec_map. Every chunk not placed in reuse_map during
+                # _partition_chunks_for_reuse was added to to_embed_indices and
+                # therefore has a corresponding entry in embed_vec_map.
+                vec = embed_vec_map[i]
+            record = ChunkRecord(
+                source_type=src.source_type,
+                path=src.path,
+                chunk_id=src.chunk_id,
+                snippet=snippet_of(src.content),
+                mtime=src.mtime,
+                source_hash=content_hash(src.content),
+            )
+            items.append((record, vec))
+
+        print(f"[recall] embedded {embed_count} / reused {reused_count} chunks")
+    else:
+        # Full embed path (--force, no prior index, or load failure).
+        print(f"[recall] embedding {len(chunks)} chunks...")
+        vectors = embedder.embed_passages([c.content for c in chunks]) if chunks else []
+        for src, vec in zip(chunks, vectors):
+            # CR-M-04 / SR-L-5: compute source_hash from the full content so that
+            # identical chunks in different files produce the same hash and changed
+            # content is reliably detected across rebuilds.
+            record = ChunkRecord(
+                source_type=src.source_type,
+                path=src.path,
+                chunk_id=src.chunk_id,
+                snippet=snippet_of(src.content),
+                mtime=src.mtime,
+                source_hash=content_hash(src.content),
+            )
+            items.append((record, vec))
 
     if args.force:
         for p in (index_path, meta_path):

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

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

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

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

{claude_code_conductor-2.26.0 → claude_code_conductor-2.28.0}/src/c3/recall_index.py

@@ -159,9 +159,7 @@ class RecallIndex:
             # If the caller already computed a hash (e.g. from full content),
             # keep it; otherwise derive from the stored snippet as a fallback.
             if not record.source_hash:
-                record.source_hash = hashlib.sha256(
-                    record.snippet.encode("utf-8", errors="replace")
-                ).hexdigest()
+                record.source_hash = content_hash(record.snippet)
             self._meta.chunks[str(new_id)] = record
         self._index.add_items(vecs, ids)
         self._meta.rebuilt_at = _utcnow_iso()
@@ -293,6 +291,22 @@ class RecallIndex:
     def chunk_count(self) -> int:
         return len(self._meta.chunks)
 
+    def get_vector(self, chunk_id: int) -> list[float]:
+        """Return the stored vector for ``chunk_id`` as ``list[float]``.
+
+        Raises ``RuntimeError`` if the index has not been built or loaded yet.
+        Propagates hnswlib's exception (typically ``RuntimeError`` or
+        ``IndexError``) when ``chunk_id`` is not present in the index.
+        """
+        if self._index is None:
+            raise RuntimeError(
+                "index has not been built or loaded; call build() or load() first"
+            )
+        # hnswlib.get_items returns a 2-D array of shape (n, dim).
+        # We pass a single-element list and take the first row.
+        result = self._index.get_items([chunk_id])
+        return [float(x) for x in result[0]]
+
     # ----- internals -----
 
     def _new_index(self, *, max_elements: int):
@@ -475,6 +489,17 @@ def is_stale(repo_root: Path, index_path: Path) -> bool:
 # ----- helpers -----
 
 
+def content_hash(text: str) -> str:
+    """Return the SHA-256 hex digest of *text* encoded as UTF-8.
+
+    ``errors="replace"`` ensures arbitrary Unicode input never raises.
+    This is the canonical hash used for incremental-rebuild change detection
+    (``cli_recall._handle_rebuild``) and as the ``source_hash`` fallback in
+    :meth:`RecallIndex.build`.
+    """
+    return hashlib.sha256(text.encode("utf-8", errors="replace")).hexdigest()
+
+
 def snippet_of(text: str, *, max_chars: int = SNIPPET_CHARS) -> str:
     """Return a stable preview of ``text`` for storage / display."""
     text = (text or "").strip()