xrefkit 0.5.1__tar.gz → 0.6.0__tar.gz

{xrefkit-0.5.1 → xrefkit-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xrefkit
-Version: 0.5.1
+Version: 0.6.0
 Summary: Portable XID, Skill, Knowledge, workflow, and MCP runtime for XRefKit
 Author: synthaicode
 License: MIT License
@@ -47,7 +47,7 @@ record evidence, preserve human judgment, and apply explicit completion checks.
 
 ## Why XRefKit?
 
-Experimental local tool: [Attention Pet](projects/attention-pet/README.md) helps
+Experimental local tool: [Attention Pet](projects/attention-pet/README.en.md) helps
 people assess capability sufficiency and lower inference-cost candidates separately.
 Its Model Fit / Cost Fit estimates use uncalibrated profiles; it does not measure internal
 attention or switch models automatically.
@@ -61,6 +61,11 @@ pet. It also shows lower inference-cost comparison candidates when the
 experimental profiles support one. The estimate is observational and does not
 change the Codex model, reasoning level, or chat.
 
+It does not measure token usage. It estimates the structural complexity of the
+work context the AI must handle, including retained items, dependencies,
+constraints, decision depth, conflicts, and dispersed evidence. It does not
+read model-internal attention or remaining context-window capacity.
+
 Run it from a Codex terminal in this repository so `CODEX_THREAD_ID` identifies
 the current chat:
 
@@ -77,7 +82,7 @@ This Codex preview is bound to the chat that launched it. Selecting another
 chat does not move the Pet automatically; launch it again from that chat when
 you want a separate view. The model and reasoning dropdowns only compare
 estimates and do not change the active Codex settings. See the
-[Attention Pet guide](projects/attention-pet/README.md) for interpretation,
+[Attention Pet guide](projects/attention-pet/README.en.md) for interpretation,
 limitations, client integration, and API details.
 
 Using AI for real work creates recurring operating problems:

{xrefkit-0.5.1 → xrefkit-0.6.0}/README.md

@@ -8,7 +8,7 @@ record evidence, preserve human judgment, and apply explicit completion checks.
 
 ## Why XRefKit?
 
-Experimental local tool: [Attention Pet](projects/attention-pet/README.md) helps
+Experimental local tool: [Attention Pet](projects/attention-pet/README.en.md) helps
 people assess capability sufficiency and lower inference-cost candidates separately.
 Its Model Fit / Cost Fit estimates use uncalibrated profiles; it does not measure internal
 attention or switch models automatically.
@@ -22,6 +22,11 @@ pet. It also shows lower inference-cost comparison candidates when the
 experimental profiles support one. The estimate is observational and does not
 change the Codex model, reasoning level, or chat.
 
+It does not measure token usage. It estimates the structural complexity of the
+work context the AI must handle, including retained items, dependencies,
+constraints, decision depth, conflicts, and dispersed evidence. It does not
+read model-internal attention or remaining context-window capacity.
+
 Run it from a Codex terminal in this repository so `CODEX_THREAD_ID` identifies
 the current chat:
 
@@ -38,7 +43,7 @@ This Codex preview is bound to the chat that launched it. Selecting another
 chat does not move the Pet automatically; launch it again from that chat when
 you want a separate view. The model and reasoning dropdowns only compare
 estimates and do not change the active Codex settings. See the
-[Attention Pet guide](projects/attention-pet/README.md) for interpretation,
+[Attention Pet guide](projects/attention-pet/README.en.md) for interpretation,
 limitations, client integration, and API details.
 
 Using AI for real work creates recurring operating problems:

{xrefkit-0.5.1 → xrefkit-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "xrefkit"
-version = "0.5.1"
+version = "0.6.0"
 description = "Portable XID, Skill, Knowledge, workflow, and MCP runtime for XRefKit"
 readme = "README.md"
 requires-python = ">=3.11"

{xrefkit-0.5.1 → xrefkit-0.6.0}/tests/test_attention_pet_client_protocol.py

@@ -101,10 +101,16 @@ def test_handshake_authentication_and_active_session_switching(tmp_path):
             get("/api/state?lang=fr")
         assert error.value.code == 400
 
-        post("/api/active-session", payload("session-b", 2, 2))
-        second = get("/api/state")
+        next_session = payload("session-b", 2, 2)
+        next_session["model"] = "gpt-6-astra"
+        next_session["reasoning"] = "high"
+        post("/api/active-session", next_session)
+        second = get("/api/state?model=&reasoning=medium")
         assert second["source"]["sessionId"] == "session-b"
+        assert second["fit"]["selectedProfile"] == {"model": "astra", "reasoning": "high"}
         assert second["state"]["features"]["active_items"] == 2
+        manual_comparison = get("/api/state?model=sol&reasoning=medium")
+        assert manual_comparison["fit"]["selectedProfile"] == {"model": "sol", "reasoning": "medium"}
 
         with pytest.raises(HTTPError) as error:
             post("/api/active-session", payload("session-a", 1, 1))
@@ -116,6 +122,95 @@ def test_handshake_authentication_and_active_session_switching(tmp_path):
         thread.join(timeout=5)
 
 
+def test_state_response_keeps_one_session_when_activation_follows_snapshot(tmp_path, monkeypatch):
+    source = ClientStateSource(tmp_path / "sessions", Weights())
+    source.activate(ClientState.model_validate(payload("session-a", 1)))
+    next_session = payload("session-b", 2)
+    next_session["model"] = "gpt-6-astra"
+    next_session["reasoning"] = "high"
+    next_state = ClientState.model_validate(next_session)
+    original_snapshot = source.snapshot
+
+    def switch_after_snapshot(fallback_store):
+        snapshot = original_snapshot(fallback_store)
+        source.activate(next_state)
+        return snapshot
+
+    monkeypatch.setattr(source, "snapshot", switch_after_snapshot)
+    server, launch = make_server(Store(), source=source)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        with urlopen(launch + "api/state?model=&reasoning=medium", timeout=5) as response:
+            before = json.load(response)
+        assert before["state"]["taskId"] == "task-session-a"
+        assert before["source"]["sessionId"] == "session-a"
+        assert before["fit"]["selectedProfile"] == {"model": "sol", "reasoning": "medium"}
+
+        monkeypatch.setattr(source, "snapshot", original_snapshot)
+        with urlopen(launch + "api/state?model=&reasoning=medium", timeout=5) as response:
+            after = json.load(response)
+        assert after["state"]["taskId"] == "task-session-b"
+        assert after["source"]["sessionId"] == "session-b"
+        assert after["fit"]["selectedProfile"] == {"model": "astra", "reasoning": "high"}
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=5)
+
+
+def test_client_snapshot_blocks_activation_until_all_session_fields_are_read(tmp_path, monkeypatch):
+    source = ClientStateSource(tmp_path / "sessions", Weights())
+    source.activate(ClientState.model_validate(payload("session-a", 1)))
+    next_session = payload("session-b", 2)
+    next_session["model"] = "gpt-6-astra"
+    next_session["reasoning"] = "high"
+    next_state = ClientState.model_validate(next_session)
+    view_read = threading.Event()
+    resume_view = threading.Event()
+    activation_started = threading.Event()
+    activation_done = threading.Event()
+    captured = {}
+    original_view = source.view
+
+    def pause_after_view(fallback_store):
+        result = original_view(fallback_store)
+        view_read.set()
+        assert resume_view.wait(timeout=5)
+        return result
+
+    def read_snapshot():
+        captured["snapshot"] = source.snapshot(Store())
+
+    def activate_next():
+        activation_started.set()
+        source.activate(next_state)
+        activation_done.set()
+
+    monkeypatch.setattr(source, "view", pause_after_view)
+    reader = threading.Thread(target=read_snapshot)
+    activator = threading.Thread(target=activate_next)
+    reader.start()
+    try:
+        assert view_read.wait(timeout=5)
+        activator.start()
+        assert activation_started.wait(timeout=5)
+        assert not activation_done.wait(timeout=0.1)
+    finally:
+        resume_view.set()
+        reader.join(timeout=5)
+        if activator.ident is not None:
+            activator.join(timeout=5)
+
+    assert not reader.is_alive() and not activator.is_alive()
+    result, selection, status = captured["snapshot"]
+    assert result["state"]["taskId"] == "task-session-a"
+    assert selection == ("sol", "medium")
+    assert status["sessionId"] == "session-a"
+    assert activation_done.is_set()
+    assert source.status()["sessionId"] == "session-b"
+
+
 def test_client_contract_rejects_mismatched_session_and_manual_mode(tmp_path):
     source = ClientStateSource(tmp_path / "sessions", Weights())
     server, launch = make_server(Store(), source=source)

{xrefkit-0.5.1 → xrefkit-0.6.0}/tests/test_attention_pet_codex_session.py

@@ -38,7 +38,7 @@ def test_one_bound_chat_updates_incrementally_without_saving_text(tmp_path):
     store = Store(saved)
     source.sync(store)
     first = store.view()
-    assert source.selection() == ("sol", "standard")
+    assert source.selection() == ("sol", "medium")
     assert source.status()["observedUserTurns"] == 1
     assert first["state"]["coverage"] == "partial"
     assert len(first["workingSet"]["items"]) == 1
@@ -55,7 +55,7 @@ def test_one_bound_chat_updates_incrementally_without_saving_text(tmp_path):
     assert "この修正は不要" not in saved.read_text(encoding="utf-8")
     append(log, "2026-09-26T12:00:03Z", "turn_context", {"model": "gpt-6-terra", "effort": "low"})
     source.sync(store)
-    assert source.selection() == ("terra", "light")
+    assert source.selection() == ("terra", "low")
     assert store.view() == second
     append(log, "2026-09-26T12:00:04Z", "turn_context", {"model": "unrecognized-model", "effort": "medium"})
     source.sync(store)
@@ -80,7 +80,7 @@ def test_live_api_defaults_to_observed_model_allows_comparison_and_rejects_mutat
         assert value["source"]["mode"] == "codex-chat"
         assert value["source"]["observedUserTurns"] == 1
         assert value["source"]["profile"] == "sol"
-        assert value["source"]["reasoning"] == "standard"
+        assert value["source"]["reasoning"] == "medium"
         assert value["fit"]["selected"]["model"] == "astra"
         assert value["fit"]["selected"]["reasoning"] == "high"
         with urlopen(Request(base + "/api/state?model=&reasoning=standard"), timeout=5) as response:

{xrefkit-0.5.1 → xrefkit-0.6.0}/tests/test_attention_pet_fit.py

@@ -16,6 +16,50 @@ from xrefkit.attention_pet.server import make_server
 from xrefkit.attention_pet.store import Store
 
 
+def test_execution_profile_search_crosses_models_and_efforts(monkeypatch):
+    # Controlled hypotheses make the two cross-axis cases independent of scenario thresholds.
+    state = {"ral": 50, "causes": [], "features": {"active_items": 1},
+             "coverage": "reviewed", "trajectoryEvidence": []}
+    for model, base in (("luna", 20), ("sol", 40)):
+        monkeypatch.setitem(PROFILES, model, PROFILES[model].model_copy(
+            update={"capability": Capability(reasoning=base, constraint_tracking=base,
+                                             evidence_handling=base)}))
+    for model in ("terra", "astra"):
+        monkeypatch.setitem(PROFILES, model, PROFILES[model].model_copy(
+            update={"relative_inference_cost": 100.0}))
+    result = evaluate_fit(state, "sol", "high")
+    assert result["modelFit"] == "Sufficient"
+    assert result["costFit"] == "LowerCostCandidateAvailable"
+    assert { (c["model"], c["reasoning"]) for c in result["lowerCostCandidates"] } >= {
+        ("luna", "xhigh"), ("sol", "medium")}
+    assert not next(c for c in result["alternatives"] if
+                    (c["model"], c["reasoning"]) == ("luna", "high"))["meetsRequirements"]
+    assert result["lowerCostCandidate"] == {"model": "sol", "reasoning": "medium"}
+    assert result["selectedProfile"] == {"model": "sol", "reasoning": "high"}
+    assert result["expectedTotalCost"] is None
+
+    underpowered = evaluate_fit(state, "sol", "low")
+    assert underpowered["modelFit"] == "Underpowered"
+    assert underpowered["costFit"] == "RetryRisk"
+    assert underpowered["lowerCostCandidate"] is None
+    assert underpowered["lowerCostCandidates"] == []
+
+
+def test_unknown_and_legacy_execution_profiles():
+    state = evaluate(task())
+    for model, reasoning in (("absent", "high"), ("sol", "absent"),
+                             ("terra", "xhigh")):
+        result = evaluate_fit(state, model, reasoning)
+        assert result["modelFit"] == result["costFit"] == "Unknown"
+        assert result["presentation"]["petState"] == "Unknown"
+    assert evaluate_fit(state, "sol", "light")["selected"]["reasoning"] == "light"
+    assert evaluate_fit(state, "sol", "standard")["selected"]["reasoning"] == "standard"
+    assert evaluate_fit(state, "sol", "light")["selectedProfile"] == {"model": "sol", "reasoning": "low"}
+    assert evaluate_fit(state, "sol", "standard")["selectedProfile"] == {"model": "sol", "reasoning": "medium"}
+    assert evaluate_fit(state, "sol", "standard")["selected"]["capability"] == \
+        evaluate_fit(state, "sol", "medium")["selected"]["capability"]
+
+
 def task(name="A", step=5):
     return WorkingSet.model_validate(scenario(name, step)["workingSet"])
 
@@ -70,10 +114,10 @@ def test_comparison_is_pure_and_total_cost_is_unknown():
     assert {r["baseRal"] for r in results} == {state["ral"]}
     for result in results:
         assert result["expectedTotalCost"] is None
-        assert all(result[k] is None for k in ("inferenceCost", "retryCost", "correctionCost", "failureRiskCost"))
+        assert all(result[k] is None for k in ("inferenceCost", "retryCost", "correctionCost", "latencyCost", "failureRiskCost"))
         assert result["calibration"] == "uncalibrated"
     assert results[0]["costFit"] == "RetryRisk"
-    assert results[1]["costFit"] == "NoLowerCostCandidate"
+    assert results[1]["costFit"] == "LowerCostCandidateAvailable"
     assert results[2]["costFit"] == "LowerCostCandidateAvailable"
 
 
@@ -121,9 +165,9 @@ def test_schema_matches_python_cost_fit_contract():
 
 
 @pytest.mark.parametrize("name,step,costs,faces", [
-    ("A", 5, ["NoLowerCostCandidate"] + ["LowerCostCandidateAvailable"] * 3, ["Balanced"] + ["Relaxed"] * 3),
-    ("B", 3, ["RetryRisk", "NoLowerCostCandidate", "LowerCostCandidateAvailable", "LowerCostCandidateAvailable"], ["Strained", "Balanced", "Relaxed", "Relaxed"]),
-    ("B", 5, ["RetryRisk"] * 3 + ["NoLowerCostCandidate"], ["Strained"] * 3 + ["Balanced"]),
+    ("A", 5, ["LowerCostCandidateAvailable"] * 4, ["Relaxed"] * 4),
+    ("B", 3, ["RetryRisk"] + ["LowerCostCandidateAvailable"] * 3, ["Strained"] + ["Relaxed"] * 3),
+    ("B", 5, ["RetryRisk"] * 3 + ["LowerCostCandidateAvailable"], ["Strained"] * 3 + ["Relaxed"]),
     ("D", 5, ["RetryRisk"] * 4, ["Strained"] * 4),
     ("C", 3, ["ReviewNeeded"] * 4, ["Review"] * 4),
 ])
@@ -141,11 +185,11 @@ def test_scenarios_separate_cost_and_presentation(name, step, costs, faces):
 
 def test_other_prices_do_not_change_model_fit(monkeypatch):
     state = evaluate(task())
-    before = evaluate_fit(state, "astra")
+    before = evaluate_fit(state, "astra", "low")
     assert before["costFit"] == "LowerCostCandidateAvailable"
     for name in ("luna", "terra", "sol"):
         monkeypatch.setitem(PROFILES, name, PROFILES[name].model_copy(update={"relative_inference_cost": 100.0}))
-    after = evaluate_fit(state, "astra")
+    after = evaluate_fit(state, "astra", "low")
     assert before["modelFit"] == after["modelFit"] == "Sufficient"
     assert after["costFit"] == "NoLowerCostCandidate"
     assert after["lowerCostCandidates"] == []
@@ -153,9 +197,9 @@ def test_other_prices_do_not_change_model_fit(monkeypatch):
 
 @pytest.mark.parametrize("name,step,model,status,target", [
     ("A", 5, "astra", "Available", "Luna"),
-    ("B", 3, "astra", "Available", "Terra"),
-    ("B", 3, "sol", "Available", "Terra"),
-    ("B", 3, "terra", "NoLowerCandidate", None),
+    ("B", 3, "astra", "Available", "Sol"),
+    ("B", 3, "sol", "Available", "Sol"),
+    ("B", 3, "terra", "Available", "Sol"),
     ("B", 3, "luna", "Underpowered", None),
     ("C", 3, "astra", "HoldForReview", None),
     ("D", 5, "astra", "Underpowered", None),
@@ -168,7 +212,7 @@ def test_lowest_sufficient_downgrade_guidance(name, step, model, status, target)
     if target:
         assert f"低コスト比較候補: {target}" in guide["modelGuide"]
         assert target in guide["modelGuideShort"]
-        assert "同じ考える深さ" in guide["modelGuide"]
+        assert " / " in guide["modelGuideShort"]
         assert "再試行・修正時間・失敗損失を含む総コストは未比較" in guide["modelGuideDetail"]
         assert "仮の必要能力3軸を満たす試算" in guide["modelGuideDetail"]
         lowest = min(fit["lowerCostCandidates"], key=lambda c: c["relativeInferenceCost"])
@@ -241,7 +285,7 @@ def test_english_presentation_preserves_evaluation_meaning():
     ("Unknown", "Unknown", "Unknown", "まだ評価できません", "情報が不足"),
     ("Underpowered", "RetryRisk", "Strained", "能力が不足する可能性", "一部を満たしていません"),
     ("Sufficient", "NoLowerCostCandidate", "Balanced", "必要な能力を満たす試算", "候補は確認されていません"),
-    ("Sufficient", "LowerCostCandidateAvailable", "Relaxed", "より低い推論コストの候補", "現在のモデルでも必要能力を満たす試算"),
+    ("Sufficient", "LowerCostCandidateAvailable", "Relaxed", "より低い推論コストの候補", "現在の実行プロファイルでも必要能力を満たす試算"),
     ("Sufficient", "ReviewNeeded", "Review", "実際の結果", "モデル能力だけを原因とは判断していません"),
     ("Underpowered", "ReviewNeeded", "Review", "実際の結果", "モデル能力だけを原因とは判断していません"),
 ])
@@ -309,6 +353,13 @@ def test_profiles_reject_invalid_costs(field, value):
         ModelProfile.model_validate(data)
 
 
+def test_profiles_reject_reasoning_without_depth_definition():
+    data = PROFILES["luna"].model_dump()
+    data["supported_reasoning"] = ("low", "ultra")
+    with pytest.raises(ValidationError, match="unsupported reasoning levels: ultra"):
+        ModelProfile.model_validate(data)
+
+
 def test_api_model_selection_is_read_only_and_invalid_queries_cannot_mutate():
     store = Store()
     before = store.submit(task("B", 3))
@@ -324,6 +375,12 @@ def test_api_model_selection_is_read_only_and_invalid_queries_cannot_mutate():
             return json.load(response)
 
     try:
+        catalog = request("/api/profiles")
+        assert next(p for p in catalog["models"] if p["id"] == "luna")["reasoning"] == [
+            "low", "medium", "high", "xhigh"]
+        assert catalog["legacyAliases"] == {"light": "low", "standard": "medium"}
+        unknown = request("/api/state?model=absent&reasoning=xhigh")
+        assert unknown["fit"]["modelFit"] == "Unknown"
         for model, expected in zip(PROFILES, ["Underpowered", "Sufficient", "Sufficient", "Sufficient"], strict=True):
             value = request(f"/api/state?model={model}&reasoning=standard")
             assert value["fit"]["modelFit"] == expected

{xrefkit-0.5.1 → xrefkit-0.6.0}/xrefkit/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.5.1"
+__version__ = "0.6.0"

{xrefkit-0.5.1 → xrefkit-0.6.0}/xrefkit/attention_pet/client_protocol.py

@@ -93,6 +93,11 @@ class ClientStateSource:
         with self.lock:
             return self._store(self.active).view() if self.active else _fallback_store.view()
 
+    def snapshot(self, fallback_store: Store) -> tuple[dict, tuple[str, str], dict]:
+        """Read the active work, execution profile, and source under one lock."""
+        with self.lock:
+            return self.view(fallback_store), self.selection(), self.status()
+
     def selection(self) -> tuple[str, str]:
         with self.lock:
             state = self.states.get(self.active) if self.active else None
@@ -100,8 +105,8 @@ class ClientStateSource:
                 return "", "standard"
             family = state.model.rsplit("-", 1)[-1]
             model = family if state.model.startswith("gpt-") and family in {"luna", "terra", "sol", "astra"} else ""
-            depth = {"none": "light", "minimal": "light", "low": "light", "medium": "standard",
-                     "high": "high", "xhigh": "high", "max": "high", "ultra": "high"}.get(state.reasoning)
+            depth = {"none": "low", "minimal": "low", "low": "low", "medium": "medium",
+                     "high": "high", "xhigh": "xhigh", "max": "max", "ultra": "max"}.get(state.reasoning)
             return (model, depth) if model and depth else ("", "standard")
 
     def status(self) -> dict:

{xrefkit-0.5.1 → xrefkit-0.6.0}/xrefkit/attention_pet/codex_session.py

@@ -20,8 +20,8 @@ _AMBIENT = re.compile(r"<in-app-browser-context\b[^>]*>.*?</in-app-browser-conte
 _REFERENCE = re.compile(r"(?:^|\s)(?:この|これ|それ|その|同じ|つづけて|続けて)")
 _CONSTRAINT = ("不要", "削除", "しない", "なくす", "やめ", "違う", "おかしい", "修正", "変更")
 _MODEL_SUFFIX = {"luna": "luna", "terra": "terra", "sol": "sol", "astra": "astra"}
-_DEPTH = {"none": "light", "minimal": "light", "low": "light", "medium": "standard",
-          "high": "high", "xhigh": "high", "max": "high", "ultra": "high"}
+_DEPTH = {"none": "low", "minimal": "low", "low": "low", "medium": "medium",
+          "high": "high", "xhigh": "xhigh", "max": "max", "ultra": "max"}
 
 
 def find_rollout(thread_id: str, codex_home: Path) -> Path:

{xrefkit-0.5.1 → xrefkit-0.6.0}/xrefkit/attention_pet/evaluator.py

@@ -1,8 +1,8 @@
 """Explainable heuristic v1. Thresholds are hypotheses, not calibrated probabilities."""
 from dataclasses import dataclass, asdict
 
-from .model import AttentionState, WorkingSet, Capability, FitCandidate, FitEvaluation, ModelProfile, ReasoningDepth
-from .profiles import PROFILES, DEPTHS
+from .model import AttentionState, WorkingSet, Capability, ExecutionProfile, FitCandidate, FitEvaluation, ModelProfile, ReasoningDepth
+from .profiles import PROFILES, DEPTHS, canonical_reasoning, execution_profiles
 from .presentation import present_fit
 
 
@@ -110,6 +110,12 @@ def evaluate(ws: WorkingSet, previous: dict | None = None, history: list[dict] |
     return AttentionState.model_validate(result).model_dump()
 
 
+def profile_capability(profile: ModelProfile, depth: ReasoningDepth) -> Capability:
+    """Replaceable, uncalibrated capability hypothesis for one execution profile."""
+    return Capability(**{k: min(100, max(0, v + depth.capability_modifier))
+                         for k, v in profile.capability.model_dump().items()})
+
+
 def fit_candidate(state: dict, profile: ModelProfile, depth: ReasoningDepth) -> FitCandidate:
     """Model-generated expansion is a projection, never added to actual input/history."""
     base = state["ral"]
@@ -134,8 +140,7 @@ def fit_candidate(state: dict, profile: ModelProfile, depth: ReasoningDepth) ->
         constraint_tracking=min(100, round(.65 * effective + 25 * constraints + 10 * unresolved, 1)),
         evidence_handling=min(100, round(.65 * effective + 35 * evidence, 1)),
     )
-    capability = Capability(**{k: min(100, max(0, v + depth.capability_modifier))
-                               for k, v in profile.capability.model_dump().items()})
+    capability = profile_capability(profile, depth)
     shortfalls = [k for k, need in required.model_dump().items() if capability.model_dump()[k] < need]
     return FitCandidate(model=profile.id, reasoning=depth.id, expansion=expansion,
                         effectiveRal=effective, capability=capability, requiredCapability=required,
@@ -148,14 +153,12 @@ def evaluate_fit(state: dict | None, model: str = "", reasoning: str = "standard
     """Relative quality/cost allocation hypothesis; never a routing decision."""
     if locale not in {"ja", "en"}:
         raise ValueError("unsupported display language")
-    if model and model not in PROFILES:
-        raise ValueError("unknown model profile")
-    if reasoning not in DEPTHS:
-        raise ValueError("unknown reasoning depth")
-    if not model or state is None or not state["features"]["active_items"]:
-        reason = (("Select a model to compare." if not model else "There is no work data to evaluate.")
+    normalized = canonical_reasoning(reasoning)
+    known = model in PROFILES and normalized in DEPTHS and normalized in PROFILES[model].supported_reasoning
+    if not known or state is None or not state["features"]["active_items"]:
+        reason = (("Select a supported model and reasoning level." if not known else "There is no work data to evaluate.")
                   if locale == "en" else
-                  ("比較するモデルを選んでください。" if not model else "判定に使う作業内容がありません。"))
+                  ("対応するモデルと考える深さを選んでください。" if not known else "判定に使う作業内容がありません。"))
         cost_fit = "ReviewNeeded" if state and any(o["kind"] != "validated" for o in state["trajectoryEvidence"]) else "Unknown"
         reasons = [reason]
         if cost_fit == "ReviewNeeded":
@@ -169,10 +172,12 @@ def evaluate_fit(state: dict | None, model: str = "", reasoning: str = "standard
                              baseRal=state["ral"] if state else None).model_dump()
     profile, depth = PROFILES[model], DEPTHS[reasoning]
     selected = fit_candidate(state, profile, depth)
-    candidates = [fit_candidate(state, p, depth) for p in PROFILES.values() if p.id != model]
+    candidates = [fit_candidate(state, p, d) for p, d in execution_profiles()
+                  if (p.id, d.id) != (model, normalized)]
     cheaper = [c for c in candidates if c.meetsRequirements
                and c.relativeInferenceCost < selected.relativeInferenceCost]
-    lowest_sufficient = min(cheaper, key=lambda c: c.relativeInferenceCost, default=None)
+    cheaper.sort(key=lambda c: (c.relativeInferenceCost, c.model, c.reasoning))
+    lowest_sufficient = cheaper[0] if cheaper else None
     axes = ({"reasoning": "reasoning", "constraint_tracking": "constraint tracking",
              "evidence_handling": "evidence handling"} if locale == "en" else
             {"reasoning": "推論", "constraint_tracking": "制約の保持", "evidence_handling": "根拠の扱い"})
@@ -187,21 +192,21 @@ def evaluate_fit(state: dict | None, model: str = "", reasoning: str = "standard
                     "再試行や修正が増える可能性があります。回数・損失は未推定です。"])
     elif cheaper:
         cost_fit = "LowerCostCandidateAvailable"
-        labels = " / ".join(PROFILES[c.model].label for c in cheaper)
-        reasons = (["The selected model meets all three estimated capability requirements.",
-                    f"At the same reasoning depth, {labels} also meets the requirements at a lower relative inference cost.",
+        labels = ", ".join(f"{PROFILES[c.model].label} / {c.reasoning}" for c in cheaper[:3])
+        reasons = (["The selected execution profile meets all three estimated capability requirements.",
+                    f"Across compatible execution profiles, {labels} also meets the requirements at a lower estimated inference-cost index.",
                     "Retries, correction time, and failure losses are not compared. This does not establish equal quality, lower total cost, or a need to change models."]
                    if locale == "en" else
-                   ["選択モデルは仮の必要能力3軸を満たしています。",
-                    f"同じ考える深さで、{labels} も必要能力を満たし、より低い相対推論コストとなる試算です。",
+                    ["選択した実行プロファイルは仮の必要能力3軸を満たしています。",
+                    f"対応する実行プロファイルを横断すると、{labels} も必要能力を満たし、より低い推論コスト指数となる試算です。",
                     "再試行・修正・失敗損失はまだ比較していません。実品質の同等性、総コストの低下、モデル変更の必要性を示すものではありません。"])
     else:
         cost_fit = "NoLowerCostCandidate"
         reasons = (["All estimated capability requirements are met.",
-                    "No registered candidate at the same reasoning depth meets the requirements at a lower relative inference cost. Quality and total-cost advantages are unverified."]
+                    "No registered execution profile meets the requirements at a lower estimated inference-cost index. Quality and total-cost advantages are unverified."]
                    if locale == "en" else
                    ["仮の必要能力を全項目で満たしています。",
-                    "同じ考える深さの登録候補には、より低い相対推論コストで必要能力を満たすものがありません。実品質や総コストの優位性は未確認です。"])
+                    "登録された実行プロファイルには、より低い推論コスト指数で必要能力を満たすものがありません。実品質や総コストの優位性は未確認です。"])
     if any(o["kind"] != "validated" for o in state["trajectoryEvidence"]):
         cost_fit = "ReviewNeeded"
         reasons.append("Failure or correction records require a separate total-cost review including retries and corrections."
@@ -217,6 +222,11 @@ def evaluate_fit(state: dict | None, model: str = "", reasoning: str = "standard
                          presentation=present_fit(model_fit, cost_fit, state["coverage"],
                                                   selected=selected, lowest_sufficient=lowest_sufficient,
                                                   locale=locale),
-                         lowerCostCandidates=cheaper, inferenceCostIndex=selected.relativeInferenceCost,
+                         lowerCostCandidates=(cheaper if cost_fit == "LowerCostCandidateAvailable" else []),
+                         inferenceCostIndex=selected.relativeInferenceCost,
+                         selectedProfile=ExecutionProfile(model=model, reasoning=normalized),
+                         lowerCostCandidate=(ExecutionProfile(model=lowest_sufficient.model,
+                                                               reasoning=lowest_sufficient.reasoning)
+                                             if cost_fit == "LowerCostCandidateAvailable" and lowest_sufficient else None),
                          selected=selected, profile=profile, depth=depth,
                          alternatives=candidates, reasons=reasons).model_dump()

{xrefkit-0.5.1 → xrefkit-0.6.0}/xrefkit/attention_pet/model.py

@@ -100,14 +100,27 @@ class Behavior(Contract):
     compression: float = Field(ge=0, le=1)
 
 
+CANONICAL_REASONING_LEVELS = frozenset({"low", "medium", "high", "xhigh", "max"})
+
+
 class ModelProfile(Contract):
     id: str
     label: str
     capability: Capability
     behavior: Behavior
     relative_inference_cost: float = Field(gt=0, allow_inf_nan=False)
+    supported_reasoning: tuple[str, ...] = ("low", "medium", "high")
     calibration: Literal["uncalibrated"] = "uncalibrated"
 
+    @model_validator(mode="after")
+    def supported_levels_are_distinct(self):
+        if not self.supported_reasoning or len(set(self.supported_reasoning)) != len(self.supported_reasoning):
+            raise ValueError("supported reasoning levels must be nonempty and distinct")
+        unsupported = set(self.supported_reasoning) - CANONICAL_REASONING_LEVELS
+        if unsupported:
+            raise ValueError(f"unsupported reasoning levels: {', '.join(sorted(unsupported))}")
+        return self
+
 
 class ReasoningDepth(Contract):
     id: str
@@ -116,6 +129,11 @@ class ReasoningDepth(Contract):
     cost_modifier: float = Field(gt=0, allow_inf_nan=False)
 
 
+class ExecutionProfile(Contract):
+    model: str
+    reasoning: str
+
+
 class FitCandidate(Contract):
     model: str
     reasoning: str
@@ -157,6 +175,8 @@ class FitEvaluation(Contract):
     presentation: Presentation
     baseRal: int | None = Field(default=None, ge=0, le=100)
     selected: FitCandidate | None = None
+    selectedProfile: ExecutionProfile | None = None
+    lowerCostCandidate: ExecutionProfile | None = None
     profile: ModelProfile | None = None
     depth: ReasoningDepth | None = None
     alternatives: list[FitCandidate] = Field(default_factory=list)
@@ -168,6 +188,7 @@ class FitEvaluation(Contract):
     inferenceCost: None = None
     retryCost: None = None
     correctionCost: None = None
+    latencyCost: None = None
     failureRiskCost: None = None