eq-layer 0.2.3__tar.gz → 0.2.5__tar.gz

eq_layer-0.2.5/.gitignore

@@ -0,0 +1,23 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+.env
+.npmrc
+.DS_Store
+.idea/
+.vscode/
+
+# Python test/build outputs
+.coverage
+coverage.xml
+htmlcov/
+dist/
+build/
+*.egg-info/
+.pytest_cache/
+
+# Retired release trigger files (publishing is dispatched explicitly; see
+# .github/workflows/create-release.yml and .github/workflows/publish-npm.yml)
+.npm-release-request
+.release-trigger

{eq_layer-0.2.3 → eq_layer-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: eq-layer
-Version: 0.2.3
+Version: 0.2.5
 Summary: Inspectable intent, affect, repair, uncertainty, and factored-action control for LLM responses
 Project-URL: Homepage, https://github.com/Furox-Art/eq-layer
 Project-URL: Repository, https://github.com/Furox-Art/eq-layer
@@ -51,7 +51,7 @@ So this repo does not retrain the model. It adds a layer:
 1. **Affect state** — `{valence, arousal, escalation_delta, stance, subtext}` as an explicit intermediate representation, tracked across turns. `escalation_delta` is the point: snapshot classification cannot see a trend.
 2. **Intent belief state** — the learned classifier preserves the full posterior over `action_request/status_check/explanation/question/statement/unknown` instead of collapsing uncertainty to one confidence number. A transparent one-step Bayes-risk router chooses whether to act or clarify from that distribution. This is POMDP-inspired uncertainty handling, not a full POMDP.
 3. **Conversation health state** — `repair` identifies observable user→assistant misalignment and its target; `interaction_quality` tracks structural conversation failure separately from emotion using current score, delta, repeated failures, unresolved repair, and clarification load.
-4. **Policy selection** — affect and intent jointly choose a response-policy family (`mirror`, `direct`, `repair`, `hold`, `boundary`, ...). Selection is a discrete decision, not generation.
+4. **Policy selection** — affect and intent jointly choose a response-policy family (`mirror`, `validate_redirect`, `direct`, `ask`, `deflate`, `repair`, `hold`, `boundary`). Selection is a discrete decision, not generation.
 5. **Factored action compilation** — the selected policy is split into orthogonal controls: `task_move`, `social_move`, `repair_move`, and `realization`. The task is driven primarily by user intent, so affective adaptation cannot silently replace what the user actually asked for.
 6. **Steering** — the factored action, source policy, repair state, interaction quality, and canonical request are injected into the decode path so the control decision actually lands in the tokens.
 7. **Structural response audit** — the generated response is checked against inspectable control contracts such as question budget, required clarification, unsupported privacy promises, unknown-stance admissions, repair repetition, and low-verbosity overruns. This is not a factual truth checker.
@@ -112,12 +112,19 @@ paths and source documentation.
 
 ## Quick start
 
-Install the learned intent tracker:
+Install the Python runtime:
 
 ```bash
 pip install "eq-layer[ml]"
 ```
 
+Install the npm skill installer and CLI bridge (Node >= 22.14):
+
+```bash
+npm install -g eq-layer
+npx eq-layer --help
+```
+
 ```python
 from eq_layer import ConversationTracker, Selector, Steer, TrainedAffect, TrainedIntent, TrainedSubtext, compose_action
 
@@ -147,6 +154,18 @@ prompt = Steer.build(
 ).apply_to_prompt(messages[-1]["content"])
 ```
 
+The two `.joblib` files under `artifacts/` are **not shipped** in the
+repository, the PyPI wheel, or the npm tarball. Produce them with the training
+commands below (`tools/train_emobank_affect.py` and
+`tools/train_xdailydialog_subtext.py`) before running this block. Without those
+artifacts, use the zero-dependency route, which reports
+`"runtime_mode": "lightweight-local"` and needs no `.joblib` file:
+
+```bash
+printf '%s' '[{"role":"user","content":"devam et"}]' \
+  | python -m eq_layer.cli route --intent-mode heuristic --pretty
+```
+
 Run the seeded cases. Exits non-zero on any mismatch or any policy that no
 case can reach:
 
@@ -562,16 +581,20 @@ bridge). Each side keeps its version in exactly one canonical location, and the
 release workflows verify the GitHub release tag against those fields before
 uploading.
 
-npm publishing picks its credential mode at run time, based on repository
-settings only:
-
-- `NPM_TOKEN` configured: token mode, `npm publish --access public
-  --no-provenance`;
-- no `NPM_TOKEN`: trusted publishing over GitHub OIDC, `npm publish
-  --access public --provenance`.
-
-Provenance is an OIDC-only attestation, so it is only requested when no token is
-configured. See `docs/PUBLISHING.md` for the full flow.
+`.github/workflows/create-release.yml` is the release entry point: a push to
+`main` that changes `.release-request` creates the GitHub release when missing
+and explicitly dispatches both publishers (`release.yml` for PyPI and
+`publish-npm.yml` for npm). A release tag on its own does not publish npm;
+GitHub suppresses the `release` event for releases created with `GITHUB_TOKEN`,
+so the explicit dispatch is required.
+
+npm publishing uses trusted publishing over GitHub OIDC by default and requests
+a provenance attestation (`npm publish --access public --provenance`). The
+presence of an `NPM_TOKEN` secret does **not** change that: token mode runs only
+when a maintainer explicitly dispatches `publish-npm.yml` with
+`use_token_fallback=true`. That fallback publishes with
+`npm publish --access public --no-provenance`, because provenance is an
+OIDC-only attestation. See `docs/PUBLISHING.md` for the full flow.
 
 ## Contributing
 

{eq_layer-0.2.3 → eq_layer-0.2.5}/README.md

@@ -16,7 +16,7 @@ So this repo does not retrain the model. It adds a layer:
 1. **Affect state** — `{valence, arousal, escalation_delta, stance, subtext}` as an explicit intermediate representation, tracked across turns. `escalation_delta` is the point: snapshot classification cannot see a trend.
 2. **Intent belief state** — the learned classifier preserves the full posterior over `action_request/status_check/explanation/question/statement/unknown` instead of collapsing uncertainty to one confidence number. A transparent one-step Bayes-risk router chooses whether to act or clarify from that distribution. This is POMDP-inspired uncertainty handling, not a full POMDP.
 3. **Conversation health state** — `repair` identifies observable user→assistant misalignment and its target; `interaction_quality` tracks structural conversation failure separately from emotion using current score, delta, repeated failures, unresolved repair, and clarification load.
-4. **Policy selection** — affect and intent jointly choose a response-policy family (`mirror`, `direct`, `repair`, `hold`, `boundary`, ...). Selection is a discrete decision, not generation.
+4. **Policy selection** — affect and intent jointly choose a response-policy family (`mirror`, `validate_redirect`, `direct`, `ask`, `deflate`, `repair`, `hold`, `boundary`). Selection is a discrete decision, not generation.
 5. **Factored action compilation** — the selected policy is split into orthogonal controls: `task_move`, `social_move`, `repair_move`, and `realization`. The task is driven primarily by user intent, so affective adaptation cannot silently replace what the user actually asked for.
 6. **Steering** — the factored action, source policy, repair state, interaction quality, and canonical request are injected into the decode path so the control decision actually lands in the tokens.
 7. **Structural response audit** — the generated response is checked against inspectable control contracts such as question budget, required clarification, unsupported privacy promises, unknown-stance admissions, repair repetition, and low-verbosity overruns. This is not a factual truth checker.
@@ -77,12 +77,19 @@ paths and source documentation.
 
 ## Quick start
 
-Install the learned intent tracker:
+Install the Python runtime:
 
 ```bash
 pip install "eq-layer[ml]"
 ```
 
+Install the npm skill installer and CLI bridge (Node >= 22.14):
+
+```bash
+npm install -g eq-layer
+npx eq-layer --help
+```
+
 ```python
 from eq_layer import ConversationTracker, Selector, Steer, TrainedAffect, TrainedIntent, TrainedSubtext, compose_action
 
@@ -112,6 +119,18 @@ prompt = Steer.build(
 ).apply_to_prompt(messages[-1]["content"])
 ```
 
+The two `.joblib` files under `artifacts/` are **not shipped** in the
+repository, the PyPI wheel, or the npm tarball. Produce them with the training
+commands below (`tools/train_emobank_affect.py` and
+`tools/train_xdailydialog_subtext.py`) before running this block. Without those
+artifacts, use the zero-dependency route, which reports
+`"runtime_mode": "lightweight-local"` and needs no `.joblib` file:
+
+```bash
+printf '%s' '[{"role":"user","content":"devam et"}]' \
+  | python -m eq_layer.cli route --intent-mode heuristic --pretty
+```
+
 Run the seeded cases. Exits non-zero on any mismatch or any policy that no
 case can reach:
 
@@ -527,16 +546,20 @@ bridge). Each side keeps its version in exactly one canonical location, and the
 release workflows verify the GitHub release tag against those fields before
 uploading.
 
-npm publishing picks its credential mode at run time, based on repository
-settings only:
-
-- `NPM_TOKEN` configured: token mode, `npm publish --access public
-  --no-provenance`;
-- no `NPM_TOKEN`: trusted publishing over GitHub OIDC, `npm publish
-  --access public --provenance`.
-
-Provenance is an OIDC-only attestation, so it is only requested when no token is
-configured. See `docs/PUBLISHING.md` for the full flow.
+`.github/workflows/create-release.yml` is the release entry point: a push to
+`main` that changes `.release-request` creates the GitHub release when missing
+and explicitly dispatches both publishers (`release.yml` for PyPI and
+`publish-npm.yml` for npm). A release tag on its own does not publish npm;
+GitHub suppresses the `release` event for releases created with `GITHUB_TOKEN`,
+so the explicit dispatch is required.
+
+npm publishing uses trusted publishing over GitHub OIDC by default and requests
+a provenance attestation (`npm publish --access public --provenance`). The
+presence of an `NPM_TOKEN` secret does **not** change that: token mode runs only
+when a maintainer explicitly dispatches `publish-npm.yml` with
+`use_token_fallback=true`. That fallback publishes with
+`npm publish --access public --no-provenance`, because provenance is an
+OIDC-only attestation. See `docs/PUBLISHING.md` for the full flow.
 
 ## Contributing
 

{eq_layer-0.2.3 → eq_layer-0.2.5}/eq_layer/__init__.py

@@ -7,7 +7,9 @@ from .intent import HeuristicIntent, IntentAdapter, IntentState
 from .intent_belief import IntentBelief, IntentRiskDecision, decide_intent_action, expected_loss
 from .interaction import InteractionQualityState, RepairState, infer_interaction_quality, infer_repair_state
 from .model_state import ModelStateError
-from .policies import POLICIES, REGISTRY, SUBTEXTS, AffectState, Policy, Register, Selector
+from . import policies as _policies
+from .policies import REGISTRY, SUBTEXTS, AffectState, Policy, Register, Selector
+
 from .preferences import SessionPreferences, infer_session_preferences
 from .response_experiment import (
     CommandModel,
@@ -22,6 +24,10 @@ from .trained_intent import TrainedIntent
 from .trained_subtext import DialogueSignals, SubtextDecision, TrainedSubtext
 from .tracker import AnnotationStanceResolver, ConversationTracker, StanceDecision, TrackingResult
 
+# Snapshot re-export: code that must observe runtime overrides reads
+# eq_layer.policies.POLICIES instead.
+POLICIES = _policies.POLICIES
+
 __all__ = [
     "__version__",
     "OptionalDependencyError",

{eq_layer-0.2.3 → eq_layer-0.2.5}/eq_layer/ab_eval.py

@@ -6,6 +6,7 @@ import random
 from dataclasses import dataclass
 from pathlib import Path
 
+from .json_contract import loads as strict_json_loads
 
 DIMENSIONS = (
     "intent_fidelity",
@@ -17,8 +18,20 @@ DIMENSIONS = (
 
 
 def load_jsonl(path: str | Path) -> list[dict]:
+    """Read human-evaluation artifacts without ambiguous JSON interpretation."""
+    rows: list[dict] = []
     with open(path, encoding="utf-8") as fh:
-        return [json.loads(line) for line in fh if line.strip()]
+        for lineno, line in enumerate(fh, start=1):
+            if not line.strip():
+                continue
+            try:
+                row = strict_json_loads(line)
+            except (ValueError, UnicodeError) as exc:
+                raise ValueError(f"{path}:{lineno}: invalid evaluation JSON: {exc}") from exc
+            if not isinstance(row, dict):
+                raise ValueError(f"{path}:{lineno}: evaluation row must be an object")
+            rows.append(row)
+    return rows
 
 
 def write_jsonl(path: str | Path, rows: list[dict]) -> None:
@@ -47,15 +60,25 @@ def prepare_blinded(
 
     seen: set[str] = set()
     for row in pairs:
-        case_id = str(row["id"])
+        case_id = row["id"]
+        if not isinstance(case_id, str) or not case_id.strip():
+            raise ValueError("A/B case id must be a non-empty string")
         if case_id in seen:
             raise ValueError(f"Duplicate A/B case id: {case_id}")
         seen.add(case_id)
 
-        baseline = str(row["baseline"])
-        eq_response = str(row["eq"])
-        if not baseline.strip() or not eq_response.strip():
-            raise ValueError(f"Empty response in A/B case: {case_id}")
+        baseline = row["baseline"]
+        eq_response = row["eq"]
+        if (
+            not isinstance(baseline, str)
+            or not isinstance(eq_response, str)
+            or not baseline.strip()
+            or not eq_response.strip()
+        ):
+            raise ValueError(f"A/B responses must be non-empty strings: {case_id}")
+        source = row.get("source") or {}
+        if not isinstance(source, dict):
+            raise ValueError(f"A/B case source must be an object: {case_id}")
 
         eq_is_a = bool(rng.getrandbits(1))
         response_a = eq_response if eq_is_a else baseline
@@ -67,7 +90,7 @@ def prepare_blinded(
         ballot.append(
             {
                 "id": case_id,
-                "stratum": (row.get("source") or {}).get("stratum"),
+                "stratum": source.get("stratum"),
                 "context": row.get("context", []),
                 "response_A": response_a,
                 "response_B": response_b,
@@ -89,7 +112,9 @@ class PreferenceSummary:
     exact_p_two_sided: float | None
 
 
-def _wilson_interval(successes: int, total: int, z: float = 1.959963984540054) -> tuple[float, float]:
+def _wilson_interval(
+    successes: int, total: int, z: float = 1.959963984540054
+) -> tuple[float, float]:
     if total <= 0:
         raise ValueError("Wilson interval requires total > 0.")
     p = successes / total
@@ -141,6 +166,20 @@ def summarize(wins: int, losses: int, ties: int) -> PreferenceSummary:
     )
 
 
+def _validate_decode_arms(case_id: str, key: dict) -> dict[str, str]:
+    """A blinded pair must decode to one EQ arm and one control arm."""
+    mapping = key.get(case_id)
+    if mapping is None:
+        raise ValueError(f"Missing decode key for case: {case_id}")
+    if (
+        not isinstance(mapping, dict)
+        or set(mapping) != {"A", "B"}
+        or {mapping["A"], mapping["B"]} != {"eq", "baseline"}
+    ):
+        raise ValueError(f"Invalid or non-blinded decode key for case: {case_id}")
+    return mapping
+
+
 def score_blinded(
     rated_ballot: list[dict],
     key: dict,
@@ -152,15 +191,17 @@ def score_blinded(
         for dimension in DIMENSIONS
     }
     excluded: list[str] = []
+    seen_ids: set[str] = set()
 
     for row in rated_ballot:
         case_id = str(row["id"])
+        if case_id in seen_ids:
+            raise ValueError(f"Duplicate case id in rated ballot: {case_id}")
+        seen_ids.add(case_id)
         if exclude_ids and case_id in exclude_ids:
             excluded.append(case_id)
             continue
-        if case_id not in key:
-            raise ValueError(f"Missing decode key for case: {case_id}")
-
+        arm_mapping = _validate_decode_arms(case_id, key)
         ratings = row.get("ratings") or {}
         for dimension in DIMENSIONS:
             vote = str(ratings.get(dimension, "")).strip().upper()
@@ -173,13 +214,12 @@ def score_blinded(
                 counts[dimension]["ties"] += 1
                 continue
 
-            winner = key[case_id][vote]
+            winner = arm_mapping[vote]
+            # _validate_decode_arms already proves the target is eq or baseline.
             if winner == "eq":
                 counts[dimension]["wins"] += 1
-            elif winner == "baseline":
-                counts[dimension]["losses"] += 1
             else:
-                raise ValueError(f"Invalid decode key target: {winner}")
+                counts[dimension]["losses"] += 1
 
     report = {
         "design": "blind-pairwise-human-evaluation",
@@ -204,8 +244,7 @@ def score_blinded(
 
 def _decoded_vote(row: dict, key: dict, dimension: str) -> str:
     case_id = str(row["id"])
-    if case_id not in key:
-        raise ValueError(f"Missing decode key for case: {case_id}")
+    arm_mapping = _validate_decode_arms(case_id, key)
     ratings = row.get("ratings") or {}
     vote = str(ratings.get(dimension, "")).strip().upper()
     if vote == "TIE":
@@ -214,10 +253,8 @@ def _decoded_vote(row: dict, key: dict, dimension: str) -> str:
         raise ValueError(
             f"{case_id}/{dimension}: expected A, B, or tie; got {vote!r}"
         )
-    winner = key[case_id][vote]
-    if winner not in {"eq", "baseline"}:
-        raise ValueError(f"Invalid decode key target: {winner}")
-    return winner
+    # _validate_decode_arms has already rejected every other mapping target.
+    return arm_mapping[vote]
 
 
 def _fleiss_kappa(case_votes: list[list[str]]) -> float | None:
@@ -275,6 +312,8 @@ def score_multiple_blinded(
         rows_by_rater[rater_id] = mapping
 
     assert case_ids is not None
+    if not case_ids:
+        raise ValueError("Multi-rater scoring requires at least one rated case.")
     report = {
         "design": "blind-pairwise-multi-rater-human-evaluation",
         "n_raters": len(rated_ballots),

{eq_layer-0.2.3 → eq_layer-0.2.5}/eq_layer/affect.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
-import json
+from collections.abc import Iterable
 from dataclasses import dataclass
-from typing import Iterable, Protocol
+from typing import Protocol
 
+from .json_contract import loads as strict_json_loads
 from .policies import AffectState
 
 
@@ -15,7 +16,8 @@ class AffectAdapter(Protocol):
         messages: list[dict],
         turn_index: int = 0,
         annotated: dict | None = None,
-    ) -> AffectState: ...
+    ) -> AffectState:
+        pass  # pragma: no cover - Protocol stub
 
 
 # --- detectors -----------------------------------------------------------
@@ -93,7 +95,9 @@ class HeuristicAffect:
         low = text.lower().strip()
         hits = sum(1 for m in ESCALATION_MARKERS if m in low)
         softens = sum(1 for s in SOFTENERS if s in low)
-        score = min(1.0, 0.25 + hits * 0.22 - softens * 0.12)
+        # Arousal is a [0, 1] scale: a softening-only turn must floor at 0, not
+        # go negative and hand the policy state an impossible value.
+        score = max(0.0, min(1.0, 0.25 + hits * 0.22 - softens * 0.12))
         if "?" in low or "!" in low:
             score = min(1.0, score + 0.1)
         return round(score, 3)
@@ -110,11 +114,13 @@ class HeuristicAffect:
 
     def _escalating(self, user_turns: list[str]) -> bool:
         """Three or more consecutive turns opening with a wh-word."""
-        if len(user_turns) < 3:
+        # Blank turns are not wh-word turns. Counting them let three turns in
+        # which only one or two actually opened with a wh-word read as a
+        # three-turn interrogation run. Same filter as ``_demand_pattern``.
+        recent = [t for t in user_turns[-3:] if t.strip()]
+        if len(recent) < 3:
             return False
-        return all(
-            self._first_word(t) in QUESTION_OPENERS for t in user_turns[-3:] if t.strip()
-        )
+        return all(self._first_word(t) in QUESTION_OPENERS for t in recent)
 
     def _first_word(self, text: str) -> str:
         """First token with punctuation stripped. 'Neden?' must match 'neden',
@@ -144,7 +150,6 @@ class HeuristicAffect:
         has_prior_assistant: bool = False,
     ) -> str:
         current = user_turns[-1] if user_turns else ""
-        low = current.lower()
 
         if has_prior_assistant and self._has(current, CORRECTION_MARKERS):
             return "correction"
@@ -223,5 +228,16 @@ class HeuristicAffect:
 
 
 def load_cases(path: str) -> list[dict]:
+    cases: list[dict] = []
     with open(path, encoding="utf-8") as fh:
-        return [json.loads(line) for line in fh if line.strip()]
+        for lineno, line in enumerate(fh, start=1):
+            if not line.strip():
+                continue
+            try:
+                case = strict_json_loads(line)
+            except (ValueError, UnicodeError) as exc:
+                raise ValueError(f"{path}:{lineno}: invalid JSON case: {exc}") from exc
+            if not isinstance(case, dict):
+                raise ValueError(f"{path}:{lineno}: JSON case must be an object")
+            cases.append(case)
+    return cases

{eq_layer-0.2.3 → eq_layer-0.2.5}/eq_layer/cli.py

@@ -8,10 +8,11 @@ import sys
 from dataclasses import asdict
 
 from ._deps import ML_INSTALL_COMMAND, OptionalDependencyError, ml_extra_available
+from .json_contract import loads as strict_json_loads
 
 
 def _load_messages(raw: str) -> list[dict]:
-    payload = json.loads(raw)
+    payload = strict_json_loads(raw)
     if isinstance(payload, dict):
         payload = payload.get("messages")
     if not isinstance(payload, list) or not payload:
@@ -20,12 +21,18 @@ def _load_messages(raw: str) -> list[dict]:
     for index, item in enumerate(payload):
         if not isinstance(item, dict):
             raise ValueError(f"message {index} must be an object")
-        role = str(item.get("role") or "")
-        content = str(item.get("content") or "")
-        if role not in {"user", "assistant", "system"}:
+        role = item.get("role")
+        content = item.get("content")
+        if not isinstance(role, str) or role not in {"user", "assistant", "system"}:
             raise ValueError(f"message {index} has unsupported role {role!r}")
+        if not isinstance(content, str):
+            raise ValueError(f"message {index} content must be a string")
         if not content.strip():
             raise ValueError(f"message {index} has empty content")
+        try:
+            content.encode("utf-8")
+        except UnicodeError as exc:
+            raise ValueError(f"message {index} content must be valid UTF-8") from exc
         messages.append({"role": role, "content": content})
     if not any(message["role"] == "user" for message in messages):
         raise ValueError("Transcript must contain at least one user turn.")
@@ -179,8 +186,9 @@ def main(argv: list[str] | None = None) -> int:
         print(f"{parser.prog}: error: {exc}", file=sys.stderr)
         return 2
     except (ValueError, json.JSONDecodeError, ImportError) as exc:
+        # ArgumentParser.error terminates with SystemExit(2).
         parser.error(str(exc))
-    return 2
+        return 2  # pragma: no cover - parser.error raises SystemExit
 
 
 if __name__ == "__main__":

{eq_layer-0.2.3 → eq_layer-0.2.5}/eq_layer/intent.py

@@ -27,7 +27,8 @@ class IntentState:
 class IntentAdapter(Protocol):
     name: str
 
-    def infer(self, messages: list[dict]) -> IntentState: ...
+    def infer(self, messages: list[dict]) -> IntentState:
+        pass  # pragma: no cover - Protocol stub
 
 
 ACTION_MARKERS = (

eq_layer-0.2.5/eq_layer/json_contract.py

@@ -0,0 +1,41 @@
+"""Unambiguous finite UTF-8 JSON for externally supplied transcripts and cases."""
+
+from __future__ import annotations
+
+import json
+import math
+from typing import Any
+
+
+def _unique_keys(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    output: dict[str, Any] = {}
+    for key, value in pairs:
+        if key in output:
+            raise ValueError("duplicate JSON object key")
+        output[key] = value
+    return output
+
+
+def _finite_float(value: str) -> float:
+    number = float(value)
+    if not math.isfinite(number):
+        raise ValueError("non-finite JSON number")
+    return number
+
+
+def _reject_constant(value: str) -> None:
+    raise ValueError(f"non-standard JSON constant: {value}")
+
+
+def loads(text: str) -> Any:
+    data = json.loads(
+        text,
+        object_pairs_hook=_unique_keys,
+        parse_float=_finite_float,
+        parse_constant=_reject_constant,
+    )
+    try:
+        json.dumps(data, ensure_ascii=False, allow_nan=False).encode("utf-8")
+    except UnicodeError as exc:
+        raise ValueError("JSON text must contain valid UTF-8") from exc
+    return data

{eq_layer-0.2.3 → eq_layer-0.2.5}/eq_layer/model_state.py

@@ -21,8 +21,6 @@ from typing import Any
 # estimator, so its concrete type is deliberately not pinned here.
 FITTED = object()
 
-_FLOAT_TYPES = (int, float)
-
 
 class ModelStateError(ValueError):
     """A persisted model artifact failed schema validation at load time."""

{eq_layer-0.2.3 → eq_layer-0.2.5}/eq_layer/preferences.py

@@ -5,7 +5,6 @@ from dataclasses import asdict, dataclass, replace
 
 from .textnorm import normalise_light as _normalise
 
-
 SESSION_SCOPE_PATTERNS = (
     r"\bbundan sonra\b",
     r"\bbu sohbet(?:te| boyunca)\b",
@@ -51,8 +50,7 @@ def _session_scoped(text: str) -> bool:
     if any(re.search(pattern, low) for pattern in SESSION_SCOPE_PATTERNS):
         return True
     return bool(
-        STRONG_TURKISH_STYLE_PATTERN.search(low)
-        or STRONG_ENGLISH_STYLE_PATTERN.search(low)
+        STRONG_TURKISH_STYLE_PATTERN.search(low) or STRONG_ENGLISH_STYLE_PATTERN.search(low)
     )
 
 
@@ -60,7 +58,7 @@ def _updates(text: str) -> dict:
     low = _normalise(text)
     updates: dict[str, object] = {}
 
-    if re.search(r"\b(kısa|öz|brief|concise)\b", low):
+    if re.search(r"\b(kısa|öz|brief|briefly|concise)\b", low):
         updates["verbosity"] = "low"
     if re.search(r"\b(detaylı|ayrıntılı|detailed)\b|\bin detail\b", low):
         updates["verbosity"] = "high"
@@ -68,12 +66,7 @@ def _updates(text: str) -> dict:
     if re.search(r"\b(net|direkt|doğrudan|direct)\b|\bstraight to the point\b", low):
         updates["directness"] = "high"
 
-    if (
-        "tahmin etme" in low
-        or "uydurma" in low
-        or "don't guess" in low
-        or "do not guess" in low
-    ):
+    if "tahmin etme" in low or "uydurma" in low or "don't guess" in low or "do not guess" in low:
         updates["no_guess"] = True
 
     if (

{eq_layer-0.2.3 → eq_layer-0.2.5}/eq_layer/response_experiment.py

@@ -9,7 +9,7 @@ import subprocess
 import threading
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Iterable
+from typing import Callable, Iterable
 
 from .auditor import audit_from_generation_metadata, regeneration_instruction
 from .policies import Selector
@@ -19,8 +19,6 @@ from .trained_affect import TrainedAffect
 from .trained_intent import TrainedIntent
 from .trained_subtext import TrainedSubtext
 
-
-
 LEAKAGE_FIELDS = {
     "expected_policy",
     "expected_intent",
@@ -49,19 +47,23 @@ def _force_kill(process: subprocess.Popen) -> None:
     try:
         process.terminate()
     except OSError:
+        # The child may already have been reaped by the OS.
         pass
     try:
         process.wait(timeout=5)
         return
     except subprocess.TimeoutExpired:
+        # Ignored the graceful signal; escalate to kill below.
         pass
     try:
         process.kill()
     except OSError:
+        # The child exited between the timeout and the kill.
         pass
     try:
         process.wait(timeout=5)
     except subprocess.TimeoutExpired:
+        # Last-resort wait; nothing further can be done without a block.
         pass
 
 
@@ -162,17 +164,16 @@ def select_stratified_cases(cases: list[dict], limit: int) -> list[dict]:
             deficit += quotas[stratum] - available
             quotas[stratum] = available
 
+    # target <= len(cases), and quota sums to target. Therefore when a
+    # deficit exists, at least one stratum has spare capacity; an exhausted
+    # full pass is mathematically impossible for valid inputs.
     while deficit > 0:
-        progressed = False
         for stratum in strata:
             if quotas[stratum] < len(groups[stratum]):
                 quotas[stratum] += 1
                 deficit -= 1
-                progressed = True
                 if deficit == 0:
                     break
-        if not progressed:
-            break
 
     selected: list[dict] = []
     max_quota = max(quotas.values(), default=0)
@@ -198,6 +199,17 @@ def stable_case_seed(global_seed: int, case_id: str) -> int:
     return int.from_bytes(digest[:4], "big", signed=False)
 
 
+# The experiment's own clock. Reproducibility is a property of the artifact, so
+# the wall clock must never leak into a generated record: the default is a
+# fixed epoch and callers who need a real timestamp inject their own clock.
+DEFAULT_EXPERIMENT_CLOCK_EPOCH = 0.0
+
+
+def _fixed_experiment_clock() -> float:
+    """Default experiment clock: a constant, so runs differ only by content."""
+    return DEFAULT_EXPERIMENT_CLOCK_EPOCH
+
+
 def file_sha256(path: str | Path) -> str:
     digest = hashlib.sha256()
     with open(path, "rb") as fh:
@@ -349,7 +361,7 @@ class CommandModel:
 
     @staticmethod
     def _decode_response(raw: str) -> str:
-        if not raw:
+        if not raw.strip():
             raise RuntimeError("Model command returned an empty response.")
 
         try:
@@ -654,7 +666,18 @@ def generate_pairs(
     auditor_regenerations: int = 0,
     length_matched_arm: bool = False,
     length_profiles: tuple[str, ...] | None = None,
+    rng: random.Random | None = None,
+    clock: Callable[[], float] | None = None,
 ) -> list[dict]:
+    """Generate the same-model baseline/EQ pairs for one experiment run.
+
+    Generation is deterministic: the only randomness is the control-arm
+    shuffling, seeded from ``seed``, and it is quarantined behind the injectable
+    ``rng`` so a caller can supply the same generator without re-deriving it
+    from the seed. Any timestamp is quarantined behind ``clock``, whose default
+    is a fixed epoch, so the same experiment plus the same fixture serialises
+    to identical bytes.
+    """
     if auditor_regenerations not in {0, 1}:
         raise ValueError("auditor_regenerations must be 0 or 1.")
     profiles = tuple(length_profiles or ())
@@ -665,7 +688,8 @@ def generate_pairs(
                 f"{sorted(LENGTH_CONTROL_PROFILES)}"
             )
 
-    rng = random.Random(seed)
+    rng = rng if rng is not None else random.Random(seed)
+    clock = clock if clock is not None else _fixed_experiment_clock
     output: list[dict] = []
     seen: set[str] = set()
 
@@ -769,6 +793,7 @@ def generate_pairs(
                     "model_id": model.model_id,
                     "temperature": model.temperature,
                     "pair_seed": pair_seed,
+                    "generated_at_epoch": round(float(clock()), 6),
                     "order": ["baseline", "eq", *controls],
                     "same_model_both_arms": True,
                     "annotations_used": bool(annotated),

{eq_layer-0.2.3 → eq_layer-0.2.5}/eq_layer/tracker.py

@@ -30,7 +30,8 @@ class StanceResolver(Protocol):
         self,
         messages: list[dict],
         annotated: dict | None = None,
-    ) -> StanceDecision: ...
+    ) -> StanceDecision:
+        pass  # pragma: no cover - Protocol stub
 
 
 @dataclass

{eq_layer-0.2.3 → eq_layer-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "eq-layer"
-version = "0.2.3"
+version = "0.2.5"
 description = "Inspectable intent, affect, repair, uncertainty, and factored-action control for LLM responses"
 readme = "README.md"
 license = { text = "MIT" }

eq_layer-0.2.3/.gitignore

@@ -1,9 +0,0 @@
-__pycache__/
-*.py[cod]
-.venv/
-venv/
-.env
-.npmrc
-.DS_Store
-.idea/
-.vscode/